This content originally appeared on DEV Community and was authored by Seenivasa Ramadurai
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).
- Fast startup times and extended runtime support
- Secure multi-tenant session isolation
- Built-in authentication and authorization
- Serverless auto-scaling based on demand
- 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.
- Secure token vault and least-privilege access
- Permission delegation for AWS and third-party resources
- Compatibility with enterprise identity systems
- 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.
- Short-term and long-term memory storage
- Cross-agent memory sharing
- High-accuracy context retrieval
- Developer control over what agents retain
- 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.
- MCP server support for open tool integration
- Automatic tool discovery and registration
- API and Lambda transformation into agent tools
- Built-in security and access control
- Simplified service-to-agent connectivity
- 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.
- Unified operational dashboards
- Workflow visualization and step tracing
- Real-time performance metrics
- Debugging and health monitoring
- 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
This content originally appeared on DEV Community and was authored by Seenivasa Ramadurai
Seenivasa Ramadurai | Sciencx (2025-10-18T20:15:44+00:00) Introducing AWS Bedrock AgentCore: A Modular Platform for Deploying AI Agents at Enterprise Scale -Part I. Retrieved from https://www.scien.cx/2025/10/18/introducing-aws-bedrock-agentcore-a-modular-platform-for-deploying-ai-agents-at-enterprise-scale-part-i/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.