Pydantic AI

Pydantic AI is an open-source Python framework for building large language model (LLM) agents, developed by Pydantic Services Inc. and released in beta on December 2, 2024.^[1][2] The framework provides a type-safe, model-agnostic abstraction layer on top of provider SDKs from Anthropic, OpenAI, Google, Mistral, Groq, Cohere, and Ollama, with structured outputs validated through Pydantic models.^[3][4] Designed by Samuel Colvin and the team behind the pydantic data-validation library, the project applies the same "type hints as schema" approach to agent construction, with explicit primitives for dependency injection, tool registration, streaming, and model context protocol integration.^[4][5] Pydantic AI reached its 1.0 stable release on September 4, 2025, after nine months in 0.x development and roughly 15 million PyPI downloads.^[6][7] The framework then shipped its 2.0 release on June 23, 2026, after seven public betas, reorganizing agent behavior around a single composable primitive called a "capability" and moving most higher-level features into a separate first-party package, the Pydantic AI Harness.^[34][35]

History

Pydantic AI grew out of pydantic, the Python data-validation library that Colvin created in 2017 to put runtime semantics on Python's PEP 484 type hints.^[8][9] Pydantic v1.0 shipped in October 2019, and by 2023 the library was being downloaded around 22 million times per month from PyPI, with adoption inside openai, anthropic, and Google through their respective Python SDKs.^[9][10] Colvin incorporated Pydantic Services Inc. in 2022 and announced a seed round led by sequoia Capital on February 16, 2023, with participation from Partech and Irregular Expression.^[11] Crunchbase and trade press later reported the seed amount at $4.7 million.^[12][13]

On October 1, 2024, Pydantic announced a $12.5 million Series A led by Sequoia, with Partech and Irregular Expression returning and angels including Logan Kilpatrick and Jason Liu joining the round.^[12][14] The same announcement marked the general-availability launch of Pydantic Logfire, the company's observability platform, which had spent five months in open beta.^[14] Total disclosed funding stood at $17.2 million as of late 2024.^[12]

PydanticAI was first announced publicly on December 2, 2024, when Samuel Colvin published the project's documentation site at ai.pydantic.dev and pushed the initial 0.0.1 series to PyPI.^[2][15] The repository was open-sourced under the MIT license on GitHub at pydantic/pydantic-ai.^[4] Simon Willison, in a blog post the same day, described the framework as "an Agent Framework / shim to use Pydantic with LLMs" and noted that many existing tools already use Pydantic for defining JSON schemas in function-calling contexts.^[15] Coverage in VentureBeat and InfoQ characterized the release as "model-agnostic" and noted that initial provider support included openai, gemini, and groq, with anthropic support planned for a subsequent release.^[1][16]

The project iterated rapidly through 2025. On January 15, 2025, Colvin announced v0.0.19, which introduced graph support as the largest new feature since launch, allowing developers to model agent control flow as type-safe directed graphs.^[17] After nine months of feedback and approximately 15 million downloads, the team shipped v1.0 on September 4, 2025, with an API stability commitment of at least six months and an additional six months of security fixes following any future v2 release.^[6][18] By mid-2025 PydanticAI was, by Pydantic's own measurement, the fastest-growing agent framework by PyPI downloads, with eight million downloads per month.^[19] By May 2026 the repository had crossed 17,000 GitHub stars.^[4]

On June 23, 2026, after seven public betas, Pydantic released Pydantic AI v2, the framework's second major version and its largest architectural change since launch.^[34][35] V2 introduced the "capability" as the core unit of agent behavior, split most higher-level features into the separate first-party Pydantic AI Harness, slimmed the default install, and shortened the version policy's breaking-change window from six months to three.^[34] Point releases followed roughly daily in the weeks after launch, reaching v2.5.1 by July 6, 2026.^[35]

Design principles

The launch documentation framed PydanticAI's design as an attempt to bring "that FastAPI feeling to GenAI app and agent development," extending the type-hints-first philosophy of pydantic from data validation to LLM orchestration.^[3][4] The framework is built around four explicit principles.

