🚀 **AgentCore Runtime简化AI代理部署**：Amazon Bedrock AgentCore提供了一个服务器less、安全的环境，专门为AI代理工作负载而设计。它允许开发者在不管理底层基础设施的情况下，轻松部署由LangGraph、CrewAI等框架构建的多代理系统，大大降低了生产部署的复杂性。

🛠️ **框架与模型无关的灵活性**：AgentCore支持多种AI代理框架和基础模型，开发者可以自由选择最适合其需求的工具，而无需重写代码。这使得将现有代理原型快速迁移到生产环境成为可能，并能集成企业现有的API和认证系统。

💡 **Deep Agents实例展示强大能力**：文章通过部署Deep Agents这一复杂的多代理系统来具体说明AgentCore的强大之处。Deep Agents能够执行深度互联网搜索、批判性评估和任务编排，展示了AgentCore在处理需要多轮信息收集、综合和精炼的复杂研究任务方面的优势。

🔒 **增强的安全性和隔离性**：AgentCore Runtime通过为每个新会话分配独立的微虚拟机（microVM）来确保会话隔离和数据安全，防止跨会话的数据污染。同时，它还提供企业级安全功能，如与公司认证系统的集成，为生产环境提供可靠保障。

💰 **高效的成本和资源管理**：AgentCore Runtime采用基于消费的定价模式，仅在代理处理任务时收费，而不是在等待LLM或工具响应时收取费用。此外，它支持长达8小时的扩展执行时间，并能处理大型多模态内容，满足复杂和长时间运行的代理任务需求。

AI agents are evolving beyond basic single-task helpers into more powerful systems that can plan, critique, and collaborate with other agents to solve complex problems. Deep Agents—a recently introduced framework built on LangGraph—bring these capabilities to life, enabling multi-agent workflows that mirror real-world team dynamics. The challenge, however, is not just building such agents but also running them reliably and securely in production. This is where Amazon Bedrock AgentCore Runtime comes in. By providing a secure, serverless environment purpose-built for AI agents and tools, Runtime makes it possible to deploy Deep Agents at enterprise scale without the heavy lifting of managing infrastructure.

In this post, we demonstrate how to deploy Deep Agents on AgentCore Runtime. As shown in the following figure, AgentCore Runtime scales any agent and provides session isolation by allocating a new microVM for each new session.

What is Amazon Bedrock AgentCore?

Amazon Bedrock AgentCore is both framework-agnostic and model-agnostic, giving you the flexibility to deploy and operate advanced AI agents securely and at scale. Whether you’re building with Strands Agents, CrewAI, LangGraph, LlamaIndex, or another framework—and running them on a large language model (LLM)—AgentCore provides the infrastructure to support them. Its modular services are purpose-built for dynamic agent workloads, with tools to extend agent capabilities and controls required for production use. By alleviating the undifferentiated heavy lifting of building and managing specialized agent infrastructure, AgentCore lets you bring your preferred framework and model and deploy without rewriting code.

Amazon Bedrock AgentCore offers a comprehensive suite of capabilities designed to transform local agent prototypes into production-ready systems. These include persistent memory for maintaining context in and across conversations, access to existing APIs using Model Context Protocol (MCP), seamless integration with corporate authentication systems, specialized tools for web browsing and code execution, and deep observability into agent reasoning processes. In this post, we focus specifically on the AgentCore Runtime component.

Core capabilities of AgentCore Runtime

AgentCore Runtime provides a serverless, secure hosting environment specifically designed for agentic workloads. It packages code into a lightweight container with a simple, consistent interface, making it equally well-suited for running agents, tools, MCP servers, or other workloads that benefit from seamless scaling and integrated identity management.AgentCore Runtime offers extended execution times up to 8 hours for complex reasoning tasks, handles large payloads for multimodal content, and implements consumption-based pricing that charges only during active processing—not while waiting for LLM or tool responses. Each user session runs in complete isolation within dedicated micro virtual machines (microVMs), maintaining security and helping to prevent cross-session contamination between agent interactions. The runtime works with many frameworks (for example: LangGraph, CrewAI, Strands, and so on) and many foundation model providers, while providing built-in corporate authentication, specialized agent observability, and unified access to the broader AgentCore environment through a single SDK.

Real-world example: Deep Agents integration

In this post we’re going to deploy the recently released Deep Agents implementation example on AgentCore Runtime—showing just how little effort it takes to get the latest agent innovations up and running.

The sample implementation in the preceding diagram includes:

A research agent that conducts deep internet searches using the Tavily API A critique agent that reviews and provides feedback on generated reports A main orchestrator that manages the workflow and handles file operations

Deep Agents uses LangGraph’s state management to create a multi-agent system with:

Built-in task planning through a write_todos tool that helps agents break down complex requests Virtual file system where agents can read/write files to maintain context across interactions Sub-agent architecture allowing specialized agents to be invoked for specific tasks while maintaining context isolation Recursive reasoning with high recursion limits (more than 1,000) to handle complex, multi-step workflows

