For eighteen months the AI agent framework debate was loud, tribal, and mostly about shape. Was an agent a chain? A crew of role-players? A swarm passing control by handoff? A hierarchy of a supervisor and its workers? Each framework had an answer, and each answer looked different enough to argue about.

That argument is over. On May 19, 2026, Google's Agent Development Kit reached 2.0 GA and, in the process, rewrote its own core: the framework moved "from a hierarchical agent executor to a graph-based execution engine," in which "your Agents, Tools, and Functions are evaluated as individual nodes within a workflow graph." The new Workflow Runtime does routing, fan-out/fan-in, loops, automatic retry, state management, and human-in-the-loop pauses. On June 30, the Go SDK hit GA with the same runtime, and the convergence finished crossing language lines.

ADK was the last major holdout, and its capitulation is worth naming plainly, because it completes a set.

The set#

LangGraph got here first and never pretended otherwise — it is a graph state machine by design, with a checkpointer that snapshots state at each super-step so a run can pause, resume, or time-travel. Its durable-execution docs are blunt about the deal: "If you are using LangGraph with a checkpointer, you already have durable execution enabled." Whether that claim holds up under load is exactly the argument we'll get to — the same one that runs through LangGraph checkpointing versus Temporal-style durable execution.

OpenAI's Agents SDK shipped in 2025 as the minimalist of the bunch: agents, tools, and handoffs, with almost no ceremony. But minimalism doesn't survive contact with production, and the missing durability arrived through the Temporal integration, which reached GA on March 23, 2026. Wrap your agent as a Temporal workflow and it "persists its state automatically, resumes from exactly where it left off after a crash or server restart, and consumes zero compute resources while waiting for input." A handoff is just an edge you didn't draw.

Microsoft's Agent Framework, the BUILD 2026 centerpiece, is organized around graph-based workflows with a hosted runtime for the long-running, durable case.

Four frameworks. One architecture: a directed graph of nodes, mutable state threaded through the edges, checkpoints so the thing can survive a restart, and a pause primitive for the human. If you learned one, you can read the others. The war is settled, and the graph won.

Convergence happened on the notation, not on the guarantee. Everyone agreed to draw the same diagram. They did not agree on what has to be true underneath it.

The part that didn't converge#

Here's the catch, and it's the whole point. Agreeing that an agent is a graph is agreeing on a drawing. It says nothing about what the runtime actually promises when a node throws on retry number three, or when the process dies mid-tool-call, or when a paused human-in-the-loop step sits idle for six days and the pod gets rescheduled underneath it.

That is the difference between checkpointing and durable execution, and it is a real technical distinction that the convergence papers over. A checkpointer saves a snapshot you can resume from. Durable execution — the Temporal, Restate, and Inngest lineage — guarantees that each step runs exactly as written, exactly once as observed, through crashes and retries and redeploys, by replaying an event-sourced history rather than trusting a saved blob. Diagrid, which sells the durable-execution view, put the disagreement in a headline: checkpoints are not durable execution, and the graph frameworks that lean on them "fall short for production."

You don't have to buy the vendor framing to see the tell. Watch what the frameworks do when they want the strong guarantee: they reach for someone else's runtime. OpenAI's answer to "make it survive a crash" was to marry the Agents SDK to Temporal, not to strengthen its own loop. LangGraph's checkpointer is real, but the moment you need cross-service exactly-once semantics, the community reference architectures route you to a durable backend anyway. ADK 2.0 builds retry and HITL into the engine — genuinely more than a bare checkpointer — but "the engine manages state, graph routing, and streaming" is a description of orchestration, not a proof of durability under partial failure.

What this changes about choosing#

The practical upshot is that "which framework" has quietly become the shallow question. The graph is now table stakes; you will get nodes, edges, state, retry, and a pause primitive from any of them, and porting a design between two of them is a weekend, not a rewrite.

The question that actually bites is one layer down. When you evaluate an agent framework in the back half of 2026, don't ask whether it has a graph — they all do. Ask what stands behind the graph: Does the runtime give you real durable execution or a snapshot you have to babysit? What exactly happens to an in-flight tool call when the process dies? Can a human-in-the-loop pause outlive a deploy? Where does the state live, who pays to keep it warm while the agent waits, and can you host the paused thing for a week without burning a container?

Those answers still diverge sharply — which is the tell that the convergence was never as deep as it looked. Everyone agreed to draw the same diagram. Almost no one agreed on what has to be true underneath it. The framework wars ended by settling the easy question and leaving the hard one exactly where it was.