Cloudflare Agents vs. LangGraph (and Where AWS Bedrock AgentCore Fits): Framework vs. Runtime

What each one actually is

LangGraph is a low-level framework for structuring agents as a StateGraph — nodes, edges, conditional branches, shared state, checkpointers for persistence, and human-in-the-loop interrupts. LangChain sits on top of it as the higher-level library, and at its 1.0 release in late 2025 the centerpiece became a create_agent abstraction built on the LangGraph runtime. Its great strengths are maturity and reach: it’s battle-tested in production at large companies, it’s model- and cloud-agnostic so it runs anywhere, it offers the deepest control over complex multi-agent flow, and it plugs into LangChain’s very large ecosystem of integrations plus LangSmith for observability. What it does not give you is a place to run it. You either operate the infrastructure yourself — including the Postgres or Redis that backs its checkpointers, plus scaling and monitoring — or you pay for the managed LangGraph Platform.

Cloudflare Agents is the opposite shape: an integrated runtime where each agent is a TypeScript class backed by a Durable Object — a stateful micro-server with its own embedded SQL, scheduling, and connections, running across Cloudflare’s global network and hibernating when idle. Around it sit the durable-execution engine (Workflows), MCP hosting and clients, the browser and sandbox action layer, the models (Workers AI and AI Gateway), managed Agent Memory, and Code Mode. The pitch is that compute, state, tools, and models are colocated, with nothing to operate and scale-to-zero economics. The depth on each of those pieces lives in the sibling spokes — the agent-as-Durable-Object runtime, durable execution, MCP hosting, and the action layer — so this piece won’t re-derive them.

AWS Bedrock AgentCore is AWS’s managed agent runtime, and it’s the closest analog to Cloudflare’s full platform — runtime, memory, a gateway that turns APIs into tools, identity, a managed browser, a code interpreter, and observability, all as managed services. Crucially, it’s framework-agnostic: AWS markets it as “build with any framework, any model,” and LangGraph is a first-class supported framework on it. It reached general availability in October 2025, with up-to-8-hour sessions, VPC support, and nine regions at launch. It’s heavier and AWS-centric — the strong choice if you’re already all-in on AWS and want managed isolation and governance.

The comparison, dimension by dimension

A quick feel for what writing an agent looks like in each: in LangGraph you define a graph of nodes and edges and compile it with a checkpointer; in Cloudflare you write a TypeScript Agent class with callable methods and optional Workflows; in AgentCore you take an agent built in your framework of choice and deploy it into the managed runtime with a decorator and CLI. One note on the durable-execution row: the engine-level comparison — Workflows against Temporal, Step Functions, Inngest, and DBOS — lives in the durable-execution spoke, not here. This piece stays at the framework-and-platform level.

When each one wins

LangGraph wins when you need portability across clouds and models with no lock-in; when you’re Python- or ML-heavy and want the LangChain ecosystem; when you need fine-grained control over complex multi-agent orchestration; or when you want mature framework abstractions and a large community behind them. Don’t choose Cloudflare here if your team is Python-first or you can’t accept Durable Object lock-in.

Cloudflare wins when you want an integrated runtime with zero infrastructure to operate — no Postgres or Redis to run; when you need global low-latency and genuine scale-to-zero economics, like one stateful agent per user or task at near-zero idle cost; when you’re already building on Workers and JavaScript; or when you want MCP-native tools with a browser, sandbox, and models colocated. It’s a poor fit if you need on-premise deployment, strict data residency in your own VPC, or a Python-heavy scientific stack.

AgentCore wins when you’re already deep in AWS — IAM, Bedrock, VPC, the AWS data stack; when you want a framework-agnostic managed runtime that works with LangGraph rather than instead of it; when you need enterprise AWS governance; or when you need long, hours-scale agent sessions in an AWS-native context.

