What's the difference between Bedrock Managed Agents and AgentCore?

AgentCore is AWS's open, model-agnostic agent orchestration layer — you bring the model, the harness, and the prompts; AgentCore provides compute, memory, identity, and tools. Bedrock Managed Agents (powered by OpenAI), launched in May 2026, is the opinionated managed runtime: AWS bundles OpenAI's frontier models, the OpenAI agent harness, and AgentCore's compute environment as a single managed service. Pick AgentCore when you want full control over the model and harness; pick Managed Agents when you want OpenAI-native execution with AWS-native operations and you don't need harness-level customization.

How does Claude Agent SDK fit into AWS's agent stack?

Claude Agent SDK is Anthropic's first-party agent harness for Claude models. On AWS, it runs alongside Bedrock Claude inference and integrates with AgentCore for compute and memory. It's the closest analog to the OpenAI harness inside Bedrock Managed Agents — but as a separate SDK, not a fully managed AWS runtime. As of May 2026, AWS does not offer a 'Bedrock Managed Agents, powered by Anthropic' equivalent. If you want an AWS-managed Claude agent runtime, you compose Claude Agent SDK on AgentCore yourself.

Which one should I pick for a new agent project in May 2026?

Three rules. (1) If you're building an OpenAI-native agent and want zero ops work, pick Bedrock Managed Agents. (2) If you're building a Claude-native agent or want to keep the model choice open, pick AgentCore + Claude Agent SDK or AgentCore + your custom harness. (3) If you're already using LangGraph, CrewAI, or another framework, run them on AgentCore for the AWS-native compute layer. The decision is mostly about whether you want OpenAI's harness baked in (Managed Agents) or model/harness flexibility (AgentCore).

Is Bedrock Managed Agents available now?

Yes, in limited preview as of May 1, 2026, announced at the 'What's Next with AWS' 2026 event. Access requires a waitlist request through the AWS Bedrock console. AgentCore is generally available (since 2025) and is the underlying compute environment Bedrock Managed Agents runs on. Claude Agent SDK is also generally available — Anthropic ships it as the recommended harness for Claude 4.7 Opus and Sonnet.

Quick Answer

Bedrock Managed Agents vs AgentCore vs Claude Agent SDK (May 2026)

Published: May 6, 2026

Bedrock Managed Agents vs AgentCore vs Claude Agent SDK (May 2026)

AWS now has three layers of agent infrastructure: AgentCore (the open compute layer), Bedrock Managed Agents (the opinionated OpenAI-powered runtime), and Claude Agent SDK (Anthropic’s first-party harness that runs on AgentCore). Picking the right layer is the most important architectural decision for any team building production agents on AWS in May 2026. Here’s the comparison.

Last verified: May 6, 2026

The three-layer stack at a glance

Layer	What it is	Who owns it	Model choice	Harness choice
AgentCore	Compute, memory, identity, tools	AWS	Open (any)	Open (any)
Bedrock Managed Agents (powered by OpenAI)	Managed runtime	AWS + OpenAI	OpenAI only	OpenAI harness only
Claude Agent SDK on AgentCore	First-party Claude harness on AWS compute	Anthropic + AWS	Claude only	Claude Agent SDK

Think of it as: AgentCore is the substrate. Managed Agents is one curated stack on top. Claude Agent SDK is another curated stack on top.

What each layer does

AgentCore (the substrate)

Released: GA in 2025; mature.
Provides: Compute environment for agent loops, persistent memory store, identity/auth, secrets management, tool invocation gateway, observability.
Doesn’t provide: Model, harness, prompts, application logic.
Pricing: Pay-as-you-go for compute, memory, and tool invocations.
Best for: Teams that want to bring their own model/harness/framework but offload the operational layer.

Bedrock Managed Agents (powered by OpenAI)

Released: Limited preview, May 1, 2026.
Built on: AgentCore underneath, OpenAI’s harness on top.
Provides: Everything AgentCore provides + the OpenAI agent harness + bundled inference on GPT-5.5 / GPT-5.4 + opinionated memory and skill abstractions.
Models supported: OpenAI only (currently GPT-5.5, GPT-5.4 in preview).
Harness: OpenAI’s agent harness — same one OpenAI runs in their own Codex / Operator.
Pricing: Limited-preview pricing not yet public; expect Bedrock-style markup over direct OpenAI rates plus per-agent runtime fees.
Best for: Teams committing to OpenAI long-term, wanting the official OpenAI harness with AWS-native operations.

Claude Agent SDK on AgentCore

Released: GA, multiple iterations through 2025-2026.
Built on: AgentCore optionally; runs anywhere.
Provides: Anthropic’s first-party agent loop, tool use, prompt caching, computer use APIs, memory abstractions, skill loading.
Models supported: Claude (Opus 4.7, Sonnet 4.6, Haiku 4.5) — including via Bedrock.
Harness: Claude Agent SDK (Python and TypeScript).
Pricing: Free SDK; pay direct Bedrock Claude inference + AgentCore compute if hosting on AWS.
Best for: Teams committing to Claude long-term, wanting the official Anthropic harness with AWS-native operations.

Side-by-side: building a coding agent

How would each option handle “build a coding agent that reads tickets from Jira, modifies code, runs tests, and opens PRs”?

