"Picking an agent framework in 2026: ADK, LangGraph, or no framework at all"

"Which agent framework should we use?" is the new "which JS framework should we use?" — same energy, same religious wars, same unsatisfying true answer: it depends on the shape of your problem. But "it depends" is a cop-out without the decision criteria, so here are mine after shipping with all of the major options.

The contenders, in one paragraph each

Google ADK treats agents as composable code objects. Its superpower is the workflow-agent family (SequentialAgent, ParallelAgent, LoopAgent) — deterministic orchestration wrapping stochastic workers — plus the best local dev UI in the field and a clean path to Vertex AI in production. Its gravity well is Google Cloud.

LangGraph models your agent as an explicit state machine: nodes, edges, a typed state object flowing through. Maximum control over control-flow, best-in-class checkpointing and human-in-the-loop interrupts. The cost is ceremony — you will write graph plumbing on day one — and the broader LangChain ecosystem's abstraction churn is a real tax.

Claude Agent SDK comes from the opposite philosophy: don't build the loop, inherit one that's already good. You get the production agent loop that powers Claude Code — context compaction, tool permissioning, subagents — and you customize with tools, hooks, and prompts. Fastest path from zero to a competent agent, especially for coding-shaped tasks; less appealing if you need to own every step of orchestration.

No framework — an LLM client, your tool registry, a while-loop — remains criminally underrated. Two hundred lines you fully understand beat two dependencies you don't, and it's the best way to learn what the frameworks are abstracting.

The actual decision criteria

How known is your workflow's shape? Fixed shape (intake → process → verify → report): ADK pipelines or LangGraph make it explicit and testable. Open-ended (research, coding, debugging): the loop matters more than the graph — Claude Agent SDK or a bare loop.

Who has to debug it at 2am? LangGraph's explicit state machine is the most inspectable. ADK's traces are good. A homegrown loop is exactly as debuggable as you built it to be, which — be honest — is "not very".

Where does it run? Deep on GCP already: ADK's Vertex integration is a genuine tailwind. Multi-cloud or on-prem constraints: check the deployment story before the API aesthetics, not after.

How many agents, really? If the honest answer is "one agent, five tools", skip the multi-agent frameworks entirely. You can migrate later; the tools and evals carry over, the orchestration glue doesn't.

What actually transfers

Here's the part the framework wars miss: the durable assets are framework-agnostic. Well-designed tools (increasingly as MCP servers), your eval scenarios, your prompts, your understanding of the failure modes — all of it ports. The orchestration layer is maybe 15% of the codebase and the only part you'd rewrite in a migration.

So my real advice: pick whichever framework fits your deployment constraints and your team's debugging taste, keep your tools behind MCP, keep your evals in plain pytest — and hold the whole thing loosely. In this field, eighteen months is a geological era.