Reimagine AI agents with Amazon Bedrock AgentCore

Say you’ve perfected your AI agent’s logic.

It runs flawlessly on your machine and it's ready to change the world. But now comes the hard part: deployment. The thought of wrestling with servers, security, and scaling is daunting.

This is the year of AI agents. And while building them is half the battle, making them work reliably in production is where things get messy. From stitching tools and data sources together to handling infrastructure, scaling, and orchestration, deploying agents can feel like an endless puzzle.

But what if you could skip the chaos? What if you could launch your agent into a secure, production-ready environment as easily as you run locally?

AWS just introduced Bedrock AgentCore, a toolkit for implementing agents easily. It is designed to transform your AI agent ideas from a simple prototype into a pr​​oduction-ready application that millions can use.

In this newsletter, we’ll talk about the essential components of AgentCore, explaining what each one does and how they work together to create amazing AI experiences.

AgentCore Runtime: Core execution environment for SageMaker agents#

Think of the AgentCore Runtime as the foundation where your AI agent lives and operates. It provides a framework-agnostic environment for running agents. In simple terms, you can deploy any local agent in LangGraph, LangChain, CrewAI, Strands, or any other custom agent framework, and deploy it to the cloud using AgentCore Runtime.

Here’s a list of key features of AgentCore Runtime:

• Model support: It supports any large language model (LLM), including those offered by Bedrock, Anthropic, and Claude.

• Protocol support: It allows agents to communicate with each other via the Model Context Protocol (MCP).

• Secure: Each agent session runs in an isolated environment, ensuring user data is kept private and secure.

• Long-running tasks: It supports tasks that can run for up to eight hours, making it perfect for complex, multi-step processes.

The AgentCore resources can be deployed using the Bedrock AgentCore starter toolkit. It is a Python-based CLI tool that allows us to locally test and deploy the AI agents as scalable, serverless services. It offers three main commands:

• agentcore configure: Generates a Dockerfile, .dockerignore, and .bedrock_agentcore.yaml config files. It optionally auto-creates the Elastic Container Registry (ECR) repository.

• agentcore launch: This builds and runs the agent locally at http://localhost:8080, perfect for quick testing.

• agentcore invoke: This command builds a Docker image and pushes it to the ECR. The image is then deployed on AgentCore Runtime.

AgentCore Gateway: The agent’s brain#

Imagine your agent needs to use a specific tool that isn’t built-in, like an internal company service or a public API. The AgentCore Gateway is a secure bridge that lets the agent easily connect with these external tools. It exposes these tools via the Model Context Protocol (MCP) to allow agents to communicate easily.

MCP serves as a unified endpoint for agents and tools to communicate with each other. It handles request authentication, transformation, and routing independently.

AgentCore Gateway supports several types of tools and integration methods, making it incredibly flexible:

• OpenAPI specifications: We can transform the existing REST APIs into tools the agent can use. Just provide an OpenAPI specification, and the Gateway automatically handles the translation between the agent’s protocol (MCP) and the API’s format. For example, our agent can get live data from an external weather API.

• Lambda functions: Connect AWS Lambda functions directly as tools. This is perfect for running custom business logic. For example, a Lambda function that reads customer data from a DynamoDB table can be exposed as a tool for the agent to find customer details.

• Smithy models: For a more AWS-native approach, we can use Smithy, a language for defining services, to model the APIs. The Gateway can use these models to generate tools that interact seamlessly with AWS services or custom APIs.

AgentCore Gateway features semantic search to navigate large tool catalogs. This built-in capability enables AI agents to intelligently locate the most relevant tools for a task. Instead of relying on exact keyword matches, it uses contextual understanding to match the agent’s prompt or intent to the best tools available. It reduces latency and prompt size by avoiding manual tool look-up and optimizes the agent’s performance.

AgentCore Tools: The agent’s toolbox#

The agent needs the right tools to perform complex tasks. AgentCore Tools provides prebuilt, powerful capabilities to easily add to our agent. AgentCore provides two key built-in tools.

AgentCore browser tool#

Agents often need access to real-time data from websites and applications that do not offer APIs or API integration. Similarly, companies struggle to scale web automation with AI for enterprise needs due to concurrency and maintenance issues.

The AgentCore browser tool lets agents interact with web applications and external resources in real time to research and access up-to-date dynamic data. It allows the agent to interact with websites, fill out forms, and gather information from the web just like a human would.

Code interpreter#

This is a sandboxed environment where your agent can safely write and execute code to perform calculations, analyze data, or create visualizations. It offers prebuilt runtimes for multiple languages, supports large files, and provides internet access. To ensure isolation and security, it executes code in a containerized environment.

AgentCore Memory: Storing details for later#

