ADK vs LangGraph vs OpenAI/Claude SDK: Features Have Converged — It's Crash Time That Reveals the Truth

When an Agent Crashes, Will Your Refund Get Paid Twice?

An AI agent approved a customer refund. Then the server crashed. After restart, does the customer get the money once, or twice?

This is not a joke. OpenAI's documentation states it plainly: approving a tool call does not guarantee it executes only once. The payment may already have gone through, while the saved state has no record of it. Google's ADK warns that when a run is resumed, tools may be executed multiple times. LangGraph's approach is to re-run the interrupted step from the beginning.

According to a cross-comparison of 10 mainstream agent frameworks on a YouTube channel, the real story in 2026 is this: on paper, these frameworks' features have converged to a high degree; what actually separates them is the moment things go wrong. And one boring old trick works across all of them.

Ten Frameworks, One Core Loop

The comparison covered 10 frameworks, from Google ADK and LangGraph to the OpenAI and Claude SDKs. The author posed three questions: What happens when it crashes? Who runs the loop? How deeply are you bound?

First, who's using what. Stack Overflow's 2026 survey shows LangChain in the lead, followed by the OpenAI SDK, LangGraph, and Google ADK. But download counts tell a different story: on PyPI, AWS's Strands has more than twice the downloads of the OpenAI SDK, yet only 4% of survey respondents have used it. Download counts measure machines, not just people — don't pick your stack off a leaderboard.

The real surprise: every framework gives you the same core loop — the model picks a tool, reads the result, and keeps going until done. Everyone connects tools via MCP, everyone can pause for human approval, most already support loading Agent Skills (folders of instructions that the agent reads only when needed), and most now ship with a harness. In AWS's words, the model is the brain and the harness is the body: it executes tools, manages what the model sees, saves state, and recovers from failure.

Does the harness matter? In one academic benchmark, swapping only the harness for the same model moved scores by as much as 24 points. But the author found no independent head-to-head tests among these 10 frameworks. So on a feature table, all 10 look nearly identical.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic and now hosted by the Linux Foundation, used to let AI models connect to external tools and data sources in a standardized way. It defines a unified interface for tool discovery, invocation, and result return, so agent frameworks don't need to write a separate adapter for every tool. MCP servers can be deployed independently and reused by any client that supports the protocol, which makes it a key foundation for tool portability — when you switch frameworks, the tool layer usually doesn't need to be rewritten. The article's statement that "everyone connects tools via MCP" reflects exactly this standardization at the tool-integration layer.

Agent Skills are folders of on-demand instructions and knowledge that an agent reads only when it encounters a relevant task, rather than stuffing everything into context at once. In essence, it externalizes domain knowledge as files, which both saves tokens and lets knowledge migrate across frameworks. The article notes that most frameworks already support loading Skills and lists them as one of the assets you can take with you.

Harness refers to the runtime shell wrapped around the model, responsible for executing tool calls, assembling context, maintaining state, and handling failure recovery. AWS likens it to the "body," with the model as the "brain." The article cites an academic benchmark showing that changing only the harness for the same model can move scores by up to 24 points, underscoring its weight in engineering practice.

Question One: What Happens If the Process Dies Midway?

Nearly all frameworks default to in-memory state — crash, and the run is gone. Persistence is a switch you have to turn on yourself. Even when it's on, LangGraph by default saves incrementally in the background, and its docs warn there's still a small chance of losing a step on crash — one setting fixes it. The Claude Agent SDK writes each session to a local file, so a new container starts empty unless you add session storage. The OpenAI SDK and Pydantic AI hand recovery to engines like Temporal, which can carry long-running tasks through crashes. ADK can recover, but you have to turn it on first.

The key point: no framework — not even Temporal — can make "pay the customer" and "remember that you paid" a single step. Because the payment happens somewhere else.

The fix is old and boring: give every action a fixed ID, such as the refund order number. On retry, send the same ID, and the payment system will naturally reject the duplicate request. This is the idempotency key, and OpenAI's docs recommend it too.

Idempotency Key is a general mechanism in distributed systems that ensures repeated execution of an operation produces no side effects. The client generates a globally unique and stable identifier for each business action (such as a refund order number) and carries the same key on every retry; the server records keys it has already processed and, on a duplicate request, returns the first result directly without executing again. It's necessary because "executing the payment" and "recording that it was paid" happen in two independent systems and cannot be bound by a single atomic transaction — a crash may land exactly between them. Payment and API documentation from OpenAI and others all recommend this practice. In agent scenarios, the idempotency key should be an inherent parameter of the tool call, not an after-the-fact patch.

