The thesis: an unbundled agent platform
Lesson 1 of 6 in Amazon Bedrock AgentCore, Service by Service.
In November 2023, AWS shipped Amazon Bedrock Agents: one managed service that owned your whole agent loop. You declared a model, some action groups, a knowledge base, and AWS ran the loop. In July 2025 AWS shipped something with the opposite shape — Amazon Bedrock AgentCore, a set of services you assemble yourself — and by July 30, 2026 the original service had been renamed Agents Classic and closed to new customers.
That is not a rebrand. It is a bet on a different architecture, and the bet has three parts.
Framework-agnostic. AgentCore works with any agent framework — CrewAI, LangGraph, LlamaIndex, Strands Agents, the OpenAI Agents SDK, the Claude Agent SDK, or code you wrote yourself. Model-agnostic. It is not restricted to models hosted on Amazon Bedrock. Modular. The services work together or independently: you can put a LangGraph agent on AgentCore Runtime and use nothing else, or keep your agent on EKS and adopt only Gateway and Memory.
Why unbundle? Because the hard parts of production agents are not the loop. The loop is thirty lines of code you already know how to write. The hard parts are: isolating one user’s session from another’s, holding memory across sessions without hand-rolling a database, turning your existing REST APIs into tools the model can see, giving the agent an identity that is not a shared IAM key, stopping it from calling the tool it should not call, and being able to explain what it did afterwards.
Each of those is a distinct, boring, infrastructural problem — and each is a separate AgentCore service. Read the catalogue below as an inventory of the problems, not a product list. If you are building agents anywhere, you need answers to all ten rows; AgentCore is one set of answers.
Key terms: agent loop, MCP, memory, tool, sandboxing, least privilege
| Service | The problem it exists to solve | What you would otherwise build |
|---|---|---|
Runtime | Run an agent process per session, isolated, for as long as the task takes. | Containers, an autoscaler, and a story for why two users’ sessions cannot see each other’s files. |
Memory | Keep raw turns inside a session and distilled facts across sessions. | A message store, an extraction pipeline, embeddings, and a retrieval API. |
Gateway | Expose existing APIs, Lambda functions and remote MCP servers as MCP tools, with discovery. | An MCP server per backend, plus credential plumbing on both sides. |
Identity | Give each agent its own identity, and let it act on behalf of a user against third-party services. | A workload identity scheme and an OAuth token store you really do not want to own. |
Policy | Decide, deterministically, whether this tool call with these arguments is allowed. | Authorization checks scattered through agent code the model can talk its way around. |
Code Interpreter | Let the agent run code it just wrote, without that code running next to your credentials. | A sandbox with resource caps, package management, and a network policy. |
Browser | Drive a real browser for systems with no API, and let a human watch or take over. | Headless Chrome fleet management, plus session recording for the audit trail. |
Observability | See sessions, traces and spans for a non-deterministic system. | OpenTelemetry instrumentation and a dashboard that understands agent semantics. |
Evaluations | Score agent quality on demand in CI and continuously in production. | A judge harness, a sampling pipeline, and a metrics namespace. |
Agent Registry | Let people and agents find the agents, tools and MCP servers your org has published. | A wiki page that is out of date, or a homegrown catalogue nobody governs. |
Which AgentCore service should you adopt first?
Interactive decision tree — outcomes:
- Runtime (microVM sessions)
The default serverless substrate: one dedicated microVM per session, up to an 8-hour lifetime. Bring your container, keep your framework. Treat session state as ephemeral — durable context belongs in Memory.
- Runtime Instances
EC2-backed sessions (GA August 2026) with persistent volumes that re-attach on resume and lifetimes up to 14 days — for long-lived agents and GPU-shaped work. You pay managed-compute charges on top of EC2.
- Gateway
Point it at Lambda functions, API Gateway stages, OpenAPI schemas, Smithy models or existing MCP servers and it publishes them as MCP tools with built-in semantic search. This is the highest-leverage first adoption for most enterprises — no agent rewrite required.
- Memory
Short-term events per (actor, session), plus long-term extraction driven by strategies. Usable from an agent running anywhere — you are calling an API, not moving your compute.
- Observability (then Evaluations)
Instrument first, judge second. Agents on Runtime are auto-instrumented; agents on EKS, Lambda or another cloud can ship OTel telemetry to the same CloudWatch dashboards. You cannot evaluate traffic you are not capturing.
Interactive checkpoint quiz (2 questions) — open this page in a browser to take it.