Evgeny Anikiev

Posted on Oct 26 Originally published at Medium

Bedrock Managed Agents vs AgentCore: Which Should Run Your Agents?

#aws #ai #openai #llm

AWS now offers two ways to run AI agents: an OpenAI agent loop that Amazon Bedrock manages for you, or your own agent code on AgentCore. Here is what each one does, what the preview can't do yet, and how to choose.

By Evgeny Anikiev, AWS-certified DevOps engineer with 10+ years running build automation, CI/CD, and Kubernetes in production. Checked against the Amazon Bedrock and AgentCore documentation on October 26, 2026.

TL;DR: Amazon Bedrock Managed Agents, powered by OpenAI, is a managed agent loop. You send instructions, skills, and a message, and AWS runs the conversation with an OpenAI model while the tools run on compute you provide. Amazon Bedrock AgentCore is a set of services for agents you build yourself, with any framework and any model: Runtime, Gateway, Memory, Identity, Policy, Observability, and Evaluations. Pick Managed Agents for internal agents on OpenAI models that work on files and run shell commands, and accept that it is a preview in three US Regions with no subagents or long-term memory. Pick AgentCore for customer-facing agents, non-OpenAI models, or anything that needs Cedar policy checks on tool calls. The two also combine: Managed Agents can run its tools inside AgentCore Runtime.

What this post covers:

What each service is, in one paragraph each.
A side-by-side table: models, Regions, tools, memory, security, and pricing.
What the Managed Agents preview does not support yet.
How to start a Managed Agents session, with the IAM role it needs.
A worked example: three agents, three choices.

What is Amazon Bedrock Managed Agents?

Amazon Bedrock Managed Agents, powered by OpenAI (BMA in the AWS docs), runs OpenAI-model agents in your AWS account. AWS announced the public preview at the end of September 2026. It is built on a customized version of OpenAI's Agents API, adapted to use AWS identities and resources.

The documentation describes how the work splits: "The service manages the agent's conversation and model interactions. Tools execute in the compute environment that you provide." You do not write the agent loop. You write instructions, add skills (folders with a SKILL.md file) and local MCP servers, and point the session at an execution environment.

That environment is one of two types:

self_hosted: a codex exec-server process on a machine or container you run. It opens an outbound HTTPS and WebSocket connection to the service, so it needs no inbound ports.
aws_bedrock_agentcore: an AgentCore Runtime that contains the exec server. AWS's example CDK app creates the Runtime, storage, and networking for you.

Model inference runs in the Bedrock service on the bedrock-mantle endpoint. Your environment only runs the tools.

What is Amazon Bedrock AgentCore?

Amazon Bedrock AgentCore is a set of services for running agents that you write. AgentCore Runtime is framework-agnostic: AWS documents agents built with Strands Agents, LangGraph, and CrewAI running on it, and the agent can call models on Bedrock or from other providers. Each Runtime session gets its own microVM, lasts up to 8 hours, and ends after 15 minutes of inactivity by default.

Around Runtime sit the other parts, and you use only the ones you need:

Gateway turns APIs and Lambda functions into MCP tools.
Policy checks every tool call through Gateway against Cedar rules. It became generally available on March 3, 2026.
Memory keeps short-term conversation state and long-term records per user.
Identity handles inbound auth and outbound credentials, so tools don't need keys in code.
Observability sends traces to Amazon CloudWatch in your account.
Evaluations scores live traces with 13 built-in evaluators. It became generally available on March 31, 2026.

With AgentCore you own the loop: which model to call, when to call a tool, how to retry, and what to store. If you're moving an existing agent there, my 15-check AgentCore readiness score covers what to prepare.

Bedrock Managed Agents vs AgentCore: side by side

	Bedrock Managed Agents (preview)	AgentCore (your own agent)
Who writes the agent loop	AWS and OpenAI	You, with Strands, LangGraph, CrewAI, or your own code
Models	OpenAI models available in the Region	Any model on Bedrock or from another provider
Status	Public preview; "Preview functionality and APIs can change"	Runtime, Gateway, Policy, and Evaluations generally available
Regions	US East (N. Virginia), US West (Oregon), US East (Ohio)	More Regions; check the AgentCore Region list
Endpoint	`bedrock-mantle`, path `/openai/v1/agents/sessions`	`bedrock-agentcore`
Where tools run	Your machine or container, or AgentCore Runtime	AgentCore Runtime (microVM per session)
Tools	Skills (`SKILL.md` folders) and STDIO MCP servers; shell commands in the environment	Gateway MCP tools, plus whatever your framework supports
Tool-call policy	Not described in the BMA docs	Cedar rules in AgentCore Policy, enforced at Gateway
Memory	Session context only; "No built-in long-term memory integration"	AgentCore Memory, short-term and long-term
Subagents	"Not supported"	Whatever your framework supports
Input	Text	Whatever your code accepts
Console	None; APIs and deployment examples only	Console, CLI, and SDKs
Pricing	Model inference plus the AWS resources you use	Model inference plus a meter per AgentCore service

