Amazon Bedrock AgentCore for Developers: Runtime, Memory, Gateway and Policy
A developer-oriented tour of Amazon Bedrock AgentCore: its main services, production features, a sample support-assistant architecture and when it is worth adopting.
This article is published in English.
Agent demos tend to impress for about five minutes. After that come the uncomfortable questions. Which machine does the agent run on? What carries its context from one session to the next? How can it reach Slack, Jira or internal APIs without creating a security mess? And once it's live, how do you spot a faulty tool call, a poor answer or creeping latency? Amazon Bedrock AgentCore targets exactly this gap. AWS pitches it as a managed platform to build, deploy and run agents securely at scale, whatever the framework or foundation model.
Think of Bedrock as the model layer and AgentCore as the production layer around the agent. That split matters, because many teams now have no trouble getting models. What stalls them is the long list of work that starts after the first prompt succeeds: runtime, memory, tool access, identity, monitoring, evaluation, governance and cross-team discovery. AgentCore bundles those concerns into one platform, sparing teams from wiring them up with custom glue.
AWS has been moving quickly here. Policy in AgentCore reached general availability on March 3, 2026, Evaluations on March 31, 2026, and AWS Agent Registry went into preview on April 9, 2026. Read together, the dates show a vendor assembling the whole stack for production agents, beyond model access and chatbot demos.
What problems it addresses
The easiest reading of AgentCore is as a list of answers to familiar engineering problems. Moving an agent from demo to production tends to surface the same needs every time:
- A safe place for the agent to run
- Memory that lasts across sessions
- Structured access to tools
- An identity and credentials
- Traces, metrics and quality checks for the team
- Approval flows and reuse across the organization
AgentCore covers these with modular services: Runtime, Memory, Gateway and Identity, the built-in Code Interpreter and Browser tools, plus Observability, Evaluations, Policy and Registry. Because the pieces are modular, you don't have to rebuild your whole stack around one rigid system.
That modularity is among the best things about it. AgentCore doesn't ask you to drop LangGraph, CrewAI, Strands or another framework. AWS states that it's framework-agnostic and model-agnostic, and models outside Bedrock are supported. In practice it feels less like a closed ecosystem and more like infrastructure around agent workloads.
The main building blocks
Runtime
Runtime hosts the code of the agent or tool. According to AWS it offers deployment independent of framework, automatic scaling, built-in security, microVM-based isolation and sessions lasting as long as eight hours. That last pair deserves attention: agents aren't handled as brief functions but as workloads that keep state, take many steps and need to stay up until a real task is done.
Memory
Memory addresses a classic weakness of agent systems, which is that they forget everything. AgentCore Memory keeps short-term context for the current session and long-term memory that survives between sessions. Teams get a managed service and don't have to design their own memory layer, extraction flow and retrieval logic.
Gateway
Gateway is the link between an agent and its surrounding tools. AWS says it converts APIs, Lambda functions and other services into tools agents can call through managed connectors. February 2026 brought server-side tool execution via a Gateway integration with the Bedrock Responses API, which removes some client-side orchestration and cuts down on brittle tool loops in application code.
Identity
Identity is the part that signals a serious platform. AgentCore Identity serves non-human identities and automated workloads, handling authentication, authorization and credential management for agents and tools. SigV4, OAuth 2.0 flows and API keys are supported. When an agent works on a user's behalf, reaches internal systems or calls outside services, identity becomes a feature in its own right and not hidden plumbing.
Built-in tools
Two tools come built in. With Code Interpreter, an agent can write, execute and debug code inside an isolated sandbox. Browser provides a managed browser runtime for moving around sites and interacting with them. AWS continues to extend both: browser profiles arrived in February 2026, Chrome policies and custom root CA support in March, and OS-level interaction in April. The direction is plain enough, with agents meant to work inside real enterprise environments instead of tidy sandboxes.
Production features
So far AgentCore may sound like a box of parts for running agents, but the larger story starts after the agent exists. Production systems need visibility, control and a way to measure quality over time. That's the job of Observability, Evaluations, Policy and Registry.
- Observability helps trace, debug and monitor agents live, with step-level visibility into workflows: execution paths, intermediate outputs, bottlenecks and failures.
- Evaluations assesses agent quality automatically, either online against production traffic or on demand for testing workflows.
- Policy adds central control over agent-to-tool interactions, outside the agent's own code.
- Registry is a governed catalog where agents, tools, MCP servers, skills and custom resources can be published, reviewed, approved and discovered across the organization.
Why it matters
Many AI write-ups spend too long on the model and too little on operations, which doesn't match how delivery feels inside a team. Delays rarely trace back to the first prompt. Most of them come from the platform work surrounding it. Once a prototype draws attention, the requests pile up:
- Product asks for memory that persists.
- Security asks for permission boundaries.
- Platform engineers ask for logs and traces.
- QA asks for evaluations they can repeat.
- Developers ask for tool integrations that survive change.
- Management asks for shared building blocks in place of five isolated agent projects.
That's the real problem here. AWS takes the undifferentiated infrastructure around agents and offers it as managed services, which moves more team time toward agent behavior, business rules and user value.
A realistic system
Take a support assistant embedded in a SaaS product. The customer types into the chat panel and a model behind Bedrock receives the request. The agent's logic lives in AgentCore Runtime. Memory brings back the latest session context plus earlier facts about this customer. Gateway presents tools such as Jira, billing APIs, Slack and internal case systems. Identity decides who may access what and holds the credentials. Observability stores the trace, Evaluations keeps scoring answer quality over time, and Policy stops risky tool calls. Registry earns its place later, when more teams start publishing tools and skills company-wide.
This example resolves a frequent confusion. AgentCore is neither the model nor the app interface nor your product logic. It's the operational layer in the middle, the part that lets the agent run, remember, connect, stay observable and stay under control.
When to reach for it
AgentCore makes the most sense when a team is moving from "it works in a demo" to "it must survive in production."
It fits well when:
- The agent needs genuine sessions and state.
- It needs safe access to tools and services.
- The team wants to be able to trace what happened after launch.
- You want structured quality evaluation.
- More than one team will likely build or reuse agents and tools.
It's less urgent when:
- The idea is still a proof of concept.
- The workflow is a small internal experiment with no actual users, permission concerns or operational risk so far.
- There are no real users, permissions or operational risks yet.
Not every project needs it on day one, and a lightweight prototype is often the better early choice. AgentCore pays off once the question changes from whether the agent works to how to run it safely, repeatedly and at scale. AWS's own emphasis on governance, observability and approval flows supports that reading.