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

In just some years, basis fashions (FMs) have advanced 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 cause, plan, act, study, 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 akin 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 grow to be more and more accessible due to open supply frameworks like CrewAI, LangGraph, LlamaIndex, and Strands Brokers. Nevertheless, transferring from a promising proof-of-concept to a production-ready agent that may scale to 1000’s of customers presents important challenges.

As a substitute of having the ability to deal with the core options of the agent, builders and AI engineers should spend months constructing foundational infrastructure for session administration, identification controls, reminiscence techniques, and observability—on the similar time supporting safety and compliance.

Right this moment, we’re excited to announce the preview of Amazon Bedrock AgentCore, a complete set of enterprise-grade companies that assist builders rapidly 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 as we speak:

AgentCore Runtime – Gives low-latency serverless environments with session isolation, supporting any agent framework together with common 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 study from previous interactions.

AgentCore Observability – Affords 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 akin 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 – Gives managed internet browser situations to scale your brokers’ internet automation workflows.

AgentCore Code Interpreter – Affords 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 flexibleness 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 just some strains of code, your brokers can securely connect with API-based brokers and instruments from AWS Market with AgentCore Gateway that can assist you run complicated workflows whereas sustaining compliance and management.

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

Let’s see how this works in apply. 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 clients attain out with an electronic mail, it takes time to supply 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 information bases to search out the data required to organize a solution.

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

Once I discuss to builders, they inform me that related prototypes, overlaying totally different use circumstances, are being inbuilt many firms. When these prototypes are demonstrated to the corporate management and obtain affirmation to proceed, the event crew has to outline the right way to go in manufacturing and fulfill the same old 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 information leakage—a important requirement for purposes dealing with delicate information.

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 permit to entry assets hosted in a buyer’s VPC or related 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 distinct 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 as we speak?
"""

SYSTEM_PROMPT = """
You might be an useful buyer help assistant.
When supplied with a buyer electronic mail, collect all mandatory information and put together the response electronic mail.
When requested about an order, search for it and inform the total description and date of the order to the client.
Do not point out the client 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 duvet, insert the underside first, then push from the again as much as the highest.")
            kb_info.append("To take away the duvet, push the highest and backside of the duvet on the similar 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 entrypoint operate invoking the agent
@app.entrypoint
def invoke(payload, context: RequestContext):
    """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()

I set up the AgentCore SDK and the starter toolkit within the Python digital setting:

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 take advantage of agentcore configure --entrypoint my_agent.py -er to configure the agent, passing the AWS Identification and Entry Administration (IAM) position that the agent will assume. On this case, the agent wants entry to Amazon Bedrock to invoke the mannequin. The position may give entry to different AWS assets utilized by an agent, akin to an Amazon Easy Storage Service (Amazon S3) bucket or a Amazon DynamoDB desk.

I launch the agent regionally with agentcore launch --local. When operating regionally, I can work together with the agent utilizing agentcore invoke --local . The payload is handed to the entry level operate. Word 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 distinct syntax relying in your use case.

When I’m happy by native testing, I take advantage of 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 . For instance, I move 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 be capable to use the charger? Additionally, I wrestle to take away the duvet. Thanks, Danilo"}'

Step 2 – Enabling reminiscence for context

After an agent has been deployed within the AgentCore Runtime, the context must be endured 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(
    identify="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 latest 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 keep 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 details) or create customized insurance policies for specialised wants. Information is saved encrypted utilizing a namespace-based storage for information segmentation.

I modify the earlier code creating the reminiscence retailer to incorporate long-term capabilities by passing a semantic reminiscence technique. Word that an current reminiscence retailer could 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(
    identify="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 mechanically 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="/details/user-123",
    question="smartphone mannequin"
)

On this approach, I can rapidly enhance the consumer expertise in order that the agent remembers buyer preferences and details which are exterior of the scope of the CRM and use this info to enhance the replies.

Step 3 – Including identification and entry controls

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

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

from bedrock_agentcore.companies.identification import IdentityClient

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

Then, I configure the credential suppliers, for instance:

google_provider = identity_client.create_oauth2_credential_provider(
    {
        "identify": "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(
    {
        "identify": "perplexity-ai",
        "apiKey": "perplexity-api-key"
    }
)

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

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

To supply sturdy 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 appropriate 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 identification and when invoked by the consumer, can then entry these tokens as wanted, lowering 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 sturdy entry controls, enabling brokers to function successfully throughout varied 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 connect with distant instruments. To have entry to inside techniques (akin to CRM and order administration) by way of an MCP interface, I take advantage of 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, significantly purposes that lack normal APIs or require a number of steps to retrieve info.

AgentCore Gateway facilitates cross-cutting options that the majority clients 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 characteristic 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 supply 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 client help agent must carry out calculations. To simplify that, I take advantage of the AgentCode SDK so as to add entry to the AgentCore Code Interpreter.

Equally, among the integrations required by the agent don’t implement a programmatic API however must be accessed by means of an internet interface. I give entry to the AgentCore Browser to let the agent navigate these web pages autonomously.

Step 6 – Gaining visibility with observability

Now that the agent is in manufacturing, I would like visibility into its actions and efficiency. AgentCore gives 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 akin to session depend, latency, period, token utilization, error charges, and component-level latency and error breakdowns. AgentCore additionally offers visibility into an agent’s conduct 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 establish why sure interactions would possibly fail, enabling steady enchancment and lowering the imply time to detect (MTTD) and imply time to restore (MTTR) in case of points.

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

Step 7 – Conclusion

By this journey, we reworked an area prototype right into a production-ready system. Utilizing AgentCore modular strategy, we applied enterprise necessities incrementally—from fundamental deployment to classy reminiscence, identification administration, and power integration—all whereas sustaining the present agent code.

Issues to know
Amazon Bedrock AgentCore is accessible 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. Commonplace AWS pricing applies to any further AWS Providers 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 based mostly on this web page.

Whether or not you’re constructing buyer help brokers, workflow automation, or modern AI-powered experiences, AgentCore gives the inspiration it’s essential to transfer from prototype to manufacturing with confidence.

To study extra and begin deploying production-ready brokers, go to the AgentCore documentation. For code examples and integration guides, try the AgentCore samples GitHub repo.

Be part of the AgentCore Preview Discord server to supply suggestions and focus on use circumstances. We’d like to listen to from you!

— Danilo