---
title: "AWS Bedrock Agents vs LangGraph: How to Choose in 2026"
url: "https://atlan.com/know/ai-agent/ai-agent-applications/aws-bedrock-agents-vs-langgraph/"
description: "A neutral comparison of AWS Bedrock Agents vs LangGraph across orchestration, lock-in, cost, and security, plus the context layer that sits above either."
author: "Emily Winks"
author_role: "Data Governance Expert"
published: "2026-06-23"
updated: "2026-06-23T00:00:00.000Z"
---

---

Choosing between AWS Bedrock Agents and LangGraph is a choice between a managed runtime and an open framework. AWS Bedrock Agents, now reorganized under Amazon Bedrock AgentCore, runs the orchestration loop for you. LangGraph hands you a StateGraph API so you own loops, state, and step caps. Bedrock documents quotas you do not control, such as 20 action groups per agent (adjustable); LangGraph gives you direct control of the loop. The honest 2026 reframe: the "versus" is collapsing, because you can run LangGraph on AgentCore and AWS ships a tool to migrate Bedrock Agents to LangGraph.

---

## AWS Bedrock Agents vs LangGraph: at a glance

- **Who runs orchestration:** AWS Bedrock Agents runs it for you; LangGraph runs in infrastructure you operate.
- **Control over the loop:** Bedrock favors managed simplicity; LangGraph favors explicit, typed state.
- **Primary lock-in:** Bedrock ties you to AWS infrastructure; LangGraph ties you to one library's API.
- **Portability today:** AgentCore can host LangGraph, and AWS documents migrating Bedrock Agents to LangGraph.
- **What neither solves:** whether the agent knows what your business means.

| Dimension | AWS Bedrock Agents | LangGraph |
|-----------|--------------------|-----------|
| What it is | Managed agent service under Amazon Bedrock AgentCore | Open-source orchestration framework |
| Who runs the orchestration | AWS runs the agent loop | You run it in your own infrastructure |
| Control over the agent loop | Limited internal-loop control, managed defaults | Full control of loops, state, and step caps |
| Memory and observability | Managed AgentCore memory and observability | You wire your own checkpointer and tooling |
| Primary lock-in | AWS-infrastructure lock-in | Framework lock-in to the StateGraph API |
| Cost model | Per-step metering inside AWS billing | Infrastructure you provision and control |
| Best for | AWS-committed teams wanting minimal ops | Teams needing explicit state and custom control |
| Maturity | Newer multi-agent graph, per AWS Builder Center | Broader, more battle-tested, per AWS Builder Center |

---

## The decision both frameworks leave unanswered: your context layer

