Amazon Bedrock AgentCore: Production AI Agents Made Simple
A plain-language breakdown of all 13 AgentCore components, what they cost, how they work together, and the tradeoff you should know before building.
The AI model was never the hard part. Running the agent was. Until now.
A year ago, Simon Willison, co-creator of Django and a prolific voice on AI development tooling, wrote what became the stickiest definition of an AI agent: "An LLM agent runs tools in a loop to achieve a goal." That is it. Every production agent, from Amazon Q Developer to Claude Code to OpenAI's Codex, runs the same shape under the hood.
But here is what nobody tells you when you build one: the loop takes an afternoon. Getting it into production takes months. The moment your agent needs to serve more than one user, a wall of problems shows up at once. Concurrency. Session isolation. Identity. Memory. Scaling. Observability. Security. Every team was rebuilding the same plumbing from scratch, over and over.
Amazon Bedrock AgentCore is AWS's answer: a platform that handles everything around the loop so you can focus on what makes your agent actually useful.
It went generally available on October 13, 2025. But understanding what it is, what it means strategically, and where the tradeoffs are requires more than a press release. Let me break it down.
The Thesis: The Model Is a Commodity. The Operational Layer Is the Moat.
Every major cloud provider has launched a managed agent platform in the past year. They all converged on the same set of capabilities: managed runtime, persistent memory, tool connectivity, identity, observability, and governance.
That convergence tells you something important. The foundation model is becoming interchangeable. AgentCore itself supports Claude, Nova, Llama, Mistral, GPT, and Gemini through a single interface. You can swap providers mid-session without losing context.
The real strategic value lives in the operational layer beneath the model. The memory your agent builds over months of conversations. The tool integrations you wire up through Gateway. The identity vault that holds your OAuth tokens. The observability traces that let you debug production failures.
That is the bet AWS is making with AgentCore. And honestly? It is the right one. Because the infrastructure problem was always harder than the intelligence problem.
What AgentCore Actually Is (The Simple Version)
Imagine you built a really good sandwich at home. The recipe works, the ingredients are perfect. Now someone says: "Great. Make 50,000 of those per hour, remember what each customer ordered last time, make sure nobody gets food poisoning, and track every single ingredient."
That is the jump from prototype to production. AgentCore is the factory, pre-built.
It is modular. Use one piece, use all thirteen, mix and match. It does not care what framework you used (LangChain, CrewAI, Strands, OpenAI Agents SDK, Google ADK, LlamaIndex, or custom code). It does not care what model powers your agent. You bring the brain. AgentCore handles everything else.
The fastest path? Two API calls. Here is what that looks like using the AgentCore CLI:
# Create a harness projectagentcore create --name myresearchagent --model-provider bedrock
# Deploy to productionagentcore deploy
# Invoke your agentagentcore invoke --harness myresearchagent \ --session-id "$(uuidgen)" \ "Research three tropical vacation options under $3k."Or directly with Python and boto3:
import boto3
client = boto3.client("bedrock-agentcore", region_name="us-west-2")
response = client.invoke_harness( harnessArn="arn:aws:bedrock-agentcore:us-west-2:123456789012:harness/MyHarness-XyZ123", runtimeSessionId="1234abcd-12ab-34cd-56ef-1234567890ab", messages=[{ "role": "user", "content": [{"text": "Research three tropical vacation options under $3k."}] }],)
for event in response["stream"]: if "contentBlockDelta" in event: delta = event["contentBlockDelta"].get("delta", {}) if "text" in delta: print(delta["text"], end="", flush=True)That is a production agent. Isolated in its own microVM. With memory. With observability. With identity management. Running in minutes.
The 13 Building Blocks (Grouped by What They Solve)
Problem 1: "Where does my agent run?"
Runtime is serverless compute built for agents. Each user session gets its own isolated microVM (not a shared container). Your agent can run for up to 8 hours per session, handle payloads up to 100MB (text, images, audio, video), and stream responses in real time over HTTP or WebSocket. You only pay for active computation. When your agent is waiting for an API to respond? Free. That matters because agents spend 30 to 70 percent of their time waiting.
Harness is the zero-infrastructure option. Declare your agent (model, tools, instructions) and Harness manages the entire execution loop. No container images. No deployment pipelines. Every session gets a filesystem and shell access, so the agent can read files, run commands, and write code safely. Memory provisions automatically.
Problem 2: "How does my agent use tools?"
Gateway converts any API into a tool your agent can discover and use through the Model Context Protocol (MCP). Feed it an OpenAPI spec, a Lambda function, or an existing MCP server, and Gateway handles the auth, the routing, and the execution. Pre-built connectors exist for Salesforce, Zoom, Jira, and Slack. Agents can find tools semantically (by meaning, not exact name), so you do not need to hard-code every integration.
Registry is the organizational catalog. When you have dozens of teams building agents and tools, Registry provides governed publish, review, and approve workflows so agents can discover what already exists.
Problem 3: "How does my agent remember things?"
Memory provides both short-term (within a session) and long-term (across sessions) persistence. The agent recognizes returning users, picks up where conversations left off, and learns preferences over time. Multiple agents can share the same memory store. Memory types include semantic, summarization, user-preference, and episodic.
Problem 4: "How do I keep it secure?"
Identity handles authentication for agents acting on behalf of users or autonomously. It integrates with Amazon Cognito, Okta, Microsoft Entra ID, Auth0, and any OAuth 2.0 provider. Credentials live in a secure token vault. The agent never sees raw API keys.
Policy (preview) intercepts every tool call before execution. Write guardrails in plain English or in Cedar (AWS's policy language): "Never allow the agent to delete production data." "Redact PII before passing to external tools." Deterministic enforcement, not probabilistic.
Problem 5: "How do I know if it is working?"
Observability provides end-to-end tracing for every agent step. OpenTelemetry-compatible. Traces stream automatically to Amazon CloudWatch, with integrations for Datadog, Grafana, New Relic, Dynatrace, Arize Phoenix, and LangSmith. You can visualize exactly where execution diverged from expectations.
Evaluations (preview) automatically assesses whether your agent performs well across diverse inputs. Built-in and custom evaluators score agents using LLM-as-judge techniques.
Optimization generates AI-powered recommendations to improve prompts and tool descriptions, with A/B testing through traffic splitting to prove improvements work.
Problem 6: "What about specialized capabilities?"
Code Interpreter gives your agent a sandboxed environment to write and execute Python, JavaScript, or TypeScript. Crunch numbers, generate charts, transform data, all safely isolated.
Browser provides a managed Playwright-based cloud browser. Agents can navigate websites, fill forms, click buttons, and extract information. Supports persistent browser profiles (cookies survive across sessions), proxies, and Chrome extensions.
Payments enables agent-native microtransactions using the x402 protocol (HTTP 402 Payment Required). Your agent can pay for premium APIs or MCP servers, with configurable spending limits.
The Numbers
What | Spec |
|---|---|
Time to production agent | 2 API calls (Harness) |
Max session duration | 8 hours |
Max payload | 100MB |
Billing model | Active consumption only (I/O wait free) |
Compute cost | $0.0895/vCPU-hour, $0.00945/GB-hour |
Gateway cost | $5.00/million invocations |
Memory cost | $0.00025/event (short-term) |
Harness surcharge | None (pay only for underlying resources) |
Frameworks supported | Strands, LangGraph, LangChain, CrewAI, LlamaIndex, Google ADK, OpenAI Agents SDK, custom |
Models supported | Amazon Nova, Claude, Llama, Mistral, GPT, Gemini, any OpenAI-compatible endpoint |
Regions | 14+ (US, Europe, Asia Pacific, Canada, GovCloud) |
GA date | October 13, 2025 |
The Honest Tradeoff
AgentCore is framework-agnostic and model-agnostic. You can swap Claude for GPT for Gemini mid-session and the conversation keeps its context. That flexibility is real.
But here is the other side: while the model is portable, the operational layer is not.
Your agent's memory lives in AgentCore Memory. Your tool integrations run through AgentCore Gateway. Your OAuth tokens sit in AgentCore Identity's vault. Your observability traces flow through AgentCore Observability. The context your agent accumulates over months of conversations, the preferences it learns, the tool connections it depends on, all of that is AWS.
That is not a criticism. It is a design choice that exists in every managed agent platform today. But you should know it going in.
AWS does offer an escape hatch: a CLI command exports a Harness agent as Strands-based code. But the exported agent still depends on the same AWS primitives to run. It is a move from configuration to code, not a move off AWS.
The practical calculus: if you are already on AWS, this is straightforward. If multi-cloud portability is a hard requirement, architect your agent logic as a thin layer above the platform services, so the core reasoning is portable even if the infrastructure is not.
Who Is Already Using It
AWS reported that tasks performed by agents on AgentCore grew 15x in six months after GA. Named production customers include Nasdaq, Visa, Experian, Clearwater Analytics, Cox Automotive, Druva, Ericsson, National Australia Bank, Sony, and Thomson Reuters.
The AgentCore SDK crossed over one million downloads at launch.
Getting Started
Four commands:
pip install amazon-bedrock-agentcore-sdkagentcore create # scaffolds your projectagentcore dev # runs locally for testingagentcore deploy # ships to productionOr skip the CLI entirely and use the two-API-call Harness path shown above.
Resources:
The Bottom Line
The race in AI infrastructure has shifted. The foundation model is table stakes. Everyone has access to Claude, GPT, Gemini, Llama. The question is no longer "which model should I use?" It is "how do I get my agent into production without burning three months on plumbing?"
AgentCore is AWS's answer. Two API calls to deploy. Active-consumption billing (you do not pay for your agent to wait). Any framework, any model, swap freely. Thirteen modular services you can adopt incrementally.
The tradeoff is clear: you get speed and simplicity in exchange for operational coupling to AWS. For most teams, that is a trade worth making. Just make it with your eyes open.
All technical specifications, pricing, and capabilities sourced from Amazon Bedrock AgentCore Documentation , AWS Pricing , and the GA Announcement Blog (October 2025). Current as of July 2026.
About the author
Carlos Calderon
is a Solutions Architect at AWS, serving as a technical advisor to ISV and SaaS companies on cloud architecture and generative AI. With a background in leading AWS data center operations, he works with customers from architecture through deployment and mentors SAs and engineers across the builder community.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article