Introducing AWS Bedrock AgentCore: A Modular Platform for Deploying AI Agents at Enterprise Scale -Part I

What is AWS Bedrock AgentCore?

Amazon Bedrock AgentCore (AgentCore) is a suite of managed, modular services from AWS that enables organizations to build, deploy, and scale AI agents in production environments. It provides the essential runtime, identity, memory, observability, and integration layers that agentic AI applications need all without the complexity of provisioning or managing infrastructure (Serverless).

AgentCore is runtime framework and model-agnostic, supporting open source agentic frameworks like LangGraph, CrewAI, and Strands Agents, and interoperating with MCP (Model Context Protocol) servers for tool discovery and integration. This flexibility allows developers to build agents that reason, plan, and act across APIs, data sources, and enterprise systems all within a secure, serverless AWS environment.

Why AgentCore Matters

Moving AI agents from prototype to production is challenging teams often face hurdles in scaling, identity management, tool orchestration, memory persistence, and observability. AgentCore directly addresses these challenges by offering a modular, fully managed platform designed for enterprise-grade agentic workloads.

With AgentCore, you can focus on your agent’s logic and user experience, while AWS handles the complex underpinnings: scaling, sandboxing, authentication, and operational visibility.

Key Features & Core Services

1. AgentCore Runtime

A secure, serverless execution environment optimized for dynamic AI agents and tools. It supports long-running processes, session isolation, and multi-modal interactions (text, image, structured data).

1. Fast startup times and extended runtime support


2. Secure multi-tenant session isolation


3. Built-in authentication and authorization


4. Serverless auto-scaling based on demand


5. Multi-modal payload handling

2. AgentCore Identity

Provides robust authentication, authorization, and access management for agents, integrating seamlessly with identity providers like Amazon Cognito, Microsoft Entra ID, and Okta.

1. Secure token vault and least-privilege access


2. Permission delegation for AWS and third-party resources


3. Compatibility with enterprise identity systems


4. Centralized agent identity lifecycle management

3. AgentCore Memory

Enables agents to remember context across interactions and sessions without needing to build or maintain custom databases.

1. Short-term and long-term memory storage


2. Cross-agent memory sharing


3. High-accuracy context retrieval


4. Developer control over what agents retain


5. Fully managed, no infrastructure setup

4. AgentCore Gateway with MCP Server Integration

The Gateway service is where AWS Bedrock AgentCore truly shines. It acts as a bridge between agents and the tools or APIs they need, transforming existing resources — such as APIs, Lambda functions, and third-party services — into agent-compatible tools.

AgentCore Gateway also provides native support for MCP (Model Context Protocol) servers, a new open standard that allows AI agents to discover, describe, and call external tools consistently. With MCP, you can seamlessly register, version, and govern tool interactions across hybrid environments.

1. MCP server support for open tool integration


2. Automatic tool discovery and registration


3. API and Lambda transformation into agent tools


4. Built-in security and access control


5. Simplified service-to-agent connectivity


6. Accelerated tool onboarding and governance

5. AgentCore Browser Tool

A secure, cloud-based browser environment that allows agents to interact with websites safely and efficiently.

Enterprise-grade security and sandboxing

Full browsing and web interaction support

Auto-scaling for concurrent sessions

Deep observability into browser actions

6. AgentCore Code Interpreter Tool

A fully managed sandbox for agents to execute code securely. Ideal for data analysis, automation, or reasoning tasks.

Isolated, secure execution environment

Enterprise-level compliance and resource limits

Native integration with Strands Agents and MCP tools

Configurable runtime and language support

7. AgentCore Observability

Provides unified visibility and telemetry for your agents. Integrated with CloudWatch, OpenTelemetry, and the AgentCore console, it simplifies debugging, tracing, and performance monitoring.

1. Unified operational dashboards


2. Workflow visualization and step tracing


3. Real-time performance metrics


4. Debugging and health monitoring


5. Scalable, production-ready observability

Simplified Deployment and Operations

With AgentCore, developers no longer need to manage Docker containers, ECR, or ECS clusters. The AgentCore Starter Toolkit allows deployment of agents with just a few CLI commands. Each service is modular you can use Runtime + Identity + Gateway, or just the components you need ensuring flexibility for any architecture.

The Bottom Line

AWS Bedrock AgentCore brings agentic AI to production scale, offering the infrastructure abstraction, operational security, and open integration standards modern AI systems require.

With built-in support for MCP servers, serverless execution, and enterprise-grade observability, AgentCore provides everything you need to develop intelligent, autonomous, and secure agents without the complexity of managing infrastructure.

If your organization is ready to scale agentic AI securely and efficiently, AgentCore delivers the foundation to make it happen.

Building & Testing (Locally)

Sreeni AWS-Strands-Agent

Let's explore a complete, working example of an AWS Bedrock AgentCore application built with Strands Agents. This project demonstrates all the key concepts and provides a production-ready foundation.

Project Overview

The sreeni-aws-strands-agent is a comprehensive implementation showcasing:

Context-Aware Conversations: Session-based memory with conversation history

AgentCore Integration: Full integration with all AgentCore services

Production-Ready Code: Clean, maintainable, and scalable architecture