That middle option — running LangGraph on a managed runtime — is worth dwelling on, because it dissolves the false either/or. AWS publishes first-party tutorials for running a LangGraph graph on AgentCore and ships integrations that let AgentCore Memory act as LangGraph’s checkpointer. On Cloudflare, LangChain’s JavaScript library runs on Workers and there’s a langchain-cloudflare package. The one caveat to state clearly: the managed LangGraph Platform is not designed to run inside Workers — if you want LangGraph on Cloudflare, you run the open-source framework on Workers or Containers, not the managed Platform.

What it costs (and why a head-to-head is misleading)

The three price on different axes, so a naive side-by-side deceives more than it informs; here’s the shape. LangGraph’s framework is free and open-source; the managed Platform bills on seats plus roughly half a cent per end-to-end agent run, plus deployment uptime and trace volume — and a continuously running production deployment’s uptime charge alone is meaningful before a single run executes. (Beware stale third-party guides here: the old “per node executed” pricing is gone from the official page, replaced by per-deployment-run billing where nodes within a run aren’t charged separately.) AgentCore is consumption-based and per-second — billing CPU and memory only while active, with idle and I/O-wait time free, which suits agents that spend most of their time waiting on a model — plus separate charges for its gateway, memory, and other components, with model inference on top. Cloudflare bills on the underlying Workers and Durable Objects usage with a five-dollar monthly account minimum, and its hibernation economics strongly favor bursty, idle-heavy agent workloads. The detailed modeling belongs in a pricing exercise, not a comparison article — what matters is that the shapes reward different workloads, and all three exclude separately-billed model inference.

The honest trade-offs

The case against Cloudflare deserves to be made as squarely as the case for it. Its Agents SDK is young and pre-1.0, with a number of features still explicitly experimental or in preview — you pin versions and expect change. It is JavaScript- and TypeScript-first; Python on Workers exists but is in beta, and the agent ecosystem is JS-centric, which is a real disadvantage against LangGraph’s Python-first data and ML world and AWS’s Python strength. Its high-level agent-framework abstractions are fewer than LangGraph’s prebuilt agents. And Durable Objects have no drop-in equivalent anywhere else, so choosing Cloudflare is choosing genuine lock-in. None of that makes it a bad platform; it makes it a shape — an integrated, opinionated runtime — that fits some teams and not others.

LangGraph’s costs are the mirror image: you carry the operational weight of hosting and scaling it, or you pay for the Platform, and its very flexibility means more decisions to get right. AgentCore’s costs are AWS gravity — it’s the right answer largely to the extent you’re already on AWS, and its multi-component billing rewards configuration discipline. And all three are moving fast enough that any specific claim here has a shelf life.

How to actually decide

Start by separating the two questions. Decide your framework and your runtime independently: do you need a portable orchestration framework, a managed runtime, or both? If your only real question is “where do I host my LangGraph agent,” you’ve already chosen the framework, and the answer is a runtime decision — your own infrastructure, Cloudflare, or AgentCore.

Then apply the defaults. A JavaScript team that wants zero infrastructure and cares about latency points to Cloudflare. A Python or ML team that wants portability and control points to LangGraph, self-hosted or on its Platform. A team already standardized on AWS that wants governance and long sessions points to AgentCore, optionally running LangGraph on top.

Finally, pressure-test against the thresholds that should change your mind. On-premise or strict in-VPC data residency argues against Cloudflare and toward self-hosted LangGraph or in-VPC AgentCore. A Python-heavy scientific stack argues against Cloudflare’s beta Python. A hard no-lock-in requirement argues for the open-source LangGraph framework over any managed runtime. Hours-long managed sessions favor AgentCore’s eight-hour window; on Cloudflare you’d reach for Workflows to make multi-step work durable rather than holding one long invocation. The honest recommendation sometimes points away from Cloudflare — and saying so is what makes the rest of the recommendation trustworthy.

Working with Truvisory

If you want help making this call for a specific project — or you’ve decided on Cloudflare and want it built — this is the work we do: senior-engineer-led, fixed-scope agent systems, and we’ll tell you honestly when a different platform is the better fit. See how we deliver agent systems, or read the pillar guide to the full stack.