Question Two: Who Runs the Loop?

In most frameworks, the loop runs inside your own program, and you extend it the way you extend ordinary code. The Claude Agent SDK is different: it runs Claude Code itself, one process per session. You get Claude Code's full harness, but a hundred concurrent sessions means a hundred processes.

Frameworks are also nesting inside each other. Mastra can plug in agents built with the OpenAI or Claude SDKs; Vercel's SDK can use Claude Code or OpenAI's Codex as the engine inside an agent.

Question Three: How Deeply Are You Bound?

The Claude Agent SDK officially supports only Claude models. ADK accepts other models, but its Google Search tool requires Gemini. The OpenAI SDK uses OpenAI models by default and, by default, sends traces to OpenAI unless you turn it off. Most of the rest are model-neutral, so switching is basically just changing a model name.

Stability also varies. The OpenAI and Claude SDKs are still at 0.x versions. Google rebuilt ADK around a graph engine in v2, and some old custom code is now silently ignored. On October 16, Microsoft updated the AutoGen page to announce it was archived with no further security fixes; its successor, Microsoft Agent Framework, reached 1.0 in April.

Note that all three questions are about plumbing, not features. And plumbing is exactly what the biggest AI companies now want to run for you.

The Rise of Managed Runtimes and the Vanishing Framework

Five giants — Anthropic, Google, AWS, Microsoft, and OpenAI — now all offer services that run the agent loop for you. So far, only AWS's has left beta or preview. OpenAI says it handles sessions, context, and recovery for you; AWS puts it more bluntly: don't write the loop, define an agent with configuration.

Framework vendors are following suit. In April, LangChain's founder wrote that Anthropic's managed agent hides "almost everything behind the API." By August, LangChain had launched its own managed agent, running on its open-source harness.

Money points the same way. In September, Temporal raised at a $12.5 billion valuation — it serves far more than agents, but that number is ten times LangChain's last disclosed valuation. On November 30, OpenAI shut down its drag-and-drop agent builder about 14 months after launch, along with its evaluation platform. What you build on can disappear.

So where's the lock-in? The author's judgment: less and less in the framework, because AWS, Microsoft, and LangChain will all host agents built with almost any framework. Lock-in happens in what piles up around the agent: memory, saved sessions, identity, and permissions.

What can you take with you? Tools as MCP servers, knowledge as Agent Skills, agent-to-agent calls over A2A, and traces in OpenTelemetry format. MCP, A2A, and Skills all now have a neutral home at the Linux Foundation.

A prediction for the next year or two: frameworks will get thinner, more agents will start from configuration, and the real battleground will shift to the runtime — the layer that keeps the agent alive and holds its identity and memory. What would prove this wrong? If a year from now these managed services are still stuck in beta, or a major outage drives teams back to running agents themselves.

A2A (Agent-to-Agent Protocol) is an open protocol that lets different agents discover each other, delegate tasks, and exchange results; it too has been placed under the Linux Foundation. It complements MCP: MCP handles agent-to-tool connections, while A2A handles agent-to-agent collaboration. Because the protocol is neutral and independent of any specific framework, A2A-based call relationships survive a runtime change, which is why the article lists it as a portable asset.

OpenTelemetry is an observability standard under the Cloud Native Computing Foundation that unifies the collection and export formats for traces, metrics, and logs. In agent scenarios, a single run involves multiple model calls and tool executions; recording traces with OpenTelemetry doesn't depend on a particular framework's backend, so observability data remains reusable when you migrate — the technical basis for the article's advice to "keep your own traces."

So Which One Should You Pick?

There's no default answer anymore. In April, ThoughtWorks wrote that it no longer treats LangGraph as the default choice for every agent system. The author's recommendations:

• Don't want to run the loop yourself: pick a managed service, even though most are still in beta.
• Want any model and full control: LangGraph or Pydantic AI, or Mastra, Vercel SDK.
• Already committed to one vendor: use theirs — the OpenAI SDK, Claude's for coding agents, Google's ADK, AWS's Strands, or Microsoft's (also the .NET choice).

Whichever you choose, do three things: add idempotency keys to every action; keep tools and skills portable; keep your own tests and traces.

The author's core point: pick a framework you can delete. It's becoming the shortest-lived part of the agent — invest your effort in the things that last longer.