Ask "ADK or LangGraph?" and you'll get answered with a feature table: stars, license, who has checkpointing, who has a managed deploy. All true, all beside the point. You can build the same customer-support agent in either. You can wire the same tools, call the same model, get the same demo working by Friday. Feature for feature, they converge.
The thing that doesn't converge is altitude — how high above the machinery each one makes you stand. And that, not the checklist, is what you're actually choosing.
ADK hands you the org chart
Google's Agent Development Kit, which landed at Cloud Next in April 2025 and reached 1.0 across Java and Go in early 2026, is unapologetically opinionated. Its core idea is that an agent system has structure, and that structure should be made of named parts you assemble, not control flow you draw.
So ADK ships agent types as primitives. There's the LlmAgent — the reasoning unit that thinks and calls tools. And then there are workflow agents that exist purely to arrange other agents: a SequentialAgent runs its children in order, a ParallelAgent fans them out concurrently over shared session state, and a LoopAgent repeats until a condition trips. You build a multi-agent system by composing these into a tree, with a root agent delegating down to sub-agents.
That's a strong opinion. It means a lot of what you'd otherwise write as orchestration code — "run these three, then that one, retry until done" — becomes configuration: pick the workflow agent that matches the shape and slot your LlmAgents into it. The hierarchy is given. You fill it in.
LangGraph hands you the wiring
LangGraph starts from the opposite instinct: don't impose structure, expose the substrate. Its model is a single directed graph — nodes are functions, edges are routing rules (direct or conditional), and a shared state object threads through the whole thing. There are no "agent types." There's a node, and there's where it can go next.
Multi-agent, in LangGraph, isn't a primitive — it's a pattern you build. A "supervisor" is just a node that routes to other nodes. A "team" is just a subgraph. This is the same low-level philosophy that makes LangGraph feel closer to a state machine than a toolkit: more to assemble, but nothing standing between you and the control flow.
What you get for that effort is durability done right. LangGraph's checkpointing persists graph state at every step, so a run can crash and resume, or pause at a node for human-in-the-loop approval and pick back up without losing its place. For agents that run long or need a human in the loop, that persistence layer is the headline feature — and it's the one LangChain has been pouring its $125M Series B into hardening.
ADK asks "what's the shape of your agent team?" and gives you parts to build it. LangGraph asks "what's the exact path your computation takes?" and gives you a graph to draw it. Both are right. They're answering different questions.
The quieter bet underneath
There's a second axis riding along with altitude, and it's about where you end up, not how you start.
ADK is, among other things, a funnel. It's Gemini-native, it leans on Vertex AI, and its smoothest production path is a one-command deploy to Google's managed Agent Engine. You can point it at other models through LiteLLM and run it elsewhere — it's genuinely model-agnostic at the edges — but the gravity pulls toward Google Cloud. That's not a criticism; if you're already on GCP, that gravity is exactly the friction-removal you want.
LangGraph makes the opposite bet: provider- and cloud-neutral, any LLM, containerize and run it wherever. It carries the larger ecosystem and the bigger mindshare (the star gap, ~35k to ~20k, is a rough proxy), and it asks nothing about which cloud you've committed to. The cost is that you own more of the assembly and more of the deployment. The same trade shows up across the field — it's the open-vs-closed framework question wearing different logos.
The actual decision
Stop comparing features and ask two questions.
How much structure do you want handed to you? If "a lot — give me agent types and a hierarchy and let me fill it in," that's ADK. If "as little as possible — give me the graph and get out of the way," that's LangGraph.
Where are you deploying? If the answer is "Google Cloud, and I'd love a one-command path to a managed runtime," ADK's funnel is a feature. If the answer is "anywhere, possibly several places, don't tie me down," LangGraph's neutrality is the feature.
Most teams already know their answer to the second question before they start evaluating. Let it decide the first. The frameworks are close enough on capability that the honest tiebreaker isn't which one can do the job — it's which altitude you want to stand at while it does.