Option A: Bedrock Managed Agents

Pick GPT-5.5 in the preview.
Define skills: read_jira_ticket, modify_file, run_tests, open_pr.
Configure memory: persistent across ticket sessions.
Deploy.
Tradeoff: least code, most lock-in to OpenAI’s harness and model lineup.

Option B: AgentCore + Claude Agent SDK

Write Python with claude_agent_sdk.
Use AgentCore primitives for memory and tool gateway.
Deploy as an AgentCore-hosted service.
Tradeoff: more code, full control over Claude prompts and memory; can swap to Sonnet for cost reduction.

Option C: AgentCore + LangGraph + your model

Write Python with LangGraph.
Compose any model (Bedrock, OpenAI, DeepSeek, etc.).
Use AgentCore primitives.
Tradeoff: most code, most flexibility; framework-level model and prompt control.

For “deliver tomorrow” timelines, Option A is fastest. For “deliver next quarter, scale long-term” timelines, Options B and C protect against vendor lock-in.

Where they differ on lock-in

The single most important strategic axis for this comparison:

Lock-in dimension	Managed Agents	AgentCore + Claude SDK	AgentCore + custom
Model lock-in	OpenAI only	Claude only	None
Harness lock-in	OpenAI harness	Claude Agent SDK	None
AWS lock-in	High	High	Medium
Effort to swap models	Not possible (no other models supported)	Need to rewrite harness logic	Just change the API call

Teams that have already committed to a single model family (most enterprises do) find Managed Agents or Claude Agent SDK simpler. Teams hedging on model choice (most multi-model startups) prefer raw AgentCore.

Pricing comparison (May 2026)

All three layers price-stack on top of underlying AWS services. Approximate cost components:

AgentCore:

Compute: pay-as-you-go (similar to Lambda/ECS pricing).
Memory: pay-per-GB-month for persistent agent memory.
Tool invocation: small per-call fee.

Bedrock Managed Agents:

AgentCore compute (passed through).
OpenAI inference (GPT-5.5 / 5.4) at Bedrock rates — pricing TBD at launch.
Per-agent runtime fee (limited-preview pricing not yet public).

Claude Agent SDK on AgentCore:

AgentCore compute.
Bedrock Claude inference (Opus 4.7: $15/$75 per 1M; Sonnet 4.6: $3/$15 per 1M).
SDK is free.

For a typical mid-volume coding agent (10K tasks/month, ~50K tokens per task):

Managed Agents (GPT-5.5): estimated $3K-6K/month.
Claude Agent SDK (Opus 4.7): $7,500/month inference + $200-500 AgentCore compute.
Claude Agent SDK (Sonnet 4.6): $1,500/month inference + $200-500 AgentCore compute.
AgentCore + custom routing (Tier 1 = Sonnet 4.6, Tier 3 = Opus 4.7): $1,800-3,000/month total.

Routing across model tiers is the cheapest path; the Managed Agents simplification carries a real cost premium.

What about LangGraph, CrewAI, and other frameworks?

All major Python agent frameworks (LangGraph, CrewAI, AutoGen, Mastra) run on AgentCore as application code. They don’t compete with AgentCore — they sit between your business logic and the AgentCore primitives. Choosing one is independent of the AgentCore vs Managed Agents decision:

AgentCore + LangGraph: very common; LangGraph for orchestration, AgentCore for compute/memory.
AgentCore + CrewAI: common for multi-agent crews.
AgentCore + Mastra: newer; TypeScript-first.
Bedrock Managed Agents + framework: not really — the OpenAI harness is the framework. Don’t double-stack.

Decision framework

Three questions, in order:

Will you commit to a single model family for the next 18 months?
- Yes, OpenAI → Bedrock Managed Agents.
- Yes, Claude → Claude Agent SDK on AgentCore.
- No → raw AgentCore + your framework of choice.
Do you need the official harness, or can you tolerate framework-level harnesses?
- Need official → Managed Agents (OpenAI) or Claude Agent SDK (Claude).
- Tolerate framework → AgentCore + LangGraph / CrewAI / custom.
What’s your cost tolerance?
- Cost-insensitive, want fastest delivery → Managed Agents.
- Cost-conscious, want max flexibility → AgentCore + multi-model routing.

Bottom line

In May 2026, AgentCore is the substrate; Bedrock Managed Agents and Claude Agent SDK are two opinionated stacks that run on top. Managed Agents gets you fastest to production on OpenAI with full AWS-native ops. Claude Agent SDK is the equivalent path for Anthropic shops. Raw AgentCore plus your framework of choice gives the most flexibility and the lowest cost ceiling for teams that can absorb the engineering work. For most teams in May 2026, the answer is Claude Agent SDK on AgentCore for production Claude agents, and raw AgentCore + LangGraph or CrewAI for multi-model strategies. Managed Agents is compelling only if you’ve already committed exclusively to OpenAI.

Sources: AWS Bedrock Managed Agents page (May 2026), AWS What’s Next with AWS 2026 announcements, Stratechery Altman/Garman interview (April 2026), Futurum Group analysis (May 2026), AI Business coverage (May 2026), Anthropic Claude Agent SDK docs (May 2026).