Type safety throughout. Agents are parameterized generic objects: an Agent[DepsT, OutputT] declares both the type of dependencies passed into tools and the type of structured output the model must return.^[20] Tool functions, system-prompt callbacks, and output validators carry full mypy and Pyright support, and Pydantic AI documents that its goal is to "give your IDE or AI coding agent as much context as possible for auto-completion and type checking, moving entire classes of errors from runtime to write-time."^[3]

Model-agnostic provider abstraction. A single Agent interface dispatches across provider SDKs. The 1.0 release ships with native support for openai, anthropic, Google (gemini), Groq, mistral ai, cohere, deepseek, xAI's Grok, Perplexity, ollama, Azure AI Foundry, Amazon Bedrock, Google Cloud Vertex, OpenRouter, Together AI, Fireworks AI, cerebras, Hugging Face, GitHub Models, Heroku AI, Vercel AI Gateway, Nebius, OVHcloud, Alibaba Cloud, and SambaNova.^[4][21]

No global state, explicit dependency injection. PydanticAI deliberately omits the global registries, "chains" objects, and runnables abstractions common in langchain. Dependencies (database handles, HTTP clients, configuration) are passed to an agent run via a deps argument and surfaced inside tool functions through a RunContext[DepsT] parameter, mirroring the dependency-injection style that made FastAPI testable.^[22]

Observable by default. PydanticAI emits OpenTelemetry traces using the GenAI semantic conventions rather than a proprietary trace format, allowing the same traces to be consumed by Pydantic Logfire, Grafana, Datadog, Honeycomb, or any OTel collector.^[23][24] Colvin has argued that "the engineering quality is far below that of the rest of the Python ecosystem" in much of the agent-framework space and has cited the team's 100 percent test coverage and unit-tested documentation examples as explicit differentiators.^[25][6]

Architecture

The framework centres on five primitives: the Agent, the Model, the RunContext, tools (registered via decorators or constructor arguments), and the output_type.^[20]

Agent

An Agent is a generic class parameterized over dependency and output types, typically constructed as Agent[DepsT, OutputT].^[20] At construction time the agent is given a model identifier (for example openai:gpt-4o or anthropic:claude-3-5-sonnet-latest), one or more instructions strings or callables, an optional deps_type, and an optional output_type (which can be a Pydantic model, a TypedDict, a primitive type, a union of types, or a callable).^[20][26] Three principal entry points exist on an agent: run (async), run_sync (blocking), and run_stream (yields tokens and partial structured output as the model generates).^[20]

Model abstraction

A Model object wraps a provider SDK. Pydantic AI ships concrete implementations including OpenAIModel, AnthropicModel, GoogleModel, GroqModel, MistralModel, CohereModel, and OllamaModel, plus pass-through implementations for Bedrock, Vertex, OpenRouter, and other gateway providers.^[4][21] Each Model normalises the provider's request and response format into a common message-history representation, which means the same agent code can be retargeted across providers by changing the model string.^[3]

RunContext

RunContext[DepsT] is the carrier type for per-run state. Tool functions and validators receive a RunContext as their first parameter, exposing ctx.deps (the typed dependency object), ctx.usage (token and request counters), ctx.model (the active model), and ctx.messages (the conversation history so far).^[22] Because the DepsT parameter is propagated by the type system, tool authors get full IDE support for dependency attributes.^[22]

Tools

Tools are functions the LLM may call. Pydantic AI provides two registration decorators: @agent.tool, for tools that take a RunContext parameter and have access to dependencies, and @agent.tool_plain, for stateless tools.^[26] Tool argument schemas are derived automatically from the function's type hints and docstring; Pydantic AI extracts the docstring summary as the tool description and parses parameter descriptions out of Google, NumPy, or Sphinx-style docstring sections.^[26] At runtime the LLM's tool-call arguments are validated against the function's signature via Pydantic, and validation failures are returned to the model as a retry prompt rather than raised as Python exceptions.^[26]

Toolsets and ToolDefinition

A Toolset is a collection of related tools that can be attached to multiple agents. ToolDefinition is the lower-level dataclass that describes a single callable to the model, with fields for name, description, parameters_json_schema, and strict.^[27] PydanticAI auto-generates ToolDefinition objects from decorated functions, but they can also be constructed manually, which is the mechanism used by integrations with external tool sources such as model context protocol servers.^[27]

