Introducing Amazon Bedrock AgentCore: Securely deploy and function AI brokers at any scale (preview)

In only a few years, basis fashions (FMs) have developed from getting used on to create content material in response to a consumer’s immediate, to now powering AI brokers, a brand new class of software program purposes that use FMs to purpose, plan, act, be taught, and adapt in pursuit of user-defined targets with restricted human oversight. This new wave of agentic AI is enabled by the emergence of standardized protocols corresponding to Mannequin Context Protocol (MCP) and Agent2Agent (A2A) that simplify how brokers join with different instruments and techniques.

In truth, constructing AI brokers that may reliably carry out complicated duties has turn into more and more accessible because of open supply frameworks like CrewAI, LangGraph, LlamaIndex, and Strands Brokers. Nonetheless, transferring from a promising proof-of-concept to a production-ready agent that may scale to 1000’s of customers presents vital challenges.

As an alternative of having the ability to give attention to the core options of the agent, builders and AI engineers should spend months constructing foundational infrastructure for session administration, id controls, reminiscence techniques, and observability—on the identical time supporting safety and compliance.

In the present day, we’re excited to announce the preview of Amazon Bedrock AgentCore, a complete set of enterprise-grade companies that assist builders shortly and securely deploy and function AI brokers at scale utilizing any framework and mannequin, hosted on Amazon Bedrock or elsewhere.

Extra particularly, we’re introducing in the present day:

AgentCore Runtime – Offers low-latency serverless environments with session isolation, supporting any agent framework together with in style open supply frameworks, instruments, and fashions, and dealing with multimodal workloads and long-running brokers.

AgentCore Reminiscence – Manages session and long-term reminiscence, offering related context to fashions whereas serving to brokers be taught from previous interactions.

AgentCore Observability – Provides step-by-step visualization of agent execution with metadata tagging, customized scoring, trajectory inspection, and troubleshooting/debugging filters.

AgentCore Identification – Permits AI brokers to securely entry AWS companies and third-party instruments and companies corresponding to GitHub, Salesforce, and Slack, both on behalf of customers or by themselves with pre-authorized consumer consent.

AgentCore Gateway – Transforms current APIs and AWS Lambda capabilities into agent-ready instruments, providing unified entry throughout protocols, together with MCP, and runtime discovery.

AgentCore Browser – Offers managed internet browser situations to scale your brokers’ internet automation workflows.

AgentCore Code Interpreter – Provides an remoted setting to run the code your brokers generate.

These companies can be utilized individually and are optimized to work collectively so builders don’t have to spend time piecing collectively parts. AgentCore can work with open supply or customized AI agent frameworks, giving groups the pliability to take care of their most well-liked instruments whereas gaining enterprise capabilities. To combine these companies into their current code, builders can use the AgentCore SDK.

Now you can uncover, purchase, and run pre-built brokers and agent instruments from AWS Market with AgentCore Runtime. With only a few strains of code, your brokers can securely hook up with API-based brokers and instruments from AWS Market with AgentCore Gateway that will help you run complicated workflows whereas sustaining compliance and management.

AgentCore eliminates tedious infrastructure work and operational complexity so growth groups can carry groundbreaking agentic options to market sooner.

Let’s see how this works in observe. I’ll share extra information on the companies as we use them.

Deploying a production-ready buyer help assistant with Amazon Bedrock AgentCore (Preview)
When prospects attain out with an e-mail, it takes time to offer a reply. Buyer help must test the validity of the e-mail, discover who the precise buyer is within the buyer relationship administration (CRM) system, test their orders, and use product-specific data bases to seek out the data required to arrange a solution.

An AI agent can simplify that by connecting to the inner techniques, retrieve contextual info utilizing a semantic knowledge supply, and draft a reply for the help workforce. For this use case, I constructed a easy prototype utilizing Strands Brokers. For simplicity and to validate the situation, the inner instruments are simulated utilizing Python capabilities.

Once I discuss to builders, they inform me that related prototypes, protecting totally different use circumstances, are being inbuilt many corporations. When these prototypes are demonstrated to the corporate management and obtain affirmation to proceed, the event workforce has to outline find out how to go in manufacturing and fulfill the standard necessities for safety, efficiency, availability, and scalability. That is the place AgentCore will help.

Step 1 – Deploying to the cloud with AgentCore Runtime

AgentCore Runtime is a brand new service to securely deploy, run, and scale AI brokers, offering isolation so that every consumer session runs in its personal protected setting to assist stop knowledge leakage—a important requirement for purposes dealing with delicate knowledge.

To match totally different safety postures, brokers can use totally different community configurations:

Public – To run with managed web entry.

VPC-only (coming quickly) – This selection will enable to entry assets hosted in a buyer’s VPC or linked by way of AWS PrivateLink endpoints.

To deploy the agent to the cloud and get a safe, serverless endpoint with AgentCore Runtime, I add to the prototype a number of strains of code utilizing the AgentCore SDK to:

• Import the AgentCore SDK.
• Create the AgentCore app.
• Specify which operate is the entry level to invoke the agent.

Utilizing a unique or customized agent framework is a matter of changing the agent invocation contained in the entry level operate.

Right here’s the code of the prototype. The three strains I added to make use of AgentCore Runtime are those preceded by a remark.

from strands import Agent, instrument
from strands_tools import calculator, current_time

# Import the AgentCore SDK
from bedrock_agentcore.runtime import BedrockAgentCoreApp

WELCOME_MESSAGE = """
Welcome to the Buyer Assist Assistant! How can I aid you in the present day?
"""

SYSTEM_PROMPT = """
You might be an useful buyer help assistant.
When supplied with a buyer e-mail, collect all obligatory information and put together the response e-mail.
When requested about an order, search for it and inform the total description and date of the order to the shopper.
Do not point out the shopper ID in your reply.
"""

@instrument
def get_customer_id(email_address: str):
    if email_address == "[email protected]":
        return { "customer_id": 123 }
    else:
        return { "message": "buyer not discovered" }

@instrument
def get_orders(customer_id: int):
    if customer_id == 123:
        return [{
            "order_id": 1234,
            "items": [ "smartphone", "smartphone USB-C charger", "smartphone black cover"],
            "date": "20250607"
        }]
    else:
        return { "message": "no order discovered" }

@instrument
def get_knowledge_base_info(matter: str):
    kb_info = []
    if "smartphone" in matter:
        if "cowl" in matter:
            kb_info.append("To placed on the quilt, insert the underside first, then push from the again as much as the highest.")
            kb_info.append("To take away the quilt, push the highest and backside of the quilt on the identical time.")
        if "charger" in matter:
            kb_info.append("Enter: 100-240V AC, 50/60Hz")
            kb_info.append("Contains US/UK/EU plug adapters")
    if len(kb_info) > 0:
        return kb_info
    else:
        return { "message": "no information discovered" }

# Create an AgentCore app
app = BedrockAgentCoreApp()

agent = Agent(
    system_prompt=SYSTEM_PROMPT,
    instruments=[calculator, current_time, get_customer_id, get_orders, get_knowledge_base_info]
)

# Specify the entry level operate invoking the agent
@app.entrypoint
def invoke(payload):
    """Handler for agent invocation"""
    user_message = payload.get(
        "immediate", "No immediate present in enter, please information buyer to create a json payload with immediate key"
    )
    outcome = agent(user_message)
    return {"outcome": outcome.message}

if __name__ == "__main__":
    app.run()

The earlier code wants the Strands Brokers modules put in within the Python digital setting:

pip set up strands-agents strands-agents-tools

I then set up the AgentCore SDK and starter toolkit:

pip set up bedrock-agentcore bedrock-agentcore-starter-toolkit

After I activate the digital setting, I’ve entry to the AgentCore command line interface (CLI) offered by the starter toolkit.

First, I exploit agentcore configure --entrypoint my_agent.py -er <IAM_ROLE_ARN> to configure the agent, passing the AWS Identification and Entry Administration (IAM) function that the agent will assume. On this case, the agent wants entry to Amazon Bedrock to invoke the mannequin. The function may give entry to different AWS assets utilized by an agent, corresponding to an Amazon Easy Storage Service (Amazon S3) bucket or a Amazon DynamoDB desk.

I launch the agent domestically with agentcore launch --local. When working domestically, I can work together with the agent utilizing agentcore invoke --local <PAYLOAD>. The payload is handed to the entry level operate. Observe that the JSON syntax of the invocations is outlined within the entry level operate. On this case, I search for immediate within the JSON payload, however can use a unique syntax relying in your use case.

When I’m glad by native testing, I exploit agentcore launch to deploy to the cloud.

After the deployment is succesful and an endpoint has been created, I test the standing of the endpoint with agentcore standing and invoke the endpoint with agentcore invoke <PAYLOAD>. For instance, I cross a buyer help request within the invocation:

agentcore invoke '{"immediate": "From: [email protected] – Hello, I purchased a smartphone out of your retailer. I'm touring to Europe subsequent week, will I have the ability to use the charger? Additionally, I wrestle to take away the quilt. Thanks, Danilo"}'

Step 2 – Enabling reminiscence for context

After an agent has been deployed within the AgentCore Runtime, the context must be continued to be obtainable for a brand new invocation. I add AgentCore Reminiscence to take care of session context utilizing its short-term reminiscence capabilities.

First, I create a reminiscence consumer and the reminiscence retailer for the conversations:

from bedrock_agentcore.reminiscence import MemoryClient

memory_client = MemoryClient(region_name="us-east-1")

reminiscence = memory_client.create_memory_and_wait(
    title="CustomerSupport", 
    description="Buyer help conversations"
)

I can now use create_event to shops agent interactions into short-term reminiscence:

memory_client.create_event(
    memory_id=reminiscence.get("id"), # Identifies the reminiscence retailer
    actor_id="user-123",        # Identifies the consumer
    session_id="session-456",   # Identifies the session
    messages=[
        ("Hi, ...", "USER"),
        ("I'm sorry to hear that...", "ASSISTANT"),
        ("get_orders(customer_id='123')", "TOOL"),
        . . .
    ]
)

I can load the newest turns of a conversations from short-term reminiscence utilizing list_events:

conversations = memory_client.list_events(
    memory_id=reminiscence.get("id"), # Identifies the reminiscence retailer
    actor_id="user-123",        # Identifies the consumer 
    session_id="session-456",   # Identifies the session
    max_results=5               # Variety of most up-to-date turns to retrieve
)

With this functionality, the agent can preserve context throughout lengthy periods. However when a customers come again with a brand new session, the dialog begins clean. Utilizing long-term reminiscence, the agent can personalize consumer experiences by retaining insights throughout a number of interactions.

To extract reminiscences from a dialog, I can use built-in AgentCore Reminiscence insurance policies for consumer preferences, summarization, and semantic reminiscence (to seize info) or create customized insurance policies for specialised wants. Information is saved encrypted utilizing a namespace-based storage for knowledge segmentation.

I alter the earlier code creating the reminiscence retailer to incorporate long-term capabilities by passing a semantic reminiscence technique. Observe that an current reminiscence retailer might be up to date so as to add methods. In that case, the brand new methods are utilized to newer occasions.

reminiscence = memory_client.create_memory_and_wait(
    title="CustomerSupport", 
    description="Buyer help conversations",
    methods=[{
        "semanticMemoryStrategy": {
            "name": "semanticFacts",
            "namespaces": ["/facts/{actorId}"]
        }
    }]
)

After long-term reminiscence has been configured for a reminiscence retailer, calling create_event will robotically apply these methods to extract info from the conversations. I can then retrieve reminiscences extracted from the dialog utilizing a semantic question:

reminiscences = memory_client.retrieve_memories(
    memory_id=reminiscence.get("id"),
    namespace="/info/user-123",
    question="smartphone mannequin"
)

On this manner, I can shortly enhance the consumer expertise in order that the agent remembers buyer preferences and info which are outdoors of the scope of the CRM and use this info to enhance the replies.

Step 3 – Including id and entry controls

With out correct id controls, entry from the agent to inside instruments all the time makes use of the identical entry stage. To observe safety necessities, I combine AgentCore Identification in order that the agent can use entry controls scoped to the consumer’s or agent’s id context.

I arrange an id consumer and create a workload id, a singular identifier that represents the agent throughout the AgentCore Identification system:

from bedrock_agentcore.companies.id import IdentityClient

identity_client = IdentityClient("us-east-1")
workload_identity = identity_client.create_workload_identity(title="my-agent")

Then, I configure the credential suppliers, for instance:

google_provider = identity_client.create_oauth2_credential_provider(
    {
        "title": "google-workspace",
        "credentialProviderVendor": "GoogleOauth2",
        "oauth2ProviderConfigInput": {
            "googleOauth2ProviderConfig": {
                "clientId": "your-google-client-id",
                "clientSecret": "your-google-client-secret",
            }
        },
    }
)

perplexity_provider = identity_client.create_api_key_credential_provider(
    {
        "title": "perplexity-ai",
        "apiKey": "perplexity-api-key"
    }
)

I can then add the @requires_access_token Python decorator (passing the supplier title, the scope, and so forth) to the capabilities that want an entry token to carry out their actions.

Utilizing this method, the agent can confirm the id by means of the corporate’s current id infrastructure, function as a definite, authenticated id, act with scoped permissions and combine throughout a number of id suppliers (corresponding to Amazon Cognito, Okta, or Microsoft Entra ID) and repair boundaries together with AWS and third-party instruments and companies (corresponding to Slack, GitHub, and Salesforce).

To supply strong and safe entry controls whereas streamlining end-user and agent builder experiences, AgentCore Identification implements a safe token vault that shops customers’ tokens and permits brokers to retrieve them securely.

For OAuth 2.0 suitable instruments and companies, when a consumer first grants consent for an agent to behave on their behalf, AgentCore Identification collects and shops the consumer’s tokens issued by the instrument in its vault, together with securely storing the agent’s OAuth consumer credentials. Brokers, working with their very own distinct id and when invoked by the consumer, can then entry these tokens as wanted, decreasing the necessity for frequent consumer consent.

When the consumer token expires, AgentCore Identification triggers a brand new authorization immediate to the consumer for the agent to acquire up to date consumer tokens. For instruments that use API keys, AgentCore Identification additionally shops these keys securely and offers brokers managed entry to retrieve them when wanted. This safe storage streamlines the consumer expertise whereas sustaining strong entry controls, enabling brokers to function successfully throughout numerous instruments and companies.

Step 4 – Increasing agent capabilities with AgentCore Gateway

Till now, all inside instruments are simulated within the code. Many agent frameworks, together with Strands Brokers, natively help MCP to hook up with distant instruments. To have entry to inside techniques (corresponding to CRM and order administration) by way of an MCP interface, I exploit AgentCore Gateway.

With AgentCore Gateway, the agent can entry AWS companies utilizing Smithy fashions, Lambda capabilities, and inside APIs and third-party suppliers utilizing OpenAPI specs. It employs a twin authentication mannequin to have safe entry management for each incoming requests and outbound connections to focus on assets. Lambda capabilities can be utilized to combine exterior techniques, notably purposes that lack commonplace APIs or require a number of steps to retrieve info.

AgentCore Gateway facilitates cross-cutting options that almost all prospects would in any other case have to construct themselves, together with authentication, authorization, throttling, customized request/response transformation (to match underlying API codecs), multitenancy, and power choice.

The instrument choice function helps discover probably the most related instruments for a particular agent’s activity. AgentCore Gateway brings a uniform MCP interface throughout all these instruments, utilizing AgentCore Identification to offer an OAuth interface for instruments that don’t help OAuth out of the field like AWS companies.

Step 5 – Including capabilities with AgentCore Code Interpreter and Browser instruments

To reply to buyer requests, the shopper help agent must carry out calculations. To simplify that, I exploit the AgentCode SDK so as to add entry to the AgentCore Code Interpreter.

Equally, a number of the integrations required by the agent don’t implement a programmatic API however should be accessed by means of an online interface. I give entry to the AgentCore Browser to let the agent navigate these websites autonomously.

Step 6 – Gaining visibility with observability

Now that the agent is in manufacturing, I want visibility into its actions and efficiency. AgentCore offers enhanced observability to assist builders successfully debug, audit, and monitor their agent efficiency in manufacturing. It comes with built-in dashboards to trace important operational metrics corresponding to session rely, latency, length, token utilization, error charges, and component-level latency and error breakdowns. AgentCore additionally provides visibility into an agent’s habits by capturing and visualizing each the end-to-end traces, in addition to “spans” that seize every step of the agent workflow together with instrument invocations, reminiscence

The built-in dashboards supplied by this service assist reveal efficiency bottlenecks and determine why sure interactions would possibly fail, enabling steady enchancment and decreasing the imply time to detect (MTTD) and imply time to restore (MTTR) in case of points.

AgentCore helps OpenTelemetry to assist combine agent telemetry knowledge with current observability platforms, together with Amazon CloudWatch, Datadog, LangSmith, and Langfuse.

Step 7 – Conclusion

By means of this journey, we reworked a neighborhood prototype right into a production-ready system. Utilizing AgentCore modular method, we applied enterprise necessities incrementally—from fundamental deployment to stylish reminiscence, id administration, and power integration—all whereas sustaining the prevailing agent code.

Issues to know
Amazon Bedrock AgentCore is offered in preview in US East (N. Virginia), US West (Oregon), Asia Pacific (Sydney), and Europe (Frankfurt). You can begin utilizing AgentCore companies by means of the AWS Administration Console , the AWS Command Line Interface (AWS CLI), the AWS SDKs, or by way of the AgentCore SDK.

You’ll be able to attempt AgentCore companies at no cost till September 16, 2025. Customary AWS pricing applies to any extra AWS Companies used as a part of utilizing AgentCore (for instance, CloudWatch pricing will apply for AgentCore Observability). Beginning September 17, 2025, AWS will invoice you for AgentCore service utilization primarily based on this web page.

Whether or not you’re constructing buyer help brokers, workflow automation, or progressive AI-powered experiences, AgentCore offers the muse it is advisable to transfer from prototype to manufacturing with confidence.

To be taught extra and begin deploying production-ready brokers, go to the AgentCore documentation. For code examples and integration guides, take a look at the AgentCore samples GitHub repo.

Be part of the AgentCore Preview Discord server to offer suggestions and talk about use circumstances. We’d like to listen to from you!

— Danilo