Local Development: Complete local testing and development setup

Deployment Ready: Ready for AWS deployment with minimal configuration

Step 1: Create the Agent Server with Context (main.py-Server)

"""

AWS Strands Agent with Context for Amazon Bedrock AgentCore

"""



from strands import Agent

from bedrock_agentcore import BedrockAgentCoreApp

import uuid



# Create the AgentCore app

app = BedrockAgentCoreApp()



# Create the agent

agent = Agent(model="global.anthropic.claude-sonnet-4-5-20250929-v1:0")



# Store active conversations with context (in production, use DynamoDB)

active_conversations = {}



@app.entrypoint

def invoke(payload):

    """Process user input with conversation context"""

    # Get the user's message and session info

    user_message = payload.get("prompt", "Hello!")

    session_id = payload.get("session_id", str(uuid.uuid4()))



    # Get or create conversation context

    if session_id not in active_conversations:

        active_conversations[session_id] = {

            "messages": [],

            "context": {}

        }



    conversation = active_conversations[session_id]



    # Add user message to conversation history

    conversation["messages"].append({"role": "user", "content": user_message})



    # Create context from conversation history

    context_messages = conversation["messages"][-10:]  # Keep last 10 messages for context



    # Get response from agent with conversation context

    response = agent(user_message, messages=context_messages)



    # Add agent response to conversation history

    agent_response = response.message['content'][0]['text']

    conversation["messages"].append({"role": "assistant", "content": agent_response})



    # Return response with session info

    return {

        "result": agent_response,

        "session_id": session_id,

        "has_context": True,

        "message_count": len(conversation["messages"])

    }



if __name__ == "__main__":

    print("🤖 AWS Strands Agent with Context")

    print("Server starting on http://localhost:8080")

    app.run()

Step 2: Create the Test Client with Context (client.py)

"""

Client to chat with the AWS Strands Agent with Context

"""



import requests

import json

import uuid



def main():

    print("🤖 AWS Strands Agent Client (with Context)")

    print("=" * 50)

    print("Type 'exit' to quit, 'new' for new conversation")

    print("=" * 50)



    # Generate a session ID for this conversation

    session_id = str(uuid.uuid4())

    print(f"Session ID: {session_id}")



    while True:

        try:

            # Get user input

            user_input = input("\nYou: ").strip()



            # Check for exit command

            if user_input.lower() == "exit":

                print("👋 Goodbye!")

                break



            # Check for new conversation

            if user_input.lower() == "new":

                session_id = str(uuid.uuid4())

                print(f"🆕 New conversation started. Session ID: {session_id}")

                continue



            # Skip empty input

            if not user_input:

                print("Please enter a message, 'exit' to quit, or 'new' for new conversation.")

                continue



            # Send request to agent with session context

            print("🤖 Agent: ", end="", flush=True)



            response = requests.post(

                "http://localhost:8080/invocations",

                headers={"Content-Type": "application/json"},

                json={

                    "prompt": user_input,

                    "session_id": session_id

                }

            )



            # Check if request was successful

            if response.status_code == 200:

                result = response.json()

                print(result["result"])

                print(f"📝 Session: {result.get('session_id', 'N/A')} | Context: {'✅' if result.get('has_context') else '❌'}")

            else:

                print(f"❌ Error: {response.status_code} - {response.text}")



        except requests.exceptions.ConnectionError:

            print("❌ Error: Could not connect to agent server.")

            print("Make sure the agent is running with: python main.py")

            break

        except KeyboardInterrupt:

            print("\n\n👋 Goodbye!")

            break

        except Exception as e:

            print(f"❌ Error: {e}")



if __name__ == "__main__":

    main()

Running the Agent locally and Testing it out

Testing with cURL command

Note: Production Considerations:

For production deployment, replace the in-memory storage with:

DynamoDB: For persistent conversation storage

Redis: For fast session management

RDS: For complex conversation analytics

S3: For long-term conversation archiving

Conclusion

AWS Bedrock AgentCore marks a pivotal step in the evolution of agentic AI infrastructure. It bridges the gap between experimentation and enterprise deployment by combining serverless scalability, modular design, and open standards like the Model Context Protocol (MCP).

With AgentCore, developers no longer have to wrestle with container orchestration, tool discovery, or security management those complexities are abstracted away. Instead, they can focus on building agents that think, reason, and act intelligently across real-world business systems.

Its integration with multiple frameworks such as LangGraph, CrewAI, and Strands Agents, along with first-class support for MCP servers, ensures that organizations aren’t locked into a single ecosystem. This open, interoperable foundation future-proofs investments in AI and allows teams to adapt rapidly as new tools and models emerge.

In essence, AWS Bedrock AgentCore is not just an infrastructure platform it’s the backbone of next-generation AI applications, empowering enterprises to deploy autonomous agents securely, efficiently, and at scale.

Next in This Series Part II: Deploying Agents to AWS Bedrock AgentCore

In the next blog, I’ll walk through the end-to-end deployment process from setting up your environment and configuring the runtime, to publishing your first agent using the AgentCore Starter Toolkit. You’ll see how easy it is to move from code to a fully managed, scalable agent in just a few commands.

Thanks

Sreeni Ramadorai