Pydantic AI

Defines agents using Python dataclasses and Pydantic models with full type annotations, enabling compile-time validation of agent state, inputs, and outputs. The Agent class wraps model providers and enforces schema validation on all LLM responses through Pydantic V2's validation engine, catching type mismatches before runtime. This approach moves validation errors from production into development, leveraging IDE type checking and mypy/pyright for static analysis.

Abstracts multiple LLM providers (OpenAI, Anthropic, Google Gemini, AWS Bedrock, DeepSeek, Groq, Ollama) behind a single ModelClient interface, allowing agents to switch providers by changing a single parameter. Each provider has a dedicated integration module that handles API-specific details (authentication, request formatting, streaming protocols, token counting) while exposing a consistent run() and stream() API. The framework automatically handles provider-specific quirks like Anthropic's tool_choice syntax vs OpenAI's function_calling format.

Enables multiple agents to communicate and coordinate through a message-passing protocol. Agents can invoke other agents as tools, passing context and receiving results. The framework handles agent discovery, message routing, and result aggregation, allowing complex multi-agent workflows (e.g., supervisor agent delegating tasks to specialist agents). Supports both synchronous and asynchronous agent-to-agent communication.

Provides a built-in evaluation framework (pydantic-evals) for testing agents against datasets of test cases. Supports defining test datasets with inputs, expected outputs, and evaluation metrics. Includes pre-built evaluators (exact match, semantic similarity, LLM-as-judge) and enables custom evaluators. Generates evaluation reports with pass/fail rates, latency metrics, and cost analysis. Integrates with CI/CD for automated agent testing.

Provides pydantic-graph library for defining agent workflows as directed acyclic graphs (DAGs) where nodes are agents or functions and edges represent data flow. Nodes execute in topological order with automatic dependency resolution. Supports conditional branching, loops, and parallel execution. Graphs are visualized as Mermaid diagrams and can be persisted for replay and debugging. Integrates with the core agent framework for seamless execution.

Supports multimodal inputs including text, images, and other media types. Images can be passed as URLs, base64-encoded data, or file paths, and are automatically converted to provider-specific formats (OpenAI's image_url, Anthropic's image blocks). The framework handles image validation, format conversion, and provider-specific constraints (e.g., image size limits). Supports vision-capable models (GPT-4V, Claude 3 Vision, Gemini Vision) with automatic model selection.

Provides a low-level API (model.request_schema()) for making direct requests to models without the agent framework overhead. Useful for simple tasks that don't require tools, message history, or agent state management. Supports the same provider abstraction and output validation as agents, but with minimal latency and memory overhead. Enables mixing direct model calls with agent-based workflows.

Provides a RunContext object that flows through agent execution, carrying dependencies (database connections, API clients, user context) and runtime state without passing them as function parameters. Dependencies are registered via the Agent.run() method or through a context manager, and are injected into tool functions and system prompts via parameter inspection. This pattern decouples tool implementations from dependency management and enables testing by swapping dependencies at runtime.

Registers Python functions as tools using the @agent.tool decorator, which automatically extracts parameter types, docstrings, and return types to generate OpenAI/Anthropic function schemas. The framework handles tool invocation, parameter validation, and error handling, including support for deferred execution (tools that require user approval before running) and async tools. Tool schemas are generated once at agent definition time and reused across all model calls, reducing overhead.

Provides streaming APIs (agent.run_stream(), agent.stream()) that yield tokens or structured chunks as they arrive from the model, enabling real-time UI updates and progressive output. The framework handles provider-specific streaming protocols (Server-Sent Events for OpenAI, streaming for Anthropic) and buffers tokens into logical chunks (complete words, sentences, or structured fields). Streaming works with both text outputs and structured Pydantic models, validating partial outputs incrementally.

Maintains a message history (list of UserMessage, ModelMessage, ToolReturnMessage objects) that tracks the full conversation state across multiple agent.run() calls. Messages are immutable and typed, enabling type-safe history inspection and replay. The framework automatically manages message ordering, deduplication, and context window management, with support for message pruning strategies (e.g., keep last N messages, summarize old messages) to fit within model token limits.

Supports multiple output modes that control how the model formats its response: text mode (free-form text), JSON mode (structured JSON output), and structured mode (Pydantic model validation). Each mode uses provider-specific features (OpenAI's JSON mode, Anthropic's structured output) to guide the model toward the desired format. The framework automatically validates outputs against the declared schema and retries on validation failure (with configurable retry logic).

Integrates with the Model Context Protocol (MCP) to dynamically discover and invoke tools from external MCP servers at runtime. Agents can connect to MCP servers (local or remote) and automatically expose their tools without manual registration. The framework handles MCP protocol details (JSON-RPC, stdio/HTTP transports) and tool invocation, treating MCP tools identically to @agent.tool decorated functions.

Integrates with Pydantic Logfire and OpenTelemetry to instrument agent execution with detailed traces, metrics, and logs. Automatically captures model calls, tool invocations, token usage, latency, and errors without code changes. Traces are structured hierarchically (agent run → model call → tool invocation) and include full context (prompts, responses, dependencies) for debugging and monitoring. Supports custom instrumentation via context managers and decorators.

Integrates with Temporal and DBOS to enable durable agent execution that survives process crashes and network failures. Agent runs are checkpointed at tool invocation boundaries, allowing execution to resume from the last completed tool call if the process restarts. The framework handles serialization of agent state (message history, dependencies) and coordinates with workflow engines to manage retries and error recovery.