The Agent Framework Wars Are Already Over (You Just Don’t Know It Yet)
by an engineer
Let’s get the uncomfortable truth out of the way first: the framework you’re debating this week might be irrelevant by Q4.
Multi-agent pipelines, tool-calling orchestrators, RAG hybrids — production agentic systems come in every shape, and after building plenty of them, one pattern stands out as the single most expensive mistake teams keep making: betting their architecture on a framework instead of a protocol. This post is my attempt to save you that pain.
The Container Wars Déjà Vu
Here’s a pattern worth recognizing. Between 2015 and 2018, every major cloud provider shipped a free container orchestration layer — ECS, AKS, GKE — to lock you into their compute runtime. Kubernetes eventually won the abstraction layer, and the cloud vendors adapted around it.
We are living through the exact same cycle with AI agents right now.
Google ships ADK for free. AWS ships Strands for free. OpenAI ships the Agents SDK for free. Microsoft wraps it all in Azure identity and calls it enterprise-ready. The SDK is the loss leader. The runtime — Vertex AI, Bedrock AgentCore, OpenAI API, Azure Foundry — is where the margin lives.
This is not cynicism. This is just how platform businesses work, and knowing it should directly inform your architectural decisions.
The strategic move: build your agent logic on whatever framework fits your team’s mental model. Build your integrations on MCP (Model Context Protocol) and A2A (Agent-to-Agent) protocols. Those are the Kubernetes of this era — vendor-neutral, converging on interoperability, and increasingly supported by every major player. If you hardcode tool-calling against a framework’s proprietary interface, you will rewrite it. I promise.
A Practitioner’s Read on the Hyperscaler Frameworks
Google ADK is the most architecturally sophisticated of the hyperscaler offerings. It’s event-driven, built for stateful multi-agent systems, and has native MCP + A2A support baked in from day one — which tells you Google is serious about the protocol layer. The context engineering primitives are genuinely impressive. The lock-in is Gemini/Vertex AI, which is fine if that’s already your cloud home.
AWS Strands is the most philosophically interesting one to me. It’s built on just three primitives — models, tools, agents — and deliberately leans on the LLM’s native reasoning instead of encoding orchestration logic in code. That’s a real design bet: trust the model to figure out the workflow, don’t hard-code it. This works beautifully when your model is good and your tasks are well-scoped. It falls apart fast when you need determinism and auditability. Tightly coupled to Bedrock AgentCore for production.
OpenAI Agents SDK is the fastest path from idea to demo. Agents, Handoffs, Guardrails — that’s essentially the whole API surface. If your team is already deep in the OpenAI ecosystem, this is a no-brainer for rapid iteration. For anything requiring serious state management or complex topologies, you’ll hit the ceiling.
Microsoft’s offering is for the enterprise security team that needs to explain agent identity to a compliance officer. Azure Entra integration, enterprise orchestration, Microsoft Foundry. Not the most exciting framework, but probably the one that gets approved in a Fortune 500 procurement cycle.
The Independent Frameworks: Where the Real Tradeoffs Live
If you want to stay vendor-neutral — and for most teams, you should — the independent frameworks are where the interesting architectural decisions happen.
LangGraph is the production-grade choice if you need control. Every action is a node in a directed graph with explicit state transitions. You get deterministic replay, LangSmith observability, and the ability to audit exactly what your agent did and why. It has over 80k GitHub stars for a reason. The learning curve is real — it demands that you think in graphs, which is a different mental model from most application code. But for systems where a wrong agent decision has real consequences (financial operations, customer-facing workflows, compliance-sensitive pipelines), that control is not optional. This is my default recommendation for anything going to production.
CrewAI is the framework I recommend when I need to move fast or when I’m onboarding a team that doesn’t yet think in agent architectures. The “crew” metaphor — researcher, writer, analyst, each with a role, goal, and backstory — maps naturally to how humans already think about delegating work. You can assemble a multi-agent pipeline in a day and actually explain it to a product manager. The tradeoff is state management depth and control flow flexibility, both of which matter enormously at scale.
The practical heuristic I use: start with CrewAI to validate the workflow, migrate to LangGraph when you need to productionize it.
AutoGen from Microsoft Research is worth knowing if your system is fundamentally conversational — multiple agents in dialogue, flexible topologies, dynamic turn-taking. The documentation has historically been rough, but the research lineage is strong.
PydanticAI is a quiet gem for Python-native teams who care about type safety. If you’re already living in Pydantic for your data validation layer, the mental model transfer is seamless. Smaller ecosystem, but the developer experience is genuinely clean.
Mastra fills the same niche for TypeScript stacks. If your team is Node.js-native and the Python ecosystem feels like context switching, Mastra gives you a first-class agentic DX without leaving your comfort zone.
Syntax is increasingly irrelevant. The engineers who will matter in the next three years are the ones who can design agent topologies, reason about failure modes in autonomous systems, and make protocol-level decisions that survive framework churn.
The framework you pick this month is a productivity decision. The protocols you build on are a career decision.
Bet on MCP. Bet on A2A. Stay portable.
If you’re actively building agentic systems or making framework decisions for your team, I’d love to hear what you’re running in production. Hit reply.