FastAgentic vs standalone PydanticAI

This is not a competitive comparison. PydanticAI is a dependency of many FastAgentic projects — they’re complementary. The point of this page is to make clear what PydanticAI explicitly doesn’t try to do, so you don’t end up rebuilding it by accident.

What PydanticAI gives you

PydanticAI’s scope is deliberate and sharp:

• A clean, type-safe agent API.
• Tool calling with typed arguments.
• Structured outputs validated by Pydantic.
• Multi-model support (OpenAI, Anthropic, Gemini, Ollama, etc.).
• Streaming primitives.
• Dependency injection for agent context.
• Usage tracking.

It does not try to be a web framework. It does not try to persist state. It does not provide MCP or A2A. This is a feature, not a gap — PydanticAI is lighter and more composable for it.

What standalone PydanticAI leaves to you

If you take a PydanticAI agent and try to ship it, here’s the list of things that are now your problem:

1. HTTP surface. You need FastAPI, uvicorn, a streaming response handler, and request validation.
2. MCP exposure. You want Claude and Cursor to call your agent? You need an MCP server.
3. A2A skills. You want other agents to discover yours? A2A advertising is on you.
4. Auth. OAuth2/OIDC, scopes, multi-tenant context propagation.
5. Cost governance. PydanticAI tracks usage; it does not enforce budgets. You need to write the “stop this tenant at $100/day” logic yourself.
6. Durability. Process restart = dead run. You need Redis/Postgres/S3 and a resumption protocol.
7. Observability. PydanticAI has hooks; you still need to wire them into OTel, Langfuse, or Datadog.
8. Audit. Regulated workloads need an immutable trail of decisions and tool calls. Write it.

Every team we’ve worked with who started with “just PydanticAI” ended up building this stack. Usually twice — once in a hurry, once properly after the first version broke.

What FastAgentic adds

FastAgentic’s PydanticAIAdapter is first-class. You pass your PydanticAI Agent to FastAgentic and get:

• A REST route with streaming SSE.
• An MCP tool with the same arguments and output schema.
• An A2A skill discoverable by other agents.
• OAuth2/OIDC auth with scoped access control.
• Cost tracking that extends PydanticAI’s usage data with pricing and budget enforcement.
• Durable resumption via StepTracker or run_opaque.
• OpenTelemetry spans covering both the FastAgentic pipeline and the PydanticAI internals.
• An audit log of every tool call, model call, and decision.

from pydantic_ai import Agent
from fastagentic import App, agent_endpoint
from fastagentic.adapters import PydanticAIAdapter

pydantic_agent = Agent(
    "anthropic:claude-sonnet-4-6",
    system_prompt="You are a careful research assistant.",
)

app = App(auth="oidc", checkpoint_store="redis://localhost")

@agent_endpoint("/research", adapter=PydanticAIAdapter(pydantic_agent))
async def research(query: str) -> str: ...

That’s the whole app. It’s production-ready.

When standalone PydanticAI is fine

• Library code that another service will call.
• Batch jobs where you don’t need HTTP at all.
• CLI tools.
• Internal notebooks and experiments.

When FastAgentic earns its keep

• Anything user-facing or API-shaped.
• Multi-tenant workloads.
• Anything audit-regulated.
• Anything that must survive a crash.
• Anything your ops team has to page on.

Write your agents in PydanticAI. Ship them with FastAgentic.