This architecture enables Deep Agents to handle research tasks that require multiple rounds of information gathering, synthesis, and refinement.The key integration points in our code showcase how agents work with AgentCore. The beauty is in its simplicity—we only need to add a couple of lines of code to make an agent AgentCore-compatible:

# 1. Import the AgentCore runtimefrom bedrock_agentcore.runtime import BedrockAgentCoreAppapp = BedrockAgentCoreApp()# 2. Decorate your agent function with @app.entrypoint@app.entrypointasync def langgraph_bedrock(payload):    # Your existing agent logic remains unchanged    user_input = payload.get("prompt")        # Call your agent as before    stream = agent.astream(        {"messages": [HumanMessage(content=user_input)]},        stream_mode="values"    )        # Stream responses back    async for chunk in stream:        yield(chunk)# 3. Add the runtime starter at the bottomif __name__ == "__main__":    app.run()

That’s it! The rest of the code—model initialization, API integrations, and agent logic—remains exactly as it was. AgentCore handles the infrastructure while your agent handles the intelligence. This integration pattern works for most Python agent frameworks, making AgentCore truly framework-agnostic.

Deploying to AgentCore Runtime: Step-by-step

Let’s walk through the actual deployment process using the AgentCore Starter ToolKit, which dramatically simplifies the deployment workflow.

Prerequisites

Before you begin, make sure you have:

Python 3.10 or higher AWS credentials configured Amazon Bedrock AgentCore SDK installed

Step 1: IAM permissions

There are two different AWS Identity and Access Management (IAM) permissions you need to consider when deploying an agent in an AgentCore Runtime—the role you, as a developer use to create AgentCore resources and the execution role that an agent needs to run in an AgentCore Runtime. While the latter role can now be auto-created by the AgentCore Starter Toolkit (auto_create_execution_role=True), the former must be defined as described in IAM Permissions for AgentCore Runtime.

Step 2: Add a wrapper to your agent

As shown in the preceding Deep Agents example, add the AgentCore imports and decorator to your existing agent code.

Step 3: Deploy using the AgentCore starter toolkit

The starter toolkit provides a three-step deployment process:

from bedrock_agentcore_starter_toolkit import Runtime# Step 1: Configureagentcore_runtime = Runtime()config_response = agentcore_runtime.configure(    entrypoint="hello.py", # contains the code we showed earlier in the post    execution_role=role_arn, # or auto-create    auto_create_ecr=True,    requirements_file="requirements.txt",    region="us-west-2",    agent_name="deepagents-research")# Step 2: Launchlaunch_result = agentcore_runtime.launch()print(f"Agent deployed! ARN: {launch_result['agent_arn']}")# Step 3: Invokeresponse = agentcore_runtime.invoke({    "prompt": "Research the latest developments in quantum computing"})

Step 4: What happens behind the scenes

When you run the deployment, the starter kit automatically:

Generates an optimized Docker file with Python 3.13-slim base image and OpenTelemetry instrumentation Builds your container with the dependencies from requirements.txt Creates an Amazon Elastic Container Registry (Amazon ECR) repository (if auto_create_ecr=True) and pushes your image Deploys to AgentCore Runtime and monitors the deployment status Configures networking and observability with Amazon CloudWatch and AWS X-Ray integration

The entire process typically takes 2–3 minutes, after which your agent is ready to handle requests at scale. Each new session is launched in its own fresh AgentCore Runtime microVM, maintaining complete environment isolation.

The starter kit generates a configuration file (.bedrock_agentcore.yaml) that captures your deployment settings, making it straightforward to redeploy or update your agent later.

Invoking your deployed agent

After deployment, you have two options for invoking your agent:

Option 1: Using the start kit (shown in Step 3)

response = agentcore_runtime.invoke({    "prompt": "Research the latest developments in quantum computing"})

Option 2: Using boto3 SDK directly

import boto3import jsonagentcore_client = boto3.client('bedrock-agentcore', region_name='us-west-2')response = agentcore_client.invoke_agent_runtime(    agentRuntimeArn=agent_arn,    qualifier="DEFAULT",    payload=json.dumps({        "prompt": "Analyze the impact of AI on healthcare in 2024"    }))# Handle streaming responsefor event in response['completion']:    if 'chunk' in event:        print(event['chunk']['bytes'].decode('utf-8'))

Deep Agents in action

As the code executes in Bedrock AgentCore Runtime, the primary agent orchestrates specialized sub-agents—each with its own purpose, prompt, and tool access—to solve complex tasks more effectively. In this case, the orchestrator prompt (research_instructions) sets the plan:

Write the question to question.txt Fan out to one or more research-agent calls (each on a single sub-topic) using the internet_search tool Synthesize findings into final_report.md Call critique-agent to evaluate gaps and structure Optionally loop back to more research/edits until quality is met

Here it is in action: