For two years the question "which Python agent framework?" meant choosing between a graph and a cast of characters. LangGraph gave you nodes and edges; CrewAI gave you roles and a process; AutoGen gave you a room full of agents talking. They were powerful and they were heavy, and a lot of teams quietly discovered that what they actually wanted was a typed function call to a model with some retries bolted on.
That gap is what the new generation fills. Three frameworks — Pydantic AI, the OpenAI Agents SDK, and Agno — share a vocabulary of "lightweight" and "type-first," and on the surface they look like three flavors of the same idea. They are not. The genuinely useful insight, the one that survives the marketing, is that these three disagree about what an agent framework even owns. Pick on that axis and the choice gets easy. (If you are still weighing the heavyweights, that is a separate piece: LangGraph vs CrewAI vs AutoGen.)
Pydantic AI: own the type boundary, nothing more
Pydantic AI is built by the team behind Pydantic, the validation library that already sits under most of your data plumbing, and the tagline is exactly as literal as it sounds: "AI Agent Framework, the Pydantic way." It is model-agnostic — the repo lists OpenAI, Anthropic, Gemini, DeepSeek, Grok, Cohere, Mistral, and Perplexity — and at roughly 18k GitHub stars it is the smallest of the three by adoption while being arguably the most opinionated about one specific thing.
That thing is the type boundary. You declare your output as a Pydantic model, and the framework guarantees the LLM hands back exactly that structure, with reflection-based self-correction that re-prompts the model when validation fails. Agents are generic in both the dependencies they accept and the output they return, so your editor and type checker actually understand your agent. Add dependency injection — passing connections, config, and logic into tools and instructions — and observability through Logfire, the team's OpenTelemetry platform, and you get what its users keep calling the "FastAPI feeling": a thin, typed seam between your code and the model, and a deliberate refusal to own anything past it.
Pydantic AI does not want to be your memory layer or your control plane. It wants the boundary where untyped model output becomes typed Python, and it wants that boundary airtight.
OpenAI Agents SDK: own the orchestration primitives, stay thin
The OpenAI Agents SDK is the production-ready successor to Swarm, OpenAI's 2024 educational experiment, and it carries Swarm's minimalism forward on purpose. The whole framework is four primitives:
- Agents — an LLM with instructions and tools
- Handoffs — one agent delegating to another
- Guardrails — validation on inputs and outputs
- Sessions — automatic conversation history across runs
That is essentially the entire surface area, and the documentation leans into "very few abstractions" as a feature rather than an apology. The name misleads: despite "OpenAI" in the title, the SDK is provider-agnostic, supporting the Responses and Chat Completions APIs plus 100+ other models through LiteLLM. At around 27k stars it is the middle child by adoption and the one with the clearest philosophy — it owns orchestration patterns (how agents hand off, how you guard them, how state persists) and refuses to own anything else. No built-in vector store, no knowledge layer, no runtime. If you want those, you bring them. The bet is that orchestration primitives are the durable part and everything else is your application's business.
Agno: own the whole runtime
Agno (formerly Phidata) makes the opposite bet, and at roughly 40k stars it is the most-starred of the three. Its self-description shifted from "build agents" to "build, run, and manage agent platforms," and that verb change is the whole story. Agno ships memory, knowledge and RAG, session storage, guardrails, human-in-the-loop, context compression, MCP, and 100+ toolkits in the box — and then it ships AgentOS, a control plane with a UI that you run in your own cloud to manage the agents you built.
Agno is also the framework loudest about performance. Its benchmarks claim agents instantiate in roughly 2 microseconds using about 3.75 KiB each, which it frames as 529x faster than LangGraph, 57x faster than Pydantic AI, and 70x faster than CrewAI. Read those honestly: they measure instantiation overhead, not end-to-end latency, which is dominated by the LLM call regardless of framework. To Agno's credit, its own docs tell you to run the benchmark yourself rather than trust the number. The speed is real and mostly irrelevant to your p99; what is relevant is that Agno is the only one of the three offering to own your stack from agent definition all the way up to a management UI.
Pydantic AI owns the type boundary. The OpenAI SDK owns the orchestration primitives and stops. Agno owns the runtime, the memory, and the control plane. The frameworks barely overlap — they answer different questions.
How to choose
The decision is not about which API reads nicest. It is about how much of the stack you want a third party to own.
- Choose Pydantic AI if you already live in typed Python and your real pain is unreliable model output. You want a clean, validated seam and you intend to own memory, storage, and orchestration yourself. The FastAPI crowd will feel at home immediately.
- Choose the OpenAI Agents SDK if you want the smallest possible orchestration layer — handoffs and guardrails as first-class concepts — and you are comfortable assembling the rest. It is the right pick when you distrust frameworks that do too much, and the LiteLLM escape hatch means you are not locked to OpenAI.
- Choose Agno if you want batteries included and a control plane on day one: built-in memory and knowledge, and AgentOS to run and watch it all. It is the most framework of the three, in both the good sense (less to build) and the wary sense (more to depend on).
The trap is evaluating all three on a toy example, where they look nearly identical, and missing that the toy hides the only question that matters. A weekend prototype runs fine on any of them. A system you maintain for two years will be shaped by who owns the memory, who owns the runtime, and who owns the boundary where the model's guesswork becomes your program's truth. Decide that first. The syntax is the easy part.
