Amazon Bedrock AgentCore Explained: AWS’s Infrastructure for Running AI Agents in Production

Most coverage of AWS’s AI infrastructure, including our own on this site, focuses on either the custom silicon underneath it (Trainium, Inferentia, Graviton) or the general-purpose model platforms sitting on top (Bedrock and SageMaker as model-hosting services). Between those two layers sits a problem neither one solves: once a prototype AI agent works in a notebook, what actually keeps it running securely, debugged, and scaled when real users and real tool calls hit it in production? Amazon Bedrock AgentCore is AWS’s answer, and it’s infrastructure in the fullest sense — compute, identity, memory, and observability purpose-built for autonomous agents rather than for serving a model’s inference endpoint. This piece is specifically about that layer, distinct from our earlier look at Bedrock and SageMaker’s general AI developer services and from AWS’s Nitro/EFA networking stack.

At a Glance

Fact	Detail
What it is	A managed platform for deploying, securing, and operating AI agents in production, framework- and model-agnostic
General availability	October 2025 (per AWS’s official “now generally available” announcement)
Supported frameworks	LangChain, OpenAI Agents SDK, Claude Agent SDK, Strands Agents SDK, or custom frameworks
Core components	Runtime, Gateway, Identity, Memory, Observability, Evaluations, Browser, Code Interpreter, Policy
Pricing model	Consumption-based, no upfront commitment; most components billed per vCPU-hour, per GB-hour, or per 1,000 API calls/tokens
2026 feature rollout	Policy GA (March 2026), AgentCore Harness GA (June 2026), AgentCore Payments GA (August 2026)

Short Verdict

AgentCore is AWS correctly identifying that the hard part of production AI agents isn’t building one — it’s securing tool access, managing memory and identity across sessions, and debugging an agent’s actual decision path when it misbehaves. AWS has built a genuinely modular, pay-as-you-go set of managed services for exactly that, and it works with agents built on other vendors’ frameworks and models, not just Bedrock’s own. The trade-off is that this is a fast-moving, feature-by-feature rollout (several core pieces only reached general availability in the months since its October 2025 launch), and the vendor-cited performance numbers in AWS’s own marketing haven’t been independently verified.

The Problem AgentCore Is Built to Solve

AWS’s own framing of AgentCore is direct: building an agent is fast, but connecting it securely to internal systems, debugging unexpected behavior, and scaling it reliably are what actually slow teams down. That’s a different problem from hosting a model for inference, which is what Bedrock’s foundation-model catalog and SageMaker’s training/hosting tools are built for. An agent isn’t just a model call — it’s a model plus a loop of tool calls, memory lookups, and multi-step decisions, each of which needs its own security boundary, its own debugging trail, and its own way of scaling independently of the underlying model.

What’s Actually Inside AgentCore

• Runtime — executes agent code in isolated microVMs, billed per vCPU-hour and per GB-hour of memory consumed, with support for long-running sessions beyond what a typical serverless function allows.
• Gateway — handles authentication and access control for an agent’s connections to MCP (Model Context Protocol) servers, internal APIs, knowledge bases, and Lambda functions, so tool access is governed centrally rather than hardcoded per agent.
• Identity — issues OAuth tokens and API keys an agent uses to act on a user’s behalf; AWS does not charge separately for Identity when it’s used through Runtime or Gateway.
• Memory — split into short-term memory (billed per GB ingested, retrieved, and stored) and long-term memory (billed per 1,000 records stored and retrieved monthly), letting an agent recall context across sessions rather than starting fresh every call.
• Observability — surfaces the actual steps an agent took, which tools it called, and where its reasoning went off track, billed through Amazon CloudWatch rather than a separate AgentCore charge.
• Evaluations — lets teams test agent behavior against real traffic rather than only synthetic test cases.
• Browser and Code Interpreter — sandboxed environments that let an agent browse the web or execute code safely, billed on the same per-vCPU-hour/per-GB-hour model as Runtime.
• Policy — enforces access policies verified through automated reasoning, the same formal-verification technology AWS already uses behind IAM and S3 access controls; it reached general availability in March 2026.

Pricing, Component by Component

Component	Billing Unit	Rate (per AWS’s published pricing page)
Runtime (microVMs, on-demand)	Per vCPU-hour / per GB-hour	$0.0895 per vCPU-hour; $0.00945 per GB-hour
Browser / Code Interpreter	Per vCPU-hour / per GB-hour	$0.0895 per vCPU-hour; $0.00945 per GB-hour (same rate as Runtime)
Gateway	Per 1,000 API invocations	$0.005 per 1,000 invocations; Search API $0.025 per 1,000; tool indexing $0.02 per 100 tools/month
Identity	Per 1,000 OAuth tokens/API keys	$0.010 per 1,000; free when used through Runtime or Gateway
Memory (short-term)	Per GB ingested/retrieved/stored	$1.00 per GB ingested; $0.20 per GB retrieved; $0.10 per GB-month stored
Memory (long-term)	Per 1,000 records/month	$0.75 per 1,000 records (built-in); $0.25 per 1,000 (self-managed); $0.50 per 1,000 retrievals

New AWS customers get up to $200 in free-tier credits, and AWS notes that Identity usage carries no separate charge when accessed through Runtime or Gateway. As with any consumption-based service, actual monthly cost depends heavily on session length, memory volume, and how many tool calls an agent makes — there’s no flat per-agent price.

A Fast-Moving Rollout, Not a Single Launch

AgentCore reached general availability in October 2025, but several of its components have continued rolling out piece by piece since then: Policy reached general availability in March 2026, the AgentCore Harness (a packaging/runtime wrapper) in June 2026, and AgentCore Payments — letting agents initiate and manage payments on a user’s behalf — in August 2026. That cadence is worth flagging for anyone evaluating the platform today: a feature absent six months ago may now be GA, and the reverse is also possible for newer previews that haven’t yet reached general availability.

Vendor-Cited Results (Treat as Marketing, Not Independent Benchmarks)

AWS’s own AgentCore marketing cites a Signal65 comparison claiming 75% less time spent on infrastructure and integrations versus custom development, 5.2x faster deployment, and 2.1x faster end-to-end agent development versus building the equivalent infrastructure in-house. It also names specific customers: Cox Automotive scaling from zero to 17 production agents in under a year, Druva resolving 68% of support issues without human intervention, and Thomson Reuters reporting 70% automation in platform engineering. These are AWS-published, customer-attributed figures rather than independently audited benchmarks, and none of the underlying methodology is public, so they should be read as directional case studies rather than guaranteed outcomes for any other team’s workload.

AgentCore vs. Building It Yourself

Dimension	Self-Built Agent Infrastructure	Bedrock AgentCore
Identity & tool access	Custom auth code per integration, or a shared internal gateway you build and maintain	Managed Gateway and Identity services with centralized policy enforcement
Memory across sessions	Usually a self-managed vector store or database, wired in manually	Built-in short-term and long-term Memory services, billed by usage
Debugging agent behavior	Custom logging, often incomplete for multi-step tool-calling traces	Purpose-built Observability showing the agent’s actual step-by-step trace
Framework lock-in	Depends entirely on what you build	Framework-agnostic: LangChain, OpenAI Agents SDK, Claude Agent SDK, Strands, or custom
Cost model	Fixed infrastructure cost regardless of usage	Pay-per-use across every component, no minimum commitment

Trade-offs

Pros	Cons
Framework- and model-agnostic by design — works with Claude, OpenAI, or custom agent frameworks, not only Bedrock-hosted models	A relatively young platform; several core components reached GA only within the last year, so maturity varies by component
Granular, consumption-based pricing avoids paying for idle agent infrastructure	Granular pricing also means cost is harder to forecast than a flat per-seat or per-agent price
Security and policy enforcement (Gateway, Identity, Policy) centralizes what’s otherwise built ad hoc per team	Vendor-cited performance and ROI figures are AWS’s own marketing, not independently verified

Who It’s Relevant For

Teams that have already validated an AI agent prototype and are hitting the production wall — needing secure tool access, persistent memory, and real debugging visibility — and that want to avoid building and maintaining that infrastructure themselves. It’s especially relevant for teams already on AWS and working with multiple agent frameworks rather than a single vendor’s SDK.

Who Should Look Elsewhere

Teams still in early prototyping, where the overhead of learning a multi-component managed platform outweighs the benefit, and teams fully committed to a different cloud’s native agent stack, where switching costs would exceed what AgentCore saves. Simple, single-tool agents with no multi-session memory requirement may also not need most of what AgentCore offers.

Bottom Line

AgentCore fills a real, specific gap in AWS’s AI stack: not model hosting, not custom silicon, but the operational layer that keeps an agent secure, debuggable, and scalable once it leaves the prototype stage. Its framework-agnostic design and granular pricing are genuine differentiators, and its October 2025 general availability plus steady 2026 feature rollout (Policy, Harness, Payments) show AWS treating this as a priority rather than a one-off launch. The honest caveat is that it’s still maturing component by component, and its headline ROI figures come from AWS’s own case studies rather than independent benchmarking.

FAQ

Does AgentCore require using Bedrock’s foundation models? No. AWS markets it as model-agnostic, supporting agents built on Claude, OpenAI models, or others, through frameworks like LangChain, the OpenAI Agents SDK, the Claude Agent SDK, or Strands.

When did AgentCore become generally available? AWS’s official announcement states Amazon Bedrock AgentCore became generally available in October 2025.

How is AgentCore priced? Consumption-based with no upfront commitment, billed component by component — for example, Runtime and sandboxed execution (Browser, Code Interpreter) by vCPU-hour and GB-hour, Gateway by API invocation, Identity by token/key issued, and Memory by data ingested, retrieved, and stored.

What’s the difference between AgentCore and the earlier “Bedrock and SageMaker” AI developer tools? Bedrock’s foundation-model catalog and SageMaker cover model access, fine-tuning, and hosting. AgentCore is a separate, newer layer specifically for operating autonomous agents in production — identity, memory, tool-access security, and observability for the agent loop itself, not for serving a model endpoint.

Sources

• AWS — “Amazon Bedrock AgentCore is now generally available” (aws.amazon.com/about-aws/whats-new/2025/10/amazon-bedrock-agentcore-available)
• AWS — Amazon Bedrock AgentCore product page (aws.amazon.com/bedrock/agentcore)
• AWS — Amazon Bedrock AgentCore Pricing (aws.amazon.com/bedrock/agentcore/pricing)
• AWS — “Policy in Amazon Bedrock AgentCore is now generally available” (March 2026)
• AWS — “AgentCore Harness is now generally available” (June 2026)
• AWS — “AgentCore payments is now generally available” (August 2026)

Related reading on this site: Beyond the Chips: What Amazon Bedrock and SageMaker Actually Offer AWS’s AI Developers, Inside AWS’s AI Networking Stack (Nitro System and EFA), and AWS’s Custom Silicon Economics (Trainium vs. Nvidia GPUs).