AWS launched Amazon Bedrock AgentCore in July 2025 as a managed service designed to help organisations deploy AI agent prototypes into secure, scalable production environments. The platform eliminates the “undifferentiated heavy lifting” that typically challenges this transition from lab to production.
AgentCore shifts AI agent development by providing enterprise-grade services for runtime, identity, memory, and observability, enabling teams to focus on business logic rather than infrastructure. This offers three key benefits: faster deployment, flexible model and framework choice, and built-in security.
The platform’s model-agnostic and agentic framework-agnostic design positions AWS as a production layer for agentic AI development, regardless of developers’ choice of foundation models or open-source frameworks, addressing a market need for reliable, flexible AI agent deployment infrastructure.
The Evolution of Agentic AI and the Need for a Production-Grade Platform
Agentic AI systems can reason, plan, and autonomously execute multi-step tasks by interacting with external systems and adapting to dynamic environments. This has led to numerous AI agent prototypes demonstrating potential for business automation, from customer service to internal workflows.
However, as always, a significant gap exists between prototype development and production deployment. Enterprises face production-grade infrastructure requirements, including secure, scalable runtime environments, enterprise-grade security with session isolation, and standardised identity management. Additionally, orchestrating and debugging multi-step workflows requires sophisticated monitoring and auditing tools, which are often lacking. Furthermore, companies want to leverage off-the-shelf agentic app features—such as long-term memory and common tools like browser use and code interpreters—without having to rebuild and manage everything from scratch themselves.
These challenges have created a bottleneck preventing many promising projects from moving beyond experimentation. Amazon Bedrock AgentCore addresses this market need by providing standardised agent infrastructure. This allows development teams to focus on business logic and value, rather than operational complexities and enabling the next phase of enterprise AI agent adoption.
What is Amazon Bedrock AgentCore?
Amazon Bedrock AgentCore is a modular and fully managed suite of services designed for the secure deployment and operation of production-ready AI agents at scale.
It is not a single tool but rather a collection of composable services that developers can use together or independently, based on their specific needs. AgentCore aims to eliminate the “undifferentiated heavy lifting” of building agent infrastructure, including manual runtime configuration, custom memory solutions, and complex security implementation.
The architecture of AgentCore is built upon a set of core components. These foundational services include AgentCore Runtime, AgentCore Gateway, AgentCore Memory, AgentCore Identity, and AgentCore Observability. The platform also offers auxiliary tools such as Code Interpreter and Browser Use to easily enhance agent capabilities.
AgentCore is designed as a framework-agnostic platform supporting popular open-source frameworks like CrewAI, LangGraph, LlamaIndex, and, obviously, Strands Agents, while working with any foundation model hosted on Amazon Bedrock, Sagemaker AI or elsewhere. This approach positions AWS as an operational layer for agentic AI development without requiring developers to abandon their preferred frameworks or models. By reducing vendor lock-in and providing modular infrastructure, AWS aims to capture the operational layer of the AI market while prioritising developer choice and flexibility.
A Paradigm Shift in Agent Productionisation
Amazon Bedrock AgentCore shifts AI agent productionisation from complex infrastructure management to component architecturing. Previously, teams faced:
- Non-standardised and sometimes manual provisioning of runtime environments,
- Ad-hoc API integrations with custom authentication and access controls,
- Fragmented security implementations for session isolation,
- Limited, effortless operational visibility with basic logging and debugging capabilities
With Amazon Bedrock AgentCore, this entire process is streamlined and abstracted into a set of managed services. The infrastructure for the agent’s runtime is fully managed and serverless, automatically scaling to meet dynamic workload demands.
Tool integration is accelerated through the AgentCore Gateway. It transforms APIs and AWS Lambda functions into standardised, agent-ready tools with minimal code. Native security features, such as complete session isolation in the Runtime and automated identity management in the Identity service, are built-in from the ground up, providing a secure foundation by default. Operational visibility is holistic and automated, with the Observability service providing real-time dashboards and step-by-step visualisations of agent execution.
This shift results in a profound increase in developer velocity. By handling infrastructure complexities, AgentCore enables faster prototype-to-production deployment. The platform’s value lies in removing key friction points in the AI agent lifecycle. This allows developers to focus on unique application logic rather than operational requirements.
The Core Services of Bedrock AgentCore
Amazon Bedrock AgentCore is a composable platform. Each of its services is designed to provide a specific, critical function in the agent lifecycle. The following sections provide a detailed technical breakdown of each of these core components.
AgentCore Runtime
The AgentCore Runtime provides a serverless execution environment optimised for AI agent workloads with complete session isolation to prevent data leakage. It supports both short real-time interactions and long-running tasks up to eight hours, while remaining framework-agnostic to work with popular options like CrewAI, LlamaIndex, and LangGraph. Currently, you can define a maximum running time, but the maximum used memory cannot be configured.
AgentCore Gateway
The AgentCore Gateway connects AI agents to existing tools and services by transforming APIs and AWS Lambda functions into a standardised, agent-consumable format. It creates Model Context Protocol (MCP) compatible tools with a zero-code approach and includes dual-sided authentication for secure access control.
AgentCore Memory
AgentCore Memory is a fully managed service that provides a persistent context for agents across interactions. It removes the burden of managing complex data stores and state management logic. The service provides both short-term memory, which maintains context within a single user session, and long-term memory, which allows the agent to retain insights and knowledge across multiple interactions.
AgentCore Identity
The AgentCore Identity service provides secure and scalable identity and access management for AI agents. This service enables agents to securely access both AWS resources and third-party services on behalf of a user or autonomously with pre-authorised user consent. It streamlines the authorisation flow by integrating with enterprise identity providers such as Amazon Cognito, Okta, and Microsoft Entra ID.
AgentCore Observability
AgentCore Observability provides near real-time monitoring of agent performance and behaviour with step-by-step execution visualisation for debugging and auditing. It includes basic dashboards tracking token usage, latency, session duration, and error rates, plus OpenTelemetry integration for existing monitoring systems to make sure you can use your existing monitoring tools like LangFuse or Datadog.
Auxiliary Tools
In addition to its core services, AgentCore includes a growing suite of auxiliary tools that enhance an agent’s capabilities. Code Interpreter provides an isolated, secure sandbox environment. In this sandbox, an agent can execute code to perform tasks like data analysis, mathematical calculations, and visualisation generation. This capability expands an agent’s ability to solve complex, end-to-end tasks.
Similarly, AgentCore Browser provides managed web browser instances. It allows agents to perform and scale complex web automation workflows with features like Live View and Session Replay for troubleshooting and auditing.
Strategic Benefits and Enterprise Value Proposition
Amazon Bedrock AgentCore’s technical capabilities deliver key strategic benefits for enterprise AI adoption.
Accelerated Time-to-Value
AgentCore’s managed services eliminate infrastructure complexity, enabling teams to build agent capabilities immediately with pre-configured runtime, memory, and tool integration. The provided SDK and starter kits streamline development, allowing faster deployment from prototype to production and quicker return on AI investments.
Enterprise-Grade Security and Trust
AgentCore meets strict security standards with complete session isolation, preventing data leakage, auditable authentication through the Identity service, and comprehensive audit trails via Observability. These features enable confident deployment of agents that operate reliably and securely at scale, meeting governance and compliance requirements.
Flexibility and Choice
The platform’s framework- and model-agnostic design supports popular open-source frameworks and any foundation model, preventing vendor lock-in. Organisations can adapt to new models or frameworks without rebuilding infrastructure, future-proofing their AI strategy while maintaining control over their technology stack.
Operational Efficiency and Scalability
The serverless architecture automatically scales to meet demand, eliminating manual resource provisioning and optimising costs through pay-per-use pricing. Integrated observability provides performance insights for proactive monitoring and optimisation without requiring custom solutions.
Bedrock AgentCore within the Broader AWS Ecosystem
Amazon Bedrock AgentCore serves as the production layer for AI agent applications. It extends existing AWS generative AI services to complete the deployment lifecycle.
Amazon Bedrock provides access to foundation models and includes Bedrock Agents for experimentation and Bedrock Flows for visual workflow orchestration. AgentCore bridges the prototype-to-production gap with Runtime, Gateway, Memory, and Identity services. These services enable secure, scalable agent deployment in enterprise environments.
AgentCore integrates natively with core AWS services: Observability connects with Amazon CloudWatch for monitoring and audit trails, the SDK automates AWS IAM role creation, and the Identity service integrates with IAM for authentication. The concurrent launch of Amazon S3 Vectors, which provides native vector support for RAG operations through integration with Bedrock Knowledge Bases and OpenSearch Service, supports AgentCore’s ability to build data-driven agentic systems with proprietary enterprise data.
Strategic Recommendations and Future Outlook
Amazon Bedrock AgentCore presents a compelling platform for organisations committed to deploying AI agents at scale.
For Enterprise Architects, AgentCore should be evaluated as the standardised platform for all production-grade AI agent workloads. Its focus on enterprise-grade security, particularly features like complete session isolation and integrated identity management, directly addresses critical compliance and data governance concerns for handling sensitive information.
For DevOps Teams, the platform offers a significant reduction in operational toil. Fully-managed services handle agent runtime and observability infrastructure automatically. Teams can focus on strategic monitoring, performance optimization, and operational reliability instead.
For Product Managers, AgentCore’s accelerated time-to-value and its flexibility to use any foundation model or framework can be leveraged to bring innovative, agent-powered features to market faster. This de-risks the technology selection process and allows for greater agility in product development.
While the platform is currently in preview, the early feature set is promising. The stated roadmap indicates a clear, forward-looking strategy. The upcoming support for VPCs for even greater network isolation and built-in multi-agent orchestration for complex, collaborative systems points to AWS’s intention to continuously enhance AgentCore to address the next layers of complexity in the agentic AI landscape. The platform’s commitment to emerging standards like the Model Context Protocol (MCP), Agent2Agent (A2A) further suggests that AWS is positioning AgentCore as a central, reliable hub for a future where agents from different vendors can interoperate seamlessly.
Amazon Bedrock AgentCore: Our Insights
At Devoteam, we have started exploring and deploying some of Agentcore’s core components, notably Runtime and Observability.
Runtime
Runtime looks particularly promising for three main reasons:
- Fast setup – going from your local Strands Agent to a deployed one is seamless. You just need to create a requirements.txt file with your dependencies, use the Starter Toolkit for Dockerisation and deployment, and voilà—your agent is up and running.
- Ease of use – once deployed, interacting with the agent feels smooth and natural.
- Deployment simplicity – no heavy overhead, just a straightforward workflow.
That said, we identified a few pain points:
- Cost control: There’s currently no way to configure maximum CPU usage, meaning your agent can consume as much memory as it wants. This is problematic. You can mitigate cost risks by setting up a timeout limit, but it’s not ideal.
- Time to first token: Cold starts add latency. When interacting directly with your agent, the time to first token is smaller, but if you deploy an infrastructure to act as a middle layer, it must spin up before interacting with the agent, inevitably adding some milliseconds. This is expected but important to keep in mind. We hope this overhead will be reduced to a minimum in the future.
Observability
The Observability dashboards are functional but quite basic. They give a solid consumption overview. But for detailed tracing and logs, you’ll find yourself clicking around repeatedly to get to what you need. Tracing capabilities within Bedrock Agentcore Observability remain very limited and not user-friendly.
For now, we recommend integrating your existing AI monitoring tool instead. Langfuse is a great option: well-designed, with an excellent UI/UX, and not too complex to deploy. We expect that in the coming months, Bedrock Agentcore Observability will reach a much higher standard. But as of today, it’s clearly not there yet.
Overall, the Agentcore suite is very promising, but as usual, there are areas for improvement. We’re confident that in the coming months it will evolve significantly, and we’re already curious to discover the new features that will be announced once it reaches GA (General Availability)—likely at re: Invent in early December.
Also read: The Complete Guide to the AWS AI Agentic Ecosystem