The table comes down to who owns the agent code. With Managed Agents, AWS and OpenAI own it, and you supply the workspace and the skills. With AgentCore, you own it, and AWS supplies the hosting and the governance parts around it.

What can't Bedrock Managed Agents do yet?

The preview's limitations page lists these, and each one decides a use case:

No subagents. One agent per session. If your design hands work from a planner to specialist agents, build it on AgentCore.
No cross-Region inference profiles. Inference runs in the Region you call, and you can't route it to other Regions for extra capacity.
Text input only. No images or files in the session input. Files go into the workspace instead.
No long-term memory. A session keeps its conversation, and that's all. Anything the agent should remember across sessions has to live in files or your own store.
No turn list or turn retrieval API. You follow progress through the event stream and the turn_id on each item.
No service-managed KMS key option for session data and no programmatic tool calling (code mode).
No console. Everything goes through the API and the example scripts.

Two behaviors matter in production. Deleting a session does not delete files in your workspace, S3 data, or the AgentCore Runtime stack, so clean those up yourself. Cancelling a turn does not undo what a tool already did: if the agent ran a command that changed something, cancel stops the next step, not that one.

How do I start a Bedrock Managed Agents session?

You need three pieces: a session role that the service assumes to call the model, permissions for your client, and an execution environment.

1. The session role

The trust policy lets the bedrock-mantle service assume the role, scoped to your account:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": { "Service": "bedrock-mantle.amazonaws.com" },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": { "aws:SourceAccount": "123456789012" },
        "ArnLike": { "aws:SourceArn": "arn:aws:bedrock-mantle:*:123456789012:*" }
      }
    }
  ]
}

The permissions policy allows inference on one model only. This is where you pin the model:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "bedrock-mantle:CreateInference",
      "Resource": "*",
      "Condition": {
        "StringEquals": { "bedrock-mantle:Model": "openai.gpt-5.6-luna" }
      }
    }
  ]
}

2. Client permissions

The caller needs bedrock-mantle:CreateAgentSession, GetAgentSession, ListAgentSessions, CreateAgentSessionEvent, ListAgentSessionEvents, ListAgentSessionItems, and DeleteAgentSession. It also needs iam:PassRole on the session role, with the condition "iam:PassedToService": "bedrock-mantle.amazonaws.com". A self-hosted exec server additionally needs bedrock-mantle:RegisterEnvironment and bedrock-mantle:ConnectEnvironment.

3. Create the session and send a message

Requests are signed with SigV4 for the service name bedrock-mantle. curl can sign them with --aws-sigv4. With temporary credentials, pass the session token as a header:

ENDPOINT=https://bedrock-mantle.us-east-1.api.aws
SIGN=(--aws-sigv4 "aws:amz:us-east-1:bedrock-mantle"
      --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY"
      -H "x-amz-security-token: $AWS_SESSION_TOKEN"
      -H "Content-Type: application/json")

curl -s "${SIGN[@]}" -X POST "$ENDPOINT/openai/v1/agents/sessions" -d '{
  "agent": {
    "model": "openai.gpt-5.6-luna",
    "instructions": "Use the workspace tools to complete the user'\''s task."
  },
  "environment": {
    "type": "self_hosted",
    "workspace_directory": "/srv/agent/workspace",
    "capability_directories": ["/srv/agent/workspace/skills"]
  },
  "role_arn": "arn:aws:iam::123456789012:role/BedrockManagedAgentsSessionRole",
  "stream": false
}'

Take the session ID from the response, then submit a message as an event:

SESSION_ID=<id from the response>

curl -s "${SIGN[@]}" -X POST "$ENDPOINT/openai/v1/agents/sessions/$SESSION_ID/events" -d '{
  "events": [{
    "type": "agent.session.input.message",
    "input": [{"role": "user", "content": [
      {"type": "input_text", "text": "Find the failing test in this repo and propose a fix."}
    ]}]
  }]
}'

Follow progress with GET .../events (a text/event-stream) and read the results with GET .../items, which returns messages, reasoning summaries, command executions, and MCP calls, 20 per page by default. The session status moves between idle, in_progress, and failed. To run tools in AgentCore Runtime instead of your own host, set "type": "aws_bedrock_agentcore" with a runtime_arn and a runtime_qualifier such as DEFAULT.

