Any agent that outlives a single request needs a runtime that remembers where it was when the process died. Three answers keep coming up for builders in 2026: Cloudflare's Project Think, the Cloudflare Agents SDK underneath it, and LangGraph. They're usually pitched as rivals. They're better understood as points on one axis — how much of the agent loop is written for you — with a single hard tie-breaker: whether the thing has to run anywhere but Cloudflare.

Here's the short answer before the detail: Think if you're on Cloudflare and want the plumbing gone; the Agents SDK if you're on Cloudflare and want the plumbing exposed; LangGraph if the agent must run somewhere else or you need the control flow to be an explicit, inspectable graph.

The axis: assembled, parts, or a graph#

Project Think (@cloudflare/think) is the assembled end. You extend a base class, override getModel() and getTools(), and durable recovery, message persistence, streaming, sub-agents, and a code sandbox are already wired — all on Durable Object SQLite. The design goal is that you write agent behavior, not agent infrastructure.

The Agents SDK is that same runtime one floor down. It hands you the primitives Think is built from: a Durable Object per agent, WebSocket transport, and durable state. Think even lists agents as a peer dependency — so choosing the SDK over Think isn't switching platforms, it's choosing to hold the loop yourself. You'd do that when Think's opinions (its session model, its recovery discipline) fight the agent you're trying to build.

LangGraph is the explicit, portable end. Your agent is a graph of nodes and edges with a typed state object, written in Python or JS. Nothing is hidden — the control flow is the artifact you author and inspect — and it runs on any infrastructure, from a VM to a container to LangGraph Platform. That's also the work: you design the graph, and you attach and operate the store that makes it durable.

Durability is where they diverge most#

This is the feature everyone actually wants and the one they implement most differently.

Think makes durability a config field. Turns run inside recoverable fibers, so an in-flight response survives eviction, deploy, or hibernation and resumes — you set chatRecovery.maxAttempts and move on. Zero extra services.

The raw Agents SDK gives you durable state but not durable turns — recovery discipline is yours to write, which is exactly the durable-execution problem the whole ecosystem is trying to solve.

LangGraph solves it with checkpointers: after each node, it snapshots state to a store. Use an in-memory saver for development and a Postgres or Redis checkpointer for production. The upside is that durability is portable and explicit; the cost is that you run the store, and you design your nodes so a replayed step doesn't fire a second side effect.

Human-in-the-loop and sub-agents#

Both matter for real agents, and the ergonomics differ. Think lets a tool pause for approval and resume later without holding a request open — the durable machinery covers the wait. LangGraph does it with interrupt() and a checkpoint resume, which is clean and framework-native but, again, explicit. On the SDK you build the pause/resume yourself.

For sub-agents, Think is the most turnkey: a nested agents/ folder yields a child with its own isolated SQLite and typed RPC. LangGraph models the same idea as subgraphs or a supervisor — more flexible, more to define. This is the older agents-vs-workflows tension in miniature: Think picks sensible defaults, LangGraph makes you draw the boundaries.

So which one#

Ask two questions in order.

Does it have to run off Cloudflare? If yes, the decision is made: LangGraph. Think and the Agents SDK are Durable Objects to the bone — the persistence, the sub-agent isolation, the recovery fibers are all Cloudflare primitives, and porting means rebuilding them. LangGraph is the multi-cloud hedge.

If you're staying on Cloudflare, how much control do you want? Want the plumbing gone and a class you extend? Think. Want the primitives exposed because your agent doesn't fit a chat-turn base class? The Agents SDK.

One caveat on all three: these platforms are moving fast in 2026. Treat the specifics here — Think's recovery fields, the SDK's state APIs, LangGraph's checkpointer names — as current-at-writing, and verify against each project's docs before you pin a version. The decision axis, though, is stable: pay in lock-in for less plumbing, or pay in plumbing for portability.