Before comparing AWS Bedrock Agents and LangGraph feature by feature, it helps to name the one axis neither framework resolves: whether the agent actually knows what your business means. Both are execution substrates. Both run the loop that calls a model, invokes a tool, and returns a result. Neither encodes the [definitions, lineage, policy, and ownership](https://atlan.com/know/business-context-for-ai/) that make an answer correct for your organization.

That missing tier is the [context layer for enterprise AI](https://atlan.com/know/context-layer-enterprise-ai/): a governed, model-agnostic layer that sits above whichever framework you pick. The comparison below is real and matters for engineering ergonomics, operations, lock-in, cost, and security, so read it fairly. Then return to this thread at the end, because the framework decision and the context decision are not the same decision.

---

## What are AWS Bedrock Agents?

AWS Bedrock Agents is Amazon's [managed agent service](https://atlan.com/know/ai-agent/ai-agent-applications/aws-bedrock-for-enterprise-agents/), where AWS runs the [reasoning-and-action loop](https://atlan.com/know/ai-agent/what-is-an-ai-agent/) on your behalf and is now reorganized under Amazon Bedrock AgentCore. You define the agent, attach action groups and knowledge sources, and AWS handles the orchestration runtime, identity through IAM, and [managed memory](https://atlan.com/know/what-is-agent-memory/). The trade is operational simplicity for less direct control of the internal loop.

The reorganization matters for how you read every quota and capability claim. According to AWS (2025), in its developer guidance on building production-ready agents, AgentCore is positioned as a production runtime that can host any framework, including LangGraph, [CrewAI](https://atlan.com/know/open-ai-agents-sdk-vs-lang-chain-vs-crew-ai/), Strands, LlamaIndex, and Pydantic AI. That reframes Bedrock Agents from a closed service into one option inside a broader, framework-agnostic runtime.

On maturity, the comparison is worth stating plainly. According to the AWS Builder Center (2026), in its guidance on picking an agent framework, Bedrock's multi-agent graph is described as newer and less battle-tested than LangGraph. That is a fair, sourced characterization, and it is useful context when you weigh a managed runtime against an established open framework. The point is not which is better in the abstract; it is which trade matches your team and your business context.

### Core components of AWS Bedrock Agents

- **Managed orchestration runtime:** AWS runs the reasoning-and-action loop for you.
- **Action groups:** the agent's callable tools and APIs (20 per agent, adjustable, per AWS quota docs).
- **Managed memory and observability:** operational and conversational state handled by AgentCore.
- **IAM-based access and metering:** identity, permissions, and usage tracking through AWS.
- **AgentCore runtime:** a framework-agnostic host that can run other frameworks too.

---

## What is LangGraph?

LangGraph is an [open-source orchestration framework](https://atlan.com/know/ai-agents-frameworks-compared/) where you write the agent's control flow yourself against a StateGraph API and own loops, state, and step caps. Instead of a provider running the loop, you model the agent as a graph of nodes and edges, with explicit, typed state passing between steps. The trade is more code and operational responsibility for far more control.

Community signal favors LangGraph for control-heavy work. According to a 2026 discussion in the r/LLMDevs developer community, [LangGraph](https://atlan.com/know/ai-agent/ai-agent-memory/langchain-vs-langgraph/) is called one of the most popular frameworks and "the current leader" for explicit state across steps and agents, which makes it strong when you need typed state and runaway-loop protection. Treat that as practitioner sentiment rather than a benchmark, but it is consistent across multiple threads.

The honest critique is also real. According to discussions in the r/LangChain community (2026), experienced developers report documentation gaps and rapid feature changes, and a recurring "death by abstraction" sentiment, with advice to start with direct model APIs and add the framework once the orchestration problem is clear. None of this makes LangGraph a poor choice; it makes it a deliberate one. The framework gives you control, and control is what some teams need most, while others would rather not operate the loop at all.

### Core components of LangGraph

- **StateGraph API:** the [programming model for defining nodes, edges, and control flow](https://atlan.com/know/ai-agent/ai-agent-memory/what-is-langgraph/).
- **Explicit state management:** typed state that passes between steps deterministically.
- **Step and loop control:** direct caps on iterations to prevent runaway loops.
- **Checkpointers:** persistence for graph state, including a SQLite checkpoint option.
- **Broad ecosystem:** interoperability with the wider LangChain ecosystem.

---

  The AI Context Stack, explained
  Frameworks orchestrate the agent loop, but the stack has a tier above them. See where governed context fits relative to models, frameworks, and tools.
  Get the AI Context Stack brief

---

## AWS Bedrock Agents vs LangGraph: how do they compare head-to-head?

AWS Bedrock Agents and LangGraph diverge most on who operates the runtime and how much control you have over the loop, and they converge on the fact that both are substitutable execution substrates. Bedrock optimizes for managed simplicity inside AWS; LangGraph optimizes for explicit control in infrastructure you run. The detailed view below maps nine decision axes so you can weigh genuine strengths on both sides.

| Dimension | AWS Bedrock Agents | LangGraph |
|-----------|--------------------|-----------|
| Orchestration model | AWS-managed loop, you configure inputs | You own the StateGraph and write the loop |
| Control over the agent loop | Limited internal-loop control, fewer failure modes to manage | Full control, plus step caps to stop runaway loops |
| Memory | Managed AgentCore memory for operational state | You wire your own checkpointer, including SQLite |
| Observability | Managed AgentCore observability | LangSmith or your own tooling |
| Primary lock-in | AWS-infrastructure lock-in (IAM, metering) | Framework lock-in to one library's API |
| Cost and TCO model | Per-step metering, harder to forecast | Infrastructure you provision and can tune |
| Throttling and quotas | Account and resource quotas you do not control; 20 action groups per agent (adjustable) is the one currently corroborated figure | Self-imposed limits you set in code |
| Security and CVE maturity | AWS-managed patching of the runtime | Open-source supply-chain CVEs you track and patch |
| Ecosystem maturity | Newer multi-agent graph, per AWS Builder Center | Broader and more battle-tested, per AWS Builder Center |

Consider a team building a [multi-agent](https://atlan.com/know/multi-agent-system-orchestration/) revenue-analysis workflow. With Bedrock Agents, AWS's managed runtime removes the burden of operating the loop, scaling the runtime, and wiring memory, so a small team ships faster. With LangGraph, an explicit `max_steps` cap and typed state in the StateGraph prevent a planner agent from looping indefinitely when a downstream tool returns ambiguous results. Each framework is indispensable in its lane: Bedrock for managed operations, LangGraph for deterministic control. One axis the table cannot rank, though, is portability of business context, because neither framework, on its own, tells the agent what "revenue" means in your business.

---

## Framework lock-in vs AWS-infrastructure lock-in: which are you choosing?

The structural distinction most comparison pages miss is that AWS Bedrock Agents and LangGraph lock you in differently, and the type of lock-in is a primary decision axis. LangGraph creates framework lock-in: your orchestration logic is written against one library's StateGraph API, so moving off it means rewriting the control flow. Bedrock Agents and AgentCore create AWS-infrastructure lock-in: IAM, metering, managed memory, and observability are tied to AWS, so moving off it means re-platforming the runtime.

The honest 2026 reframe is that this "versus" is collapsing. AgentCore is positioned as a runtime that can host any framework, and AWS publicly demonstrates migrating Bedrock Agents to LangGraph. According to AWS (2026), in an official AWS Show & Tell session, the company walks through migrating Amazon Bedrock Agents to LangGraph using AgentCore, which means you can run LangGraph on AWS-managed infrastructure or move between the two with documented tooling.

So the real question is not framework lock-in or infrastructure lock-in in isolation. It is portability across either, and what stays portable when you switch. Your orchestration code is framework-specific. Your runtime is provider-specific. The business context your agents depend on, the definitions and policy and lineage, should not be tied to either, which is precisely why teams designing an [AI agent stack](https://atlan.com/know/ai-agent-stack/) want it in a portable layer above the framework.

---

## What does step-billing actually cost, and what are the throttling limits?

The cost angle no comparison page quantifies is that AWS Bedrock Agents meters per step inside AWS billing, while LangGraph cost is driven by infrastructure you provision and control. Practitioners report that opaque per-step metering can produce surprising bills, with community threads asking why a Bedrock bill jumped unexpectedly. Treat that as practitioner experience rather than a fixed figure, but the pattern of step-driven cost being harder to forecast is consistent.

On hard quotas, accuracy matters more than precision here, because the numbers shift. After the AgentCore reorganization, several agent-specific limits that older guides cite no longer match the current public quota tables. The one figure currently corroborated is 20 action groups per agent (adjustable), per the AWS General Reference quota documentation. Beyond that, Bedrock and AgentCore impose account-level and resource-level quotas, including request throttling and session limits, that you do not control and that AWS revises over time.

The practical guidance is to verify the current numbers in the live AWS quota tables before you architect around them. According to community reports on Stack Overflow (2024), which predate the AgentCore reorganization, Bedrock agents can return a "your request rate is too high" throttling error, which confirms a throttle exists even when the exact threshold is not publicly fixed. This "the limits change underneath you" reality is a stronger lock-in consideration than any single number, because you are accepting quotas you neither set nor fully predict. With LangGraph, you control loops and step caps directly, so cost is provisioning-driven rather than per-step metered, and the limits are the ones you wrote.

---

  How mature is your context for agents?
  Before you commit to a framework, score where your business context stands today and what it takes to make agents accurate in production.
  Take the Context Maturity Assessment

---

## How secure are these frameworks? The LangChain and LangGraph CVE cluster

Security maturity is a fair comparison axis as long as it is framed factually: managed services like Bedrock and AgentCore shift runtime patching to AWS, while open frameworks put [supply-chain CVE tracking](https://atlan.com/know/ai-security/) on your team. Both have real, defensible security postures. The difference is who owns the patch cadence, not whether one framework is inherently unsafe. The open-source LangChain and LangGraph ecosystem has had a documented CVE cluster, and all of the issues below are patched.

According to the National Vulnerability Database, CVE-2026-34070 is a LangChain path traversal flaw (CWE-22) rated CVSS 7.5 High, affecting `langchain-core` before 1.2.22 and patched in 1.2.22, with a backport to 0.3.86 per the GitHub Security Advisory. It was disclosed around March 2026 and was reported alongside related LangGraph findings by The Hacker News (2026). It is the kind of file-access issue that managed runtimes typically patch centrally and self-hosted deployments must patch themselves.

According to The Hacker News (2026), CVE-2025-67644 is a LangGraph SQLite checkpoint SQL injection flaw (CWE-89) rated CVSS 7.3, with the score reported by The Hacker News because it was not yet on the NVD at the time of reporting; it is patched in `langgraph-checkpoint-sqlite` 3.0.1. It affects the SQLite checkpointer specifically, so teams using that persistence option should confirm the patched version.

The most severe item carries a score discrepancy worth reporting in full. According to the National Vulnerability Database, CVE-2025-68664 is a LangChain Core serialization injection that can leak secrets, rated 8.2 High by the NVD, which explicitly notes that its score differs from the CNA's. According to the GitHub Security Advisory GHSA-c67j-w6g6-q2cm, the CNA rates the same issue 9.3 Critical. It was disclosed in December 2025, per The Hacker News (2025), and is patched in `langchain-core` 0.3.81 and 1.2.5. Report both scores, because they are both authoritative and they diverge.

---

## When should you choose Bedrock Agents vs LangGraph?

The decision comes down to team profile, control needs, and portability requirements rather than a single "better" framework. If you are committed to AWS and want minimal operations, lean Bedrock Agents. If you need explicit state and custom multi-agent control, lean LangGraph. The table below maps common situations to a default, with the reasoning.

| Your situation | Lean Bedrock Agents | Lean LangGraph | Why |
|----------------|---------------------|----------------|-----|
| All-in on AWS, want minimal ops | Yes | | Managed runtime removes operational burden |
| Need explicit state and runaway-loop caps | | Yes | StateGraph gives direct control of loops |
| Need cross-cloud portability | | Yes | Or run LangGraph on AgentCore to keep control |
| Want managed memory and observability out of the box | Yes | | AgentCore provides operational state and tooling |
| Small team prototyping fast | | Start simple | Add a framework once the orchestration problem is clear |

There is one honest caveat that bridges to the larger point. Framework choice genuinely matters for engineering ergonomics, operations, lock-in, cost, and security. It does not determine whether the agent knows what your business means. That second question, the one that decides whether the agent is right or merely fluent, lives in a different tier of the stack.

---

## How Atlan approaches the agent stack above Bedrock and LangGraph

The tier above either framework is the [Context Layer for AI](https://atlan.com/know/what-is-context-layer/): a governed, model-agnostic layer that delivers business meaning to any agent, regardless of orchestration framework. This is the only section where Atlan appears, because the comparison above stands on its own. The point here is what neither Bedrock nor LangGraph is designed to do, and where production reliability actually comes from.

Both frameworks orchestrate, but neither encodes what your business means. Joe DosSantos, VP of Enterprise Data and Analytics at Workday, described exactly this gap: "We built a revenue analysis agent and it couldn't answer one question. We started to realize we were missing this translation layer." The framework was not the bottleneck. The missing piece was the governed context that tells an agent what "revenue" is, how it is calculated, which sources are authoritative, and who is allowed to see it.

Atlan delivers that as the Context Layer for AI, a governed tier above either framework. Through the [Atlan MCP Server](https://atlan.com/know/what-is-atlan-mcp/), context flows to any agent regardless of orchestration framework, with ownership, lineage, quality scores, and policy applied at query time. The Context Engineering Studio is where that business understanding is built, tested, and shipped. The Context Lakehouse stores it in an Iceberg-native, open, portable format, which is the antidote to both framework lock-in and infrastructure lock-in. This is distinct from AgentCore memory, which holds operational and conversational state; governed business context is definitions, lineage, policy, and ownership.

The outcome is measurable. According to Atlan research across customer deployments, reported in its work on [context engineering](https://atlan.com/know/what-is-context-engineering/), governed retrieval reaches 94 to 99 percent AI accuracy versus 10 to 31 percent for ungoverned retrieval, which isolates the variable: context, not framework, moves accuracy. At Workday, Atlan reports a 5x improvement in AI response accuracy through MCP-delivered context. Sridher Arumugham, Chief Data and Analytics Officer at DigiKey, put the shift plainly: "Atlan is much more than a catalog of catalogs. It's more of a context operating system."

---

## Real stories from real customers: context above the framework



      "We're excited to build the future of AI governance with Atlan. All of the work that we did to get to a shared language at Workday can be leveraged by AI via Atlan's MCP server…as part of Atlan's AI Labs, we're co-building the semantic layer that AI needs with new constructs, like context products."


      Joe DosSantos, VP of Enterprise Data & Analytics, Workday




    Watch Now




      "Atlan is much more than a catalog of catalogs. It's more of a context operating system…Atlan enabled us to easily activate metadata for everything from discovery in the marketplace to AI governance to data quality to an MCP server delivering context to AI models."


      Sridher Arumugham, Chief Data & Analytics Officer, DigiKey




    Watch Now


  See governed context delivered to any agent
  Watch how a context layer feeds definitions, lineage, and policy to agents on any framework, in a live walkthrough.
  Watch the live context demos

---

## Why the framework choice is real but not the reliability decision

The AWS Bedrock Agents vs LangGraph choice is genuine for engineering ergonomics, operations, lock-in, cost, and security, and the honest 2026 answer is that the "versus" is collapsing. You can run LangGraph on AgentCore, and AWS documents migrating Bedrock Agents to LangGraph, so both become more like substitutable execution substrates than permanent commitments. Pick the one that matches your team's appetite for control and operations.

The decision that actually determines production reliability sits above either framework. It is the governed [context layer for enterprise AI](https://atlan.com/know/context-layer-enterprise-ai/), model-agnostic and portable, which is where the 94 to 99 percent versus 10 to 31 percent accuracy difference comes from. As models and frameworks commoditize, context compounds: performance is a function of intelligence and context, and context is the part you own. Choose your framework on its merits, then invest in the layer that makes whatever you chose actually work.

  Book a Demo

---

## FAQs about AWS Bedrock Agents vs LangGraph

### 1. What is the difference between managed agents and open frameworks?

Managed agents like AWS Bedrock Agents run the orchestration loop for you inside the cloud provider's runtime, trading control for lower operational burden. Open frameworks like LangGraph give you the orchestration code so you own loops, state, and step caps, trading convenience for control. The choice is mostly about how much of the runtime you want to operate yourself.

### 2. Can you migrate Amazon Bedrock agents to LangGraph?

Yes. AWS documents a path to migrate Amazon Bedrock Agents to LangGraph running on Amazon Bedrock AgentCore, and demonstrates it in an official AWS Show & Tell session. This is one reason the two are increasingly portable rather than mutually exclusive choices.

### 3. Can I run LangGraph on AgentCore?

Yes. Amazon Bedrock AgentCore is positioned as a framework-agnostic production runtime that can host LangGraph alongside CrewAI, Strands, LlamaIndex, and Pydantic AI. Running LangGraph on AgentCore lets you keep LangGraph's orchestration control while using AWS-managed runtime infrastructure.

### 4. Is Bedrock Agents the same as AgentCore?

They are related but not identical. AWS reorganized its agent offering under Amazon Bedrock AgentCore, a production runtime that can host multiple frameworks. Bedrock Agents is the managed agent service within that broader AgentCore context, so quotas and capabilities have shifted as the reorganization rolled out.

### 5. Is LangGraph production-ready in 2026?

LangGraph is used in production and is often called the current leader for explicit state across steps and agents. It also has a documented CVE cluster that was patched, which means production teams own the supply-chain patch cadence. Track the relevant package versions and apply updates promptly.

### 6. Why did teams stop using LangChain?

Some practitioners report abstraction overhead and documentation gaps, and advise starting with direct model APIs before adding a framework. The common guidance is to add LangGraph or another framework once the orchestration problem is clear, rather than reaching for heavy abstraction on day one.

### 7. Do I still need a context layer if I use Bedrock or LangGraph?

Yes. Bedrock Agents and LangGraph orchestrate the agent loop, but neither encodes what your business means: definitions, lineage, policy, and ownership. A governed context layer above either framework delivers that business context to any agent, which is where production accuracy and reliability come from.

---

## Sources {#sources}

1. AWS: "Building Production-Ready AI Agents with LangGraph and Amazon Bedrock AgentCore" (2025). https://dev.to/aws/building-production-ready-ai-agents-with-langgraph-and-amazon-bedrock-agentcore-4h5k
2. AWS: "Build multi-agent systems with LangGraph and Amazon Bedrock" (2026). https://aws.amazon.com/blogs/machine-learning/build-multi-agent-systems-with-langgraph-and-amazon-bedrock/
3. AWS Builder Center: "Picking an AI Agent Framework in 2026" (2026). https://builder.aws.com/content/3AzsgG6TreTO3uLRqpWNxfEyUhe/picking-an-ai-agent-framework-in-2026
4. AWS: "Migrate Amazon Bedrock Agents to LangGraph Using AgentCore (AWS Show & Tell)" (2026). https://www.youtube.com/watch?v=mdvccNuDLv0
5. AWS: "Amazon Bedrock endpoints and quotas," AWS General Reference. https://docs.aws.amazon.com/general/latest/gr/bedrock.html
6. AWS: "Amazon Bedrock quotas," AWS documentation. https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html
7. National Vulnerability Database: "CVE-2026-34070" (2026). https://nvd.nist.gov/vuln/detail/CVE-2026-34070
8. National Vulnerability Database: "CVE-2025-68664" (2025). https://nvd.nist.gov/vuln/detail/CVE-2025-68664
9. GitHub Security Advisory: "GHSA-c67j-w6g6-q2cm (CVE-2025-68664)" (2025). https://github.com/advisories/GHSA-c67j-w6g6-q2cm
10. The Hacker News: "LangChain and LangGraph Flaws Expose Files" (2026). https://thehackernews.com/2026/03/langchain-langgraph-flaws-expose-files.html
11. The Hacker News: "Critical LangChain Core Vulnerability" (2025). https://thehackernews.com/2025/12/critical-langchain-core-vulnerability.html
12. Stack Overflow: "AWS Bedrock agent error: your request rate is too high" (2024). https://stackoverflow.com/questions/79118197/aws-bedrock-agent-error-as-your-request-rate-is-too-high-reduce-the-frequency
13. Reddit r/LangChain: "Managed Agents vs Open Frameworks (LangGraph, CrewAI, etc.)" (2026). https://www.reddit.com/r/LangChain/comments/1sgh77s/managed_agents_vs_open_frameworks_langgraph/
14. Reddit r/LLMDevs: "What's the best agent framework in 2025" (2026). https://www.reddit.com/r/LLMDevs/comments/1nxlsrq/whats_the_best_agent_framework_in_2025/