An agent must remember past interactions to provide a personalized and intelligent experience. AgentCore Memory is a fully managed service that gives your agent both short-term and long-term memory without you having to worry about setting up databases or vector stores.

Short-term memory#

This is like the agent’s working memory. It stores the raw conversation history so the agent can understand the context of the current dialogue and have a natural, multi-turn conversation. It enables agents to list the previous events or access any specific ones.

Long-term memory#

This is where the agent builds lasting knowledge. Instead of just storing raw text, it automatically and intelligently extracts key information from conversations and consolidates it.

Long-term memory allows us to configure different strategies for how the agent builds its long-term memory. These strategies tell the agent what kind of information to extract from conversations, such as:

• Summarization: This strategy automatically creates a summary of the entire conversation, so the agent can quickly recall the main points of past interactions without needing to read the whole transcript.

• Semantic memory: This strategy extracts key facts and information from the conversation. For example, if a user mentions that “Project Alpha’s deadline is Friday,” the agent stores that specific fact for future reference.

• User preferences: This strategy identifies and remembers users’ tastes or choices. For instance, if a user consistently asks for code examples in Python, the agent learns this preference and will favor Python in future responses.

This allows the agent to become more personalized and helpful over time. We can also define our custom strategies for building long-term memory.

AgentCore Identity: The unique fingerprint#

AgentCore Identity is an AWS Identity and Access Management service that allows agents and their tools to communicate with other AWS services and third-party tools using the user’s authentication credentials. It is a centralized hub for managing access credentials, supporting hierarchical structures, and controlling group-based access.

It also offers a token vault to store OAuth 2.0 tokens, OAuth client credentials, and API keys. This vault implements strict access control to ensure only authorized agents can access the credentials.

AgentCore Identity simplifies secure connections by providing native support for OAuth 2.0 flows, handling the complex parts of authentication:

• Flexible authentication: It supports direct machine-to-machine connections and impersonation flows, where a user grants permission for the agent to access data on their behalf.

• Prebuilt integrations: It comes with preconfigured credential providers for popular services like Google, GitHub, Slack, and Jira, saving significant development time. We can also configure providers for any other OAuth 2.0-compatible service.

• Seamless SDK integration: Simple annotations in the AgentCore SDK (like @requires_access_token) automate the entire process of retrieving and injecting credentials, to reduce code complexity.

AgentCore Observability: The control tower#

AgentCore Observability enables end-to-end tracing, monitoring, and debugging of an agent’s workflow. All spans, metrics, and logs are stored in Amazon CloudWatch, where dashboards present key performance data, step-by-step traces of agent interactions, and quick debugging insights. It also emits telemetry for critical efficiency metrics such as token usage, latency, session duration, error rates, and tool invocation success.

The AgentCore Observability is divided into a three-tiered hierarchical structure consisting of the following components:

• Sessions: They represent the full conversation between a user and an agent, maintaining context and state across multiple exchanges. They provide a high-level view of engagement and performance, with default session-level metrics available in Amazon CloudWatch.

• Traces: They capture the complete record of a single request-response cycle within a session, detailing every step. They are useful for troubleshooting and identifying performance bottlenecks, and custom traces are supported through agent code instrumentation.

• Spans: They represent individual steps within a trace, such as parse input or calling an API with precise timing. Organized hierarchically to show the operation flow. Default span data exists for memory resources, and custom spans can be added via code instrumentation.

Together, these components provide a holistic view of an agent’s behavior and allow us to troubleshoot bugs and errors progressively.

Note: AgentCore offers a consumption-based pricing model. This means there are no upfront costs, and we only pay for the resources we utilize for runtime, gateways, built-in tools, identity, memory, and observability.

What’s next? #

Amazon Bedrock AgentCore is a comprehensive suite of services designed to take your AI agents from prototype to production. It handles the complex infrastructure tasks, security, memory, and tool integration, letting you focus on building intelligent applications.

Whether you’re looking to quickly experiment with a new idea or build a robust, enterprise-grade application, AgentCore can be your go-to application.

Want to learn about building agents with Amazon Bedrock? Here’s a list of resources that can get you started with Amazon Bedrock Agents:

1. Getting Started with Amazon Bedrock Agents: To learn about agents for Amazon Bedrock and how they enhance large language models (LLMs) by managing context and executing actions.

2. Build a Conversational Agent Using Amazon Bedrock Agents: In this lab, you’ll design a conversational agent using Amazon Bedrock Agents. This challenge-based exercise is designed for hands-on practice; step-by-step instructions will not be provided.

3. Building Multiple Agents Using CrewAI and Bedrock: In this Cloud Lab, you’ll build CrewAI agents with Amazon Bedrock to future-proof your skills by creating Knowledge Bases, using foundational models, and integrating vector stores.