The AWS agent runtime

Amazon Bedrock AgentCore: AWS's managed runtime for AI agents

What is Amazon Bedrock AgentCore?

AgentCore is the part of Amazon Bedrock that runs agents, as distinct from the part that serves models. AWS describes it as an agentic platform for building, deploying, and operating agents securely at scale, using any framework and any foundation model, without managing infrastructure. The framing matters: AgentCore is framework- and model-agnostic. It works with CrewAI, LangGraph, LlamaIndex, Strands Agents, the OpenAI Agents SDK, the Claude Agent SDK, or your own code, and with models inside or outside Bedrock — Claude, Amazon Nova, Llama, Gemini, OpenAI, Mistral.

That makes it a different kind of thing from the older Bedrock Agents, which is a configuration-driven, fully managed agent you define in the console. With AgentCore you write the agent yourself and deploy it onto AWS-managed infrastructure that supplies the production concerns — isolation, scaling, memory, tool access, identity, and observability — that you would otherwise build by hand. It is a runtime and operational substrate, not a no-code agent builder.

The AgentCore components

AgentCore is a suite of services, each usable on its own. The table below covers the ones verified in AWS's own documentation; AWS has since added further capabilities (a managed Harness agent loop, Policy, Evaluations, Optimization, a Registry, and Payments) that build on these primitives — treat the live AWS docs as the source of truth, since the set is still expanding.

The point of the modular design is that you can adopt one service without the others — use Gateway for tool plumbing while running the agent elsewhere, or use Memory from a LangGraph app — rather than buying into a monolith.

How AgentCore maps to the agentic architecture

The cleanest way to read AgentCore is as AWS's instantiation of the six-layer agentic AI architecture. Each layer in that reference model has an AgentCore counterpart — except the reasoning core, which AgentCore deliberately leaves to you (any model, in or out of Bedrock):

This is why an architect should hold the layer model in mind first and the product names second: the layers are stable, the service catalogue is not. Knowing that Gateway is the action layer and Observability is half the operational plane lets you judge the offering instead of memorising it.

When to use AgentCore (vs DIY or other runtimes)

AgentCore earns its place when you are already on AWS and want to skip building the production substrate yourself. The honest decision has three branches:

• Use AgentCore when you are committed to AWS, need enterprise concerns — session isolation, identity brokering, audited tool access, CloudWatch-native observability — and would rather configure them than build them. Its consumption-based billing also suits bursty, I/O-bound agent workloads.
• Go DIY when your agent is simple, your scale is modest, or you want full control of the loop and minimal vendor coupling. A bounded loop on your own compute is often enough; the production plane only pays off once isolation, identity, and observability become real requirements. See the bounded agentic loop.
• Use another runtime when your stack lives elsewhere. Cloudflare's Workers + Durable Objects / Agents SDK is the comparable edge-native option; this site itself runs on it. The runtime should follow the rest of your platform, not lead it. The full comparison is in where to run Claude agents.

AgentCore is not a lock-in trap by design — it is framework- and model-agnostic and speaks MCP and A2A — but it is still AWS infrastructure, so weigh it as a platform commitment, not just a library.

Pricing notes

AgentCore is consumption-based, with no upfront commitment or minimum fee, and each service is billed independently. These figures are directional — confirm current rates on the AWS pricing page before you model costs, and remember model inference is billed separately by Bedrock (or your provider):

• Runtime, Browser, Code Interpreter — active-consumption compute, billed per second: about $0.0895 per vCPU-hour and $0.00945 per GB-hour. You pay for active CPU only, so I/O wait time (often 30–70% of an agent run) is effectively free.
• Gateway — roughly $0.005 per 1,000 tool API invocations, plus small charges for search and tool indexing.
• Identity — about $0.010 per 1,000 token/API-key requests for non-AWS resources, and at no extra charge when used through Runtime or Gateway.
• Memory — short-term around $0.25 per 1,000 events; long-term storage around $0.75 per 1,000 records per month with built-in strategies.
• Observability — billed through Amazon CloudWatch at standard CloudWatch rates.

The managed Harness itself carries no extra charge, and new AWS customers get up to $200 in Free Tier credits. For how the model-inference side of an agent run adds up, see what a Claude agent costs to run.

Frequently asked questions

What is Amazon Bedrock AgentCore?

It is AWS's platform for deploying and operating AI agents in production: a set of modular services — Runtime, Memory, Gateway, Identity, Code Interpreter, Browser, and Observability — that supply the infrastructure an agent needs, while you provide the agent logic. It is framework- and model-agnostic, works with any foundation model in or outside Bedrock, and became generally available on 13 October 2025.

What are the AgentCore components?

The core services verified in AWS's documentation are Runtime (serverless agent hosting), Memory (short- and long-term context), Gateway (turning APIs and Lambda functions into MCP tools), Identity (agent authentication and credential management), Code Interpreter and Browser (built-in sandboxed tools), and Observability (CloudWatch-based tracing and monitoring). AWS has since added further capabilities — a managed Harness, Policy, Evaluations, Optimization, a Registry, and Payments — that build on these primitives.

What is AgentCore Runtime?

AgentCore Runtime is the secure, serverless runtime that hosts and scales agents. It provides fast cold starts for real-time interactions, extended execution for long-running asynchronous agents, true session isolation per user, built-in identity, and support for multi-modal and multi-agent workloads. It runs custom code and any open-source framework, and is billed on active resource consumption rather than pre-allocated capacity.

Is AgentCore the same as Bedrock Agents?

No. Bedrock Agents is the older, configuration-driven service where you define an agent in the console and AWS runs the loop for you with little or no code. AgentCore is a platform layer: you write the agent yourself in any framework and deploy it onto AWS-managed infrastructure that supplies runtime, memory, tools, identity, and observability. Bedrock Agents is a managed agent; AgentCore is the managed substrate you run your own agent on.

When should you use AgentCore?

Use it when you are on AWS and want production concerns — session isolation, identity, audited tool access, observability — handled for you rather than built by hand, especially for bursty, I/O-bound workloads its consumption pricing suits. Stay DIY when the agent is simple or you want full control of the loop, and choose another runtime (such as Cloudflare Workers and Durable Objects) when your stack lives elsewhere. The runtime should follow your platform, not lead it.

How much does AgentCore cost?

It is consumption-based with no minimum. Directionally: Runtime/Browser/Code Interpreter bill per second at about $0.0895 per vCPU-hour and $0.00945 per GB-hour; Gateway about $0.005 per 1,000 tool invocations; Identity about $0.010 per 1,000 credential requests (free via Runtime or Gateway); Memory about $0.25 per 1,000 short-term events; Observability via CloudWatch. The Harness is free and new customers get up to $200 in credits. Model inference is billed separately — confirm current rates on the AWS pricing page.