Output validation

The output_type parameter on an Agent instructs the framework to coerce the model's final response into a specific structured type.^[20] When output_type is a Pydantic model, PydanticAI uses provider-native structured output APIs (JSON mode, response_format, or tool-call mode depending on the provider) and validates the result through Pydantic.^[26] If validation fails, the agent automatically resubmits the failure as a system message and asks the model to try again, with the number of retries bounded by an agent-level retries setting.^[26] The same machinery supports output_type as a union of Pydantic models, in which case the model is asked to select the correct branch as part of its response.^[26]

Streaming

Agent.run_stream exposes an async context manager yielding a StreamedRunResult. Callers can iterate raw text tokens, partially validated structured output (where Pydantic AI continuously re-parses the in-flight JSON against the target schema), or tool-call events.^[3] For models that support delta-encoded tool calls (OpenAI, Anthropic), Pydantic AI reconstructs argument fragments incrementally.^[3]

Graph runtime

Beginning with v0.0.19 in January 2025, Pydantic AI represents an agent run internally as a directed graph of nodes; each node returns the next node, and the runtime advances the graph until a terminal End node is reached.^[17] The graph implementation supports Mermaid diagram export and can be paused and resumed across a Temporal workflow, enabling durable agent execution.^[17][6]

What is new in Pydantic AI V2?

Pydantic AI v2.0.0 shipped on June 23, 2026, following seven public betas, and reorganizes the framework around a single new primitive called a capability.^[34][35] In the launch post, "Pydantic AI v2: capabilities, a leaner core, and the Harness," the team wrote that "Pydantic AI v2 is here, and your agents have never been more capable," adding that it had "shipped Pydantic AI v1 last September" and "put out more than a hundred releases since, without once breaking your code."^[34] With v2, the project also tightened its release process: the minimum window between potentially breaking major versions moved from six months to three, reflecting a faster cadence.^[34]

Capabilities. A capability is the central organizing concept of v2. According to Pydantic's documentation, "A capability bundles an agent's instructions, tools, lifecycle hooks, and model settings into a single, composable unit," described as "the unit of agent behavior that lives in the loop."^[34][39] Because capabilities are serializable, "an agent can be loaded from a spec file," and the surface is small enough that an LLM can author one, enabling agents that are defined declaratively rather than only in imperative Python.^[34][39]

Built-in capabilities. V2 ships several first-party capabilities: Thinking (extended reasoning unified across providers), CodeMode (sandboxed code execution that collapses many tool calls into one), WebSearch (native provider web search where available, with a local fallback), and ToolSearch (which lets a model discover tools on demand instead of receiving hundreds up front).^[34][38]

The Harness and a leaner core. V2 splits the project into a small, stable core and a separate first-party package, the Pydantic AI Harness, described in the launch post as "the batteries for your agent (memory, guardrails, context management, file system access, code mode, and more)."^[34] Capabilities can iterate quickly in the Harness and graduate into core once they prove broadly essential. The base install was also slimmed: per the launch post, "uv add pydantic-ai still includes OpenAI, Anthropic, and Google by default, but the long tail of providers (bedrock, groq, mistral, and friends) is now opt-in."^[34] The package supports Python 3.10 through 3.14 and remains MIT-licensed.^[7]

What are Code Mode and Monty?

Code Mode is the v2 capability that wraps an agent's tools into a single run_code tool, letting the model write Python that calls multiple tools with loops, conditionals, variables, and asyncio.gather inside one tool call rather than issuing a separate tool call for each step.^[38] The generated code executes inside Monty, an experimental Python interpreter that Pydantic wrote in Rust specifically for running LLM-generated code.^[37] Monty runs in-process with startup times measured in single-digit microseconds rather than the hundreds of milliseconds typical of container-based sandboxes; the package is roughly 4.5 MB, adds about 5 MB of memory when embedded in CPython, and blocks filesystem, environment-variable, and network access unless the developer explicitly exposes them through external functions.^[37] Pydantic describes Monty as experimental and not yet production-ready, supporting only a subset of Python.^[37]

