Six months ago, if you wanted to build an AI agent, you picked a model and wrote a while loop. Today there are eight production-grade agent SDKs, three competing interoperability protocols, and 120+ tools across 11 categories. The ecosystem went from zero to overwhelming in record time.
Here's the uncomfortable truth: most of these frameworks won't exist in 18 months. The agent space is repeating the same pattern as every infrastructure layer before it — an explosion of options followed by ruthless consolidation. Think JavaScript frameworks circa 2015, except the stakes are higher and the timeline is compressed.
I've spent the last three weeks building production agents across six of these frameworks. This is what I learned about what's real, what's hype, and where to place your bets.
The Landscape Right Now
The agent framework space splits cleanly into two camps: provider-native SDKs and independent frameworks.
The provider-native camp is crowded. Anthropic ships the Claude Agent SDK. OpenAI has the Agents SDK (the production successor to Swarm). Google launched ADK in four languages. Microsoft merged AutoGen and Semantic Kernel into a unified Agent Framework. Each is optimized for its own model family first, interoperability second.
The independent camp includes LangGraph (stateful graph workflows), CrewAI (role-based multi-agent crews), Smolagents (code-generating agents from HuggingFace), and Pydantic AI (type-safe structured output). These work across providers but lack the deep integration of the native SDKs.
Meanwhile, the protocol layer is consolidating fast. ACP merged into A2A under the Linux Foundation. MCP crossed 200 server implementations. The question isn't whether protocols will standardize — it's which standard wins and how quickly.
What Actually Matters
Most framework comparisons obsess over feature checklists. Does it support multi-agent? MCP? A2A? Voice? These are the wrong questions. The right questions are architectural, and they have uncomfortable answers.
1. State management is the hard problem
Every agent framework, without exception, pretends state management is someone else's problem. OpenAI's Agents SDK has no built-in state persistence — you manage checkpointing yourself. LangGraph is better (it's built on a state graph), but the persistence layer is still your responsibility in production. Claude Agent SDK delegates to your session management.
This matters because agents are stateful by nature. A coding agent that can't remember what it did five minutes ago is useless. A customer support agent that loses context mid-conversation is worse than useless — it's actively frustrating. The framework that solves state management elegantly wins. None of them have yet.
2. Multi-agent coordination is undersolved
OpenAI's handoff model is clean for simple cases: Agent A delegates to Agent B via a typed tool call. But real agent systems aren't linear chains. They're graphs with conditional routing, parallel execution, shared state, and error recovery. LangGraph handles this with explicit graph topologies, which works but requires you to design the entire graph upfront. Google ADK uses hierarchical agent trees — parent delegates to children — which is more flexible but harder to debug.
The honest assessment: if your multi-agent system has more than three agents with complex routing, none of these frameworks make it easy. You're going to write orchestration code. The question is how much boilerplate the framework saves you. Answer: less than you'd hope.
3. MCP is the real standard to bet on
The Model Context Protocol crossed 200 server implementations for a reason. It solves the boring, essential problem: giving agents access to tools and data sources without writing custom integrations for each one.
Want your agent to search GitHub? There's an MCP server. Post to Slack? MCP server. Query your database? MCP server. Read files, run shell commands, browse the web — all MCP servers, all configurable with a single line.
Claude Agent SDK has the deepest MCP integration right now. That's not a coincidence — Anthropic created MCP. But OpenAI has adopted it, and the independent frameworks are adding adapter layers. Betting against MCP means betting against the entire tooling ecosystem. Don't.
4. A2A is early but important
Agent-to-Agent protocol (A2A), now hosting the merged ACP specification under the Linux Foundation, aims to solve cross-vendor agent communication. A Google ADK agent discovers and talks to a Claude Agent SDK agent without either side knowing the other's implementation.
In practice, A2A is still early. Auto-generated Agent Cards work in demos. Production deployments with authentication, error handling, and observability across vendor boundaries? That's still being figured out. But the direction is right. Agents that can't talk to agents built on other frameworks are agents that create vendor lock-in. The industry knows this. A2A is the emerging answer.
My Picks (and Why)
After building across six frameworks, here's what I'd use today, broken down by use case:
For coding agents and OS-level automation: Claude Agent SDK. The built-in file system and shell access, combined with the deepest MCP integration, means less boilerplate than anything else. The hooks system gives you lifecycle control that matters in production. You're locked to Claude models, but Claude is excellent at code tasks, and the integration depth is worth the trade-off.
For pipeline-style workflows with clear handoffs: OpenAI Agents SDK. The handoff model is the simplest mental model in the ecosystem. Customer service routing, triage pipelines, document processing chains — anywhere the flow is "Agent A decides, then hands to B or C." The guardrails system (input, output, tool validation running in parallel) is genuinely useful. Lightweight and fast to prototype.
For enterprise multi-language teams: Google ADK. If you have Java and Go teams that need to build agents alongside your Python team, ADK is the only framework that treats non-Python as a first-class citizen. The native A2A support and Vertex AI deployment path make it the pragmatic choice for large organizations. The visual Agent Designer is surprisingly useful for non-developer stakeholders to prototype before engineering builds the real version.
For complex stateful workflows: LangGraph. Nothing else handles state management as a first-class concept. If your agent system is genuinely a state machine — and many are, once you map them out — LangGraph's graph abstraction is the right mental model. The learning curve is steeper, but you're not fighting the framework to express complex control flow.
What I'd Avoid
CrewAI for anything production-facing. The role-based crew metaphor is intuitive for demos, but the abstraction leaks badly when you need fine-grained control over agent behavior. Rapid prototyping? Sure. Production? The orchestration model is too rigid.
Pydantic AI is excellent at what it does (type-safe structured output from LLM calls), but it's not really an agent framework. It's a structured output library. If that's all you need, use it. If you need agents with tools, memory, and multi-step reasoning, you'll outgrow it quickly.
The Protocol Bet
If you're building agent infrastructure, here's the protocol strategy I'd recommend:
- MCP is your default for tool integration. Every tool your agent needs should be an MCP server if possible. This is the highest-ROI protocol decision you can make — it decouples your tool layer from your agent framework.
- A2A for cross-agent communication. Even if it's early, design your agent interfaces with A2A Agent Cards in mind. The refactoring cost later will be much higher than the implementation cost now.
- Ignore everything else. The protocol space is consolidating. ACP already merged into A2A. More consolidation is coming. Don't build on niche protocols that may not survive.
Where This Is Going
Eight frameworks is unsustainable. The provider-native SDKs will survive because they're backed by the model providers who have every incentive to keep them alive. The independent frameworks will consolidate — probably down to one or two survivors that differentiate on workflow complexity (LangGraph) or model flexibility (a merged independent offering).
The real action is at the protocol layer. MCP for tools. A2A for inter-agent communication. These two protocols, combined, define the interoperability surface of the entire agent ecosystem. Everything else is implementation detail.
The pragmatic move: build on MCP today. Design for A2A tomorrow. Pick the framework that fits your immediate use case and don't over-invest in any of them. The code you write against the protocol layer will outlast any specific framework — the same way your HTTP code outlived every web framework you used in 2015.
The agents are real. The frameworks are temporary. Build accordingly.