Amazon Bedrock AgentCore: Deploy Production AI Agents on AWS (2026)

Amazon Bedrock AgentCore is AWS's answer to the hardest part of building AI agents: not prototyping them, but running them in production. Frameworks like Strands, LangGraph, and CrewAI make a proof-of-concept easy. Turning that POC into an agent that serves thousands of users — with session isolation, memory, identity, tool access, and observability — is where teams stall. AgentCore provides exactly that production substrate as managed AWS services.

It went generally available on October 13, 2025, and it's directly relevant if you're studying for the AWS Certified Generative AI Developer – Professional (AIP-C01) exam, where agentic AI is a core domain. This guide covers what AgentCore actually is, its component services, framework support, a realistic deployment workflow, and how it maps to the exam.

What Is Amazon Bedrock AgentCore?

AgentCore is a set of modular services for building, deploying, and operating AI agents securely at scale — using any framework and any foundation model, without managing servers. The services work together or independently, so you can adopt just the runtime, or layer on memory, identity, and tool access as your agent matures.

The key design choice is that AgentCore is framework- and model-agnostic. You don't have to rewrite your agent in an AWS-specific format. Bring a Strands or LangGraph agent, point it at Claude, Nova, or an external model, and AgentCore handles the production plumbing.

The 7 Core AgentCore Services

At launch, AgentCore shipped seven services. These are the stable canon to know:

AWS has continued to expand the suite since GA with additional services — including AgentCore Policy (deterministic guardrails on tool calls) and AgentCore Evaluations (automated agent quality assessment), both introduced in preview. Treat the newer additions as an expanding edge of the platform; the seven above are the production-stable core.

Framework and Model Support

This is where AgentCore differentiates itself from a lock-in platform:

• Frameworks: Strands Agents, LangGraph (LangChain), CrewAI, LlamaIndex, Google ADK, and the OpenAI Agents SDK — plus custom frameworks.
• Models: Any foundation model, inside or outside Bedrock — Anthropic Claude, Amazon Nova, OpenAI, Google Gemini, Meta Llama, Mistral.
• Protocols: MCP (Model Context Protocol) for agent-to-tool communication, and A2A (Agent-to-Agent) for multi-agent coordination.

If you've built an agent and don't want to throw away your framework choice to get it into production, that's the whole point.

How to Deploy an Agent on AgentCore

The current workflow uses the AgentCore CLI. Here's the high-level shape — enough to understand the model, not a full tutorial:

1. Install the CLI. It ships as an npm package (@aws/agentcore); you'll need Node 20+ and Python 3.10+.
2. Scaffold the project with agentcore create. A wizard picks your framework (Strands is the recommended default), model provider, and memory mode (none, short-term, or long-term + short-term). It generates an agentcore.json config plus an entrypoint.
3. Test locally with agentcore dev — a local server with hot reload and an inspector to chat with the agent and view traces.
4. Deploy with agentcore deploy. This packages your code (a code-zip artifact by default, or a container if you choose), provisions the infrastructure, creates an AgentCore Runtime endpoint, and wires up CloudWatch logging and observability.
5. Invoke the agent over that endpoint with agentcore invoke --prompt "...".
6. Add capabilities incrementally — agentcore add memory, add gateway, and so on — then redeploy.

The concepts worth internalizing: session isolation (each session runs isolated so one user's state can't leak into another's), short- vs. long-term memory, Identity for OAuth and credential management against your existing IdP, Gateway for governed tool/MCP access, and OTEL-based observability flowing into CloudWatch.

Pricing

AgentCore is consumption-based with no upfront commitment or minimums. As published on the AWS AgentCore pricing page (June 2026):

• Runtime, Browser, Code Interpreter — about $0.0895 per vCPU-hour and $0.00945 per GB-hour, billed per second, with no CPU charge during I/O wait.
• Memory — short-term around $0.25 per 1,000 events; long-term storage $0.75 per 1,000 records/month; retrieval $0.50 per 1,000 retrievals.
• Gateway — tool invocations around $0.005 per 1,000; tool search $0.025 per 1,000.
• Identity — about $0.010 per 1,000 requests for non-AWS resources, and no charge when used via Runtime or Gateway.
• Observability — standard Amazon CloudWatch rates.

Pricing and regional availability change, so confirm current rates on the AWS pricing page before budgeting.

How AgentCore Fits the AIP-C01 Exam

If you're preparing for the AWS Generative AI Developer – Professional exam, here's the accurate picture — because it's easy to overstate this.

Amazon Bedrock AgentCore is listed in the AIP-C01 in-scope services. So it's fair game. But the exam's Task 2.1 ("Implement agentic AI solutions and tool integrations") names specific tools in its skill bullets:

• Strands Agents and AWS Agent Squad for multi-agent systems
• MCP (Model Context Protocol) for agent-to-tool interactions — including building stateless MCP servers on Lambda and complex MCP servers on Amazon ECS
• Step Functions to implement ReAct patterns, chain-of-thought reasoning, and orchestration safeguards (stopping conditions, timeouts, IAM boundaries, circuit breakers)

So the most exam-accurate way to think about it: the named orchestration patterns center on Strands, Agent Squad, MCP, and Step Functions; AgentCore is the production deployment-and-operations layer those agents run on. Knowing AgentCore's role (runtime, memory, identity, gateway, observability) rounds out your understanding of how an agentic solution actually ships — which is exactly the production-minded thinking AIP-C01 rewards.

Final Thoughts

Bedrock AgentCore is AWS betting that the future of agents isn't a single managed black box, but a production platform you bring your own framework to. For engineers, that's the right abstraction — keep your Strands or LangGraph code, and let AWS handle session isolation, memory, identity, and observability. For AIP-C01 candidates, it's part of the agentic AI story the exam now tests in depth.

The fastest way to actually learn this is to build an agent and deploy it — reading about session isolation and memory is no substitute for wiring them up. Explore our AI & Machine Learning courses for hands-on, project-based training in Bedrock, agents, and production generative AI on AWS, and see the full AIP-C01 study guide if you're working toward the certification.