How does durable execution work in Pydantic AI?

Durable execution lets a Pydantic AI agent, in the documentation's words, "preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability," while remaining compatible with streaming and Model Context Protocol tools.^[36] Pydantic AI officially supports four durable-execution backends: Temporal, DBOS, Prefect, and Restate, with additional community integrations for Kitaru and Apache Airflow.^[36] These integrations are, per Pydantic, "co-maintained by the Pydantic and vendor teams and only use Pydantic AI's public interface, so they also serve as a reference for integrating with other durable systems."^[36] Temporal and Restate use a journal-and-replay model in which completed steps return cached results after a crash, while DBOS runs in-process as a library and checkpoints workflow state to a database.^[36] In v2, durable execution is being reworked into the capability model alongside the other built-in capabilities.^[34]

Supported model providers

The table below summarises the providers that ship in the core pydantic-ai package as of v1.x. Feature columns reflect the framework's documented support for tool calling, streaming, structured outputs, and vision input on at least one model in the provider's catalogue.^[4][21]

Scroll sideways for more →

Provider names are accepted as model strings of the form provider:model_name, for example openai:gpt-4o, anthropic:claude-3-5-sonnet-latest, or google-vertex:gemini-1.5-pro.^[3][20] As of the v2 release, the base pydantic-ai install ships OpenAI, Anthropic, and Google support by default, while other providers such as Amazon Bedrock, Groq, and Mistral are installed as opt-in extras.^[34]

Comparison to LangChain, LlamaIndex, and DSPy

Pydantic AI occupies a distinct niche in the Python agent-framework ecosystem compared to the three best-known incumbents.^[28] For a broader, use-case-by-use-case ranking of the field, see best AI agent frameworks.

langchain, first released by Harrison Chase in late 2022, popularised the "chain" and "runnable" abstractions, the LangChain Expression Language (LCEL), and a large surface area of provider, retriever, and tool integrations.^[28] PydanticAI deliberately omits LCEL-style pipe operators and chain objects; control flow is ordinary Python with explicit if and for statements, and tools are plain functions.^[4][25] Trade-press analyses position Pydantic AI as preferable when type safety, structured outputs, and Python-native validation matter most, and LangChain as preferable when "fast prototyping, a massive community, and out-of-the-box integrations" are the priority.^[28] Pydantic AI does, however, depend on pydantic itself, which is in turn a dependency of LangChain, LlamaIndex, the openai SDK, the anthropic SDK, and Google's ADK, so the libraries are not mutually exclusive at runtime.^[4]

llamaindex, developed by Jerry Liu's company and originally branded GPT Index, focuses on retrieval-augmented generation over heterogeneous data sources and offers its own event-driven Workflows abstraction.^[28] PydanticAI is not a retrieval framework; it has no first-party document loaders, chunkers, or vector-store adapters, and projects that need those features typically use LlamaIndex (or a vector database directly) alongside PydanticAI tools.^[4][28]

dspy, the Stanford-originated framework by Omar Khattab and collaborators, treats prompts as compilable programs and optimises them automatically via teleprompters.^[28] PydanticAI does not perform prompt optimisation; instructions are author-written strings or callables and remain unchanged across runs.^[20] The two frameworks address adjacent problems: DSPy aims at programmatic prompt design, PydanticAI aims at type-safe agent execution, and a DSPy-compiled program could in principle be wrapped as a PydanticAI tool.^[28]

A closer comparison is to the instructor library, another Pydantic-centred library for structured LLM outputs that predates PydanticAI. Instructor patches provider SDKs to return Pydantic models from chat.completions.create calls, while PydanticAI provides the higher-level Agent, tool, and graph machinery; the two are complementary and Instructor's author Jason Liu participated in Pydantic's Series A as an angel investor.^[14] Pydantic AI also sits alongside the claude agent sdk and the openai agents sdk as a framework-level rather than provider-specific approach to agent construction.^[4]

Logfire integration

Pydantic Logfire is the company's observability platform, launched in beta in spring 2024 and reaching general availability on October 1, 2024 alongside the Series A announcement.^[14][29] Logfire is built on opentelemetry under the hood, with open-source SDKs for Python, JavaScript/TypeScript, and Rust, and a managed backend that stores traces in a PostgreSQL-compatible store queryable through standard SQL.^[29][24] The Python SDK is MIT-licensed and wraps the OpenTelemetry Python package.^[24]

For PydanticAI users, Logfire integration is a one-line logfire.configure() call followed by logfire.instrument_pydantic_ai(); thereafter every agent run is captured as an OTel trace with spans for each model call, tool call, and validation step.^[24] The Logfire UI provides a conversation-panel view of agent runs, with token counts, model latency, cost estimates, and tool-call argument inspection.^[29] Because PydanticAI emits semantic-convention-compliant traces, the same data can be sent to Datadog, Grafana Cloud, Honeycomb, or any OTel collector without Logfire.^[23][24]

Adoption

PydanticAI's repository at github.com/pydantic/pydantic-ai crossed 16,000 stars by early 2026, reached over 17,000 stars by May 2026, and stood at roughly 18,300 stars by July 2026.^[4][30] Pydantic's own blog reported that PydanticAI was the fastest-growing agent framework by PyPI downloads in 2025, with approximately eight million downloads per month at peak.^[19] Cumulative downloads through the v1.0 release on September 4, 2025 reached approximately 15 million.^[6]

The framework has been the subject of conference talks by Colvin, including an "Agent Hour" appearance at the MLOps Community on December 19, 2024 titled "Why we built PydanticAI, and why you might care," and an extended interview on the Latent Space podcast covering the graph-based runtime.^[31][25] Colvin has also discussed PydanticAI on Software Engineering Daily and the AI Engineering Podcast.^[32][33]

The underlying pydantic library, which acts as PydanticAI's validation layer, was reported by Pydantic in February 2026 to have crossed 10 billion total PyPI downloads, with monthly downloads exceeding 550 million.^[19] Pydantic itself is a transitive dependency of the openai Python SDK, the anthropic SDK, Google's GenAI SDK, langchain, llamaindex, instructor library, CrewAI, and Hugging Face Transformers, which gives PydanticAI an unusually deep integration surface with the rest of the Python LLM ecosystem.^[4]

Funding context

Pydantic Services Inc. was incorporated in 2022 to commercialise Colvin's open-source work; the company emerged from stealth on February 16, 2023, when Colvin announced a seed round led by sequoia Capital with participation from Partech, Irregular Expression, and angels including Bryan Helmig of Zapier, Tristan Handy of dbt Labs, and David Cramer of Sentry.^[11] Crunchbase and Nordic9 later reported the seed at $4.7 million.^[12][13]

On October 1, 2024, the company announced a $12.5 million Series A also led by Sequoia, bringing total disclosed funding to $17.2 million.^[12][14] TechCrunch reported that the Series A capital was earmarked "primarily for salaries" and for expanding the team beyond 13 employees, "mostly developers."^[12] Colvin described the strategic intent as transforming Pydantic from "an open source project to a full stack AI engineer platform" combining the validation library, Logfire observability, and PydanticAI agent framework.^[32][14] PydanticAI was developed and released within that Series A funding window, with the December 2024 launch occurring two months after the Series A close.^[2][14]

See also

• pydantic
• best ai agent frameworks
• langchain
• langgraph
• llamaindex
• dspy
• instructor library
• claude agent sdk
• openai agents sdk
• model context protocol
• function calling
• tool use
• agent
• ai agents
• guardrails
• python

References

1. Carl Franzen, "Python data validator Pydantic launches model-agnostic AI agent development platform", VentureBeat, 2024-12-04. https://venturebeat.com/programming-development/python-data-validator-pydantic-launches-model-agnostic-ai-agent-development-platform. Accessed 2026-05-26. ↩
2. Simon Willison, "PydanticAI", Simon Willison's Weblog, 2024-12-02. https://simonwillison.net/2024/Dec/2/pydanticai/. Accessed 2026-05-26. ↩
3. Pydantic Services, "Pydantic AI: AI Agent Framework, the Pydantic way", ai.pydantic.dev documentation, 2026. https://ai.pydantic.dev/. Accessed 2026-05-26. ↩
4. Pydantic Services, "pydantic/pydantic-ai: AI Agent Framework, the Pydantic way", GitHub repository, 2026. https://github.com/pydantic/pydantic-ai. Accessed 2026-07-08. ↩
5. Samuel Colvin and team, "Pydantic AI overview", Pydantic Docs, 2026. https://pydantic.dev/docs/ai/overview/. Accessed 2026-05-26. ↩
6. Samuel Colvin and David Montague, "Pydantic AI v1: A Predictable & Robust GenAI Framework", Pydantic blog, 2025-09-04. https://pydantic.dev/articles/pydantic-ai-v1. Accessed 2026-05-26. ↩
7. Python Package Index, "pydantic-ai release history", PyPI, 2026. https://pypi.org/project/pydantic-ai/. Accessed 2026-07-08. ↩
8. Beyang Liu, "Exploring Pydantic with Samuel Colvin", Sourcegraph blog, 2023-03. https://sourcegraph.com/blog/exploring-pydantic-with-samuel-colvin. Accessed 2026-05-26. ↩
9. Pydantic Services, "Pydantic HISTORY.md", GitHub, 2026. https://github.com/pydantic/pydantic/blob/main/HISTORY.md. Accessed 2026-05-26. ↩
10. Logan Kilpatrick, "Pydantic 2.0 just released! An overview of the most popular data validation Python package", Around the Prompt (Medium), 2023-07. https://medium.com/around-the-prompt/pydantic-2-0-just-released-an-overview-of-the-most-popular-data-validation-python-package-ae5b5100db2b. Accessed 2026-05-26. ↩
11. Samuel Colvin, "Company Announcement", Pydantic blog, 2023-02-16. https://pydantic.dev/articles/company-announcement. Accessed 2026-05-26. ↩
12. Paul Sawers, "Sequoia backs Pydantic to expand beyond its open source data-validation framework", TechCrunch, 2024-10-01. https://techcrunch.com/2024/10/01/sequoia-backs-pydantic-to-expand-beyond-its-open-source-data-validation-framework/. Accessed 2026-05-26. ↩
13. Nordic9, "Pydantic in a $12.5 million Series A led by Sequoia Capital", Nordic9 News, 2024-10-01. https://nordic9.com/news/pydantic-in-a-125-million-series-a-led-by-sequoia-capital-with-participation-from-partech-and-irregular-expression-alongside-american-angel-investors/. Accessed 2026-05-26. ↩
14. Samuel Colvin, "Announcement: Pydantic Logfire launch & Series A Funding", Pydantic blog, 2024-10-01. https://pydantic.dev/articles/logfire-announcement. Accessed 2026-05-26. ↩
15. Python Package Index, "pydantic-ai 0.0.1 release", PyPI, 2024-10-29. https://pypi.org/project/pydantic-ai/0.0.1/. Accessed 2026-05-26. ↩
16. Sergio De Simone, "PydanticAI: a New Python Framework for Streamlined Generative AI Development", InfoQ, 2024-12-18. https://www.infoq.com/news/2024/12/pydanticai-framework-gen-ai/. Accessed 2026-05-26. ↩
17. Samuel Colvin, "We've just released Pydantic AI v0.0.19. This comes with the biggest new feature since we announced PydanticAI: graph support.", X (Twitter), 2025-01-15. https://x.com/samuel_colvin/status/1879627376990224417. Accessed 2026-05-26. ↩
18. Pydantic Services, "Version policy", Pydantic AI docs, 2026. https://ai.pydantic.dev/version-policy/. Accessed 2026-05-26. ↩
19. Pydantic Services, "Pydantic Just Hit 10 Billion Downloads", Pydantic blog, 2026-02. https://pydantic.dev/articles/pydantic-validation-10-billion-downloads. Accessed 2026-05-26. ↩
20. Pydantic Services, "pydantic_ai.agent API reference", Pydantic AI docs, 2026. https://ai.pydantic.dev/api/agent/. Accessed 2026-05-26. ↩
21. Pydantic Services, "Models and providers", Pydantic AI docs, 2026. https://ai.pydantic.dev/models/. Accessed 2026-05-26. ↩
22. Pydantic Services, "Dependencies", Pydantic AI docs, 2026. https://ai.pydantic.dev/dependencies/. Accessed 2026-05-26. ↩
23. OpenTelemetry, "Semantic conventions for generative AI systems", OpenTelemetry specification, 2026. https://opentelemetry.io/docs/specs/semconv/gen-ai/. Accessed 2026-05-26. ↩
24. Pydantic Services, "Debugging & Monitoring with Pydantic Logfire", Pydantic AI docs, 2026. https://ai.pydantic.dev/logfire/. Accessed 2026-05-26. ↩
25. swyx and Alessio Fanelli, "Agent Engineering with Pydantic + Graphs: with Samuel Colvin", Latent Space podcast, 2025-02. https://www.latent.space/p/pydantic. Accessed 2026-05-26. ↩
26. Pydantic Services, "Function Tools", Pydantic AI docs, 2026. https://ai.pydantic.dev/tools/. Accessed 2026-05-26. ↩
27. Pydantic Services, "pydantic_ai.toolsets API reference", Pydantic AI docs, 2026. https://ai.pydantic.dev/api/toolsets/. Accessed 2026-05-26. ↩
28. Kunal Ganglani, "Pydantic AI vs LangChain 2026: Type-Safe or Flexible, Which Wins?", kunalganglani.com, 2026. https://www.kunalganglani.com/blog/pydantic-ai-vs-langchain. Accessed 2026-05-26. ↩
29. Pydantic Services, "Pydantic Logfire: AI Observability for LLMs, Apps & RAG", logfire.pydantic.dev, 2026. https://logfire.pydantic.dev/. Accessed 2026-05-26. ↩
30. DecisionCrafters, "Pydantic AI: Type-Safe AI Agent Framework with 16.5k GitHub Stars", DecisionCrafters, 2026. https://www.decisioncrafters.com/pydantic-ai-type-safe-ai-agent-framework-with-16-5k-github-stars/. Accessed 2026-05-26. ↩
31. Samuel Colvin, "Why we built PydanticAI, and why you might care: Agent Hour #2", MLOps Community video, 2024-12-19. https://home.mlops.community/public/videos/why-we-built-pydanticai-and-why-you-might-care-samuel-colvin-agent-hour-2-2024-12-19. Accessed 2026-05-26. ↩
32. Jordi Mon Companys, "Pydantic AI with Samuel Colvin", Software Engineering Daily podcast, 2025-12-04. https://softwareengineeringdaily.com/2025/12/04/pydantic-ai-with-samuel-colvin/. Accessed 2026-05-26. ↩
33. Tobias Macey, "Building Production-Ready AI Agents with Pydantic AI", AI Engineering Podcast, 2025. https://www.aiengineeringpodcast.com/episodepage/building-production-ready-ai-agents-with-pydantic-ai. Accessed 2026-05-26. ↩
34. Pydantic, "Pydantic AI v2: capabilities, a leaner core, and the Harness", Pydantic blog, 2026-06-23. https://pydantic.dev/articles/pydantic-ai-v2. Accessed 2026-07-08. ↩
35. Pydantic Services, "Releases, pydantic/pydantic-ai", GitHub, 2026. https://github.com/pydantic/pydantic-ai/releases. Accessed 2026-07-08. ↩
36. Pydantic Services, "Durable Execution: Overview", Pydantic AI docs, 2026. https://pydantic.dev/docs/ai/integrations/durable_execution/overview/. Accessed 2026-07-08. ↩
37. Pydantic, "Pydantic Monty: A Minimal Python Sandbox for AI Agents", Pydantic blog, 2026. https://pydantic.dev/articles/pydantic-monty. Accessed 2026-07-08. ↩
38. Pydantic Services, "Code Mode", Pydantic AI docs, 2026. https://pydantic.dev/docs/ai/harness/code-mode/. Accessed 2026-07-08. ↩
39. Pydantic Services, "Capabilities", Pydantic AI docs, 2026. https://pydantic.dev/docs/ai/core-concepts/capabilities/. Accessed 2026-07-08. ↩