Pydantic AI

Executes LLM agent workflows with full type safety by leveraging Pydantic V2 models to define and validate agent output schemas at runtime. The framework uses a unified Agent class that wraps model providers and enforces structured output validation before returning results to the caller, catching schema mismatches during development rather than in production. This approach integrates with Python's type system for IDE autocomplete and static type checking while maintaining runtime validation guarantees.

Abstracts away provider-specific API differences (OpenAI, Anthropic, Gemini, DeepSeek, Groq, AWS Bedrock, etc.) behind a single unified Agent interface. The framework implements a ModelProvider abstraction layer that handles protocol translation, token counting, streaming format normalization, and tool-calling conventions across 10+ different LLM providers. Developers write agent code once and swap providers by changing a single configuration parameter, with the framework handling all underlying API incompatibilities.

Provides a framework for evaluating agent performance using test datasets and custom evaluators. The framework supports defining test cases with expected outputs, running agents against these cases, and computing metrics (accuracy, latency, cost) across runs. Evaluators are pluggable functions that assess agent outputs against criteria, enabling systematic evaluation of agent quality and performance.

Enables multiple agents to communicate and coordinate with each other, with one agent calling another agent as a tool. The framework handles agent-to-agent message passing, result aggregation, and coordination patterns. This enables building complex multi-agent systems where agents specialize in different tasks and delegate to each other based on the problem at hand.

Provides a graph-based abstraction (pydantic-graph) for defining agent workflows as directed acyclic graphs (DAGs) of nodes and edges. Nodes represent agent steps or decisions, edges represent transitions, and the framework handles execution, state management, and persistence. Workflows can be visualized as Mermaid diagrams and persisted to storage for replay or analysis.

Allows direct requests to language models without the agent abstraction layer, useful for simple completion tasks that don't require tool use or structured output validation. The framework exposes a direct model interface that bypasses agent logic and goes straight to the model provider, with the same provider abstraction and streaming support as agents.

Allows agents to operate in different output modes: streaming mode for token-by-token output, structured mode for validated Pydantic outputs, or hybrid modes combining both. The framework handles mode-specific behavior (buffering for structured mode, streaming for text mode) and ensures validation guarantees are maintained in each mode. Output mode is selected at agent creation time and affects how responses are generated and returned.

Provides a dependency injection system that allows agents to access runtime context (database connections, API clients, user state) through a RunContext object passed during execution. Tools and agent logic can declare dependencies as function parameters, which are resolved from the context at runtime. This pattern decouples agent logic from infrastructure concerns and enables testing by injecting mock dependencies, following patterns similar to FastAPI's dependency system.

Registers Python functions as tools with automatic schema generation from function signatures and docstrings, then translates tool calls across different provider function-calling APIs (OpenAI's format, Anthropic's format, etc.). The framework uses Pydantic to generate JSON schemas from tool function parameters, passes these schemas to the model provider, and handles the provider-specific tool-call response format before executing the actual Python function. This enables models to call tools reliably across all supported providers with a single tool definition.

Supports streaming LLM responses token-by-token or chunk-by-chunk, allowing agents to process partial results as they arrive rather than waiting for complete generation. The framework handles provider-specific streaming formats (Server-Sent Events for OpenAI, streaming for Anthropic, etc.) and exposes a unified async iterator interface. Streaming works with structured output validation, buffering tokens until a complete, valid output is available before returning to the caller.

Maintains conversation history across multiple agent turns, tracking user messages, agent responses, and tool calls in a structured message format. The framework provides a MessageHistory class that stores messages with metadata (role, timestamp, tool calls, results) and handles context window management by intelligently pruning or summarizing older messages when approaching token limits. Messages are typed (UserMessage, ModelMessage, ToolReturnMessage) to enable type-safe history manipulation.

Accepts multimodal inputs (text, images, audio metadata) in agent prompts and tool calls, automatically encoding images as base64 or URLs depending on provider requirements. The framework provides ImageSource abstractions for different image input methods (file paths, URLs, base64 data) and handles provider-specific multimodal format translation. Audio is supported through metadata and transcription integration rather than direct audio streaming.

Integrates with the Model Context Protocol (MCP) standard to discover and register tools from external MCP servers. The framework can connect to MCP servers (stdio, SSE, or custom transports), enumerate available tools and resources, and dynamically register them as agent tools. This enables agents to access tools from external systems without hardcoding tool definitions, supporting dynamic tool discovery and composition.

Integrates with durable execution frameworks (Temporal, DBOS) to preserve agent progress across restarts and failures. The framework can serialize agent state, execution history, and message context to external workflow engines, enabling agents to resume from the last checkpoint if interrupted. This pattern ensures long-running agents don't lose progress due to crashes, network failures, or infrastructure restarts.

Integrates with Pydantic Logfire and OpenTelemetry for comprehensive observability of agent execution. The framework automatically instruments agent runs, tool calls, model requests, and message history, emitting structured logs and traces to observability backends. Developers can inspect agent execution flow, debug tool failures, and monitor model performance without adding instrumentation code.