One rule from the API reference is worth putting in your client: after a network error, check whether the create or submit call was accepted before you retry it, or you get a duplicate session or a duplicate turn.

How much do Bedrock Managed Agents and AgentCore cost?

The Managed Agents documentation lists two charges: model inference and the AWS resources your application uses. When I checked the Bedrock pricing page on October 26, it had no separate Managed Agents line. Pricing can change when the service reaches general availability.

The "AWS resources" part is not zero. AWS's AgentCore example creates a NAT gateway, which bills every hour whether or not a turn is running, and the Runtime bills for the compute your sessions use.

AgentCore has a meter per service. List prices from the AgentCore pricing page:

AgentCore service	Price
Runtime microVM (v1), CPU	$0.0895 per vCPU-hour
Runtime microVM (v1), memory	$0.00945 per GB-hour
Gateway, tool invocations	$0.005 per 1,000
Policy	$0.000025 per request
Memory, long-term records (built-in)	$0.75 per 1,000 records per month
Evaluations, custom	$1.50 per 1,000 evaluations, plus model usage

Runtime microVMs bill per second with a 1-second minimum. For scale: a session using 1 vCPU and 2 GB for one hour costs $0.0895 + 2 × $0.00945 = $0.1084 on v1. One million tool calls through Gateway cost $5, and a Policy check on each of them adds $25. Put these next to your monthly token spend in Cost Explorer before you decide which meter is worth optimizing.

Should I use Bedrock Managed Agents or AgentCore?

Use Managed Agents when the agent is internal, OpenAI-based, and workspace-shaped. Use AgentCore when you need a different model, memory, or policy on tool calls, or when customers see the output.

Here is how that plays out for a platform team with three agents to place.

1. A repo maintenance agent for engineers. It reads code, runs tests, and proposes fixes. Users are internal, the team already uses OpenAI models, and the work is files and shell commands. Choice: Managed Agents, self-hosted. The exec server runs in a build container with a checkout of the repo. Skills hold the team's conventions. There is no agent code to maintain.

2. A customer support agent with refunds. It runs on a Claude model, remembers each customer between conversations, and calls a refund API. Choice: AgentCore. It needs a non-OpenAI model, long-term memory, and a Cedar rule that blocks refunds above a set amount at Gateway. The preview offers none of those three.

3. A nightly data quality agent. It runs for up to six hours on an OpenAI model and should not run on anyone's laptop. Choice: Managed Agents with the AgentCore environment. The session fits inside a Runtime session's 8-hour limit, and the tools run in an isolated microVM in the team's account. The team deletes the Runtime stack and the NAT gateway when they retire the agent, because deleting the session does not.

FAQ

Is Bedrock Managed Agents the same as Amazon Bedrock Agents?
No. Amazon Bedrock Agents is the earlier Bedrock feature for building agents with action groups and knowledge bases. Bedrock Managed Agents, powered by OpenAI, is a separate preview service on the bedrock-mantle endpoint that runs OpenAI's agent loop.

Can Bedrock Managed Agents use Claude or other non-OpenAI models?
The preview documentation only covers OpenAI models supported in the Region and account. For Claude, Llama, or other models, build the agent on AgentCore Runtime.

Does Bedrock Managed Agents replace AgentCore?
No. Managed Agents can use AgentCore Runtime as its execution environment. AgentCore remains the place for agents with your own code, other models, Gateway tools, Memory, and Policy.

Which Regions support Bedrock Managed Agents?
During the preview: US East (N. Virginia), US West (Oregon), and US East (Ohio), through regional bedrock-mantle endpoints such as https://bedrock-mantle.us-east-1.api.aws.

Is Bedrock Managed Agents production-ready?
It is a public preview, and AWS says preview APIs can change. It has no subagents, no long-term memory, and no console. Use it for internal agents with a fallback, and plan for API changes before general availability.

What does Bedrock Managed Agents cost?
The docs list model inference plus the AWS resources you use, such as AgentCore Runtime compute or your own servers. No separate agent fee appeared on the Bedrock pricing page as of October 26, 2026.

Can I use MCP tools with Bedrock Managed Agents?
Yes, as STDIO MCP servers that run in the execution environment, configured in agent.tools or the BMA_MCP_SERVERS_JSON variable, each with an allowed_tools list. The preview docs do not describe remote MCP servers.

Sources

Choosing where your agents run? I set up Bedrock and AgentCore foundations for AI teams at DevOps Cloud Consult: IAM roles, networking without surprise NAT bills, observability, and cost tracking per team. Send me the agent you want to move and I'll tell you which side of this table it lands on.

Get one AWS cost fix every two weeks: subscribe on Substack.

DEV Community