The agent-framework library, read in order — from the foundations (do you even need a framework, and why every one of them converged on the graph) through the major head-to-heads (LangGraph vs CrewAI vs AutoGen, Agno, Smolagents, the OpenAI/Google/Anthropic SDKs, Microsoft Agent Framework), the LangChain/LangGraph ecosystem and Deep Agents, orchestration patterns (supervisor vs swarm vs handoffs), the shift from framework to runtime and durable execution, and the JS/TS stack.
Two of the most-cited essays on agent design say opposite things. They are both right — the disagreement is really about whether your task reads or writes.
With ADK 2.0's GA, LangGraph, OpenAI's Agents SDK, Google's ADK, and Microsoft's Agent Framework all now run on a graph execution engine. The programming model war is over. It settled the easy question.
All three claim to build multi-agent systems. The real question isn't features — it's who owns the control flow, and the answer changes which one is the right call.
All three build Python agents, but they disagree on one thing — who owns the loop. That contract, not the benchmark, is what you live with for years.
The frameworks that get the most attention disagree on something basic — what an agent's action even is. One writes code, one wires a graph, one casts a team.
The second wave of agent frameworks is leaner, typed, and vendor-backed — and underneath the branding, they're quietly converging on the same idea.
One hands you Anthropic's production agent loop already wired up; the other hands you a blank graph and a state machine. The choice is less "which framework" than "how much of the loop do you want to own."
Both will run the same agent. The real difference is altitude — ADK hands you an org chart of agents, LangGraph hands you the wiring and a roll of tape.
They ship the same orchestration patterns now, so stop comparing them on patterns. The real fork is where your production agent actually runs — in code you hold, or in a cloud you rent.
Since the 1.0 release, LangChain's agent helper runs on LangGraph's engine — so the real question isn't which to pick, but which layer of the same stack to write against.
After a year of churn that made it a punchline, LangChain shipped a 1.0 whose headline feature is the thing frameworks never promise: that it will stop moving under you.
A deep agent is not a new model or a framework breakthrough — it's four cheap, known ingredients that let a plain tool-calling loop survive a long task instead of drifting.
Claude Code proved the 'deep agent' pattern — planning, a filesystem, sub-agents, skills. A small cluster of Python repos now rebuilds that harness on Pydantic AI, so it runs on any model you own.
The three multi-agent shapes aren't ranked best-to-worst — they're a single axis. Pick by one question: how much context can you afford to lose between agents?
The topology you pick for your agents is really one decision in disguise — who holds the state and the control — and that single choice sets your token bill, your latency, and whether you can ever debug the thing.
CrewAI ships two orchestration models in one framework. Picking wrong is why your multi-agent demo worked and your production run didn't — and the fix is usually not choosing between them.
Every multi-agent framework now has a handoff primitive, and they all look the same in the demo. The difference that bites you in production is what rides along when one agent passes the baton to the next.
The agent libraries that mattered in 2024 told the model what to do next. The ones that matter now assume it already knows — and sell you the restraints and the trace instead.
Most teams assume LangGraph's checkpointer already makes their agents crash-proof. It doesn't — and the gap is architectural, not a missing setting. Here's exactly where it ends and where Temporal begins.
The three names a JavaScript team keeps hitting when it tries to build an agent aren't competing for the same job. Two of them stack on top of the third.