I run Deep Research AI Agent on Amazon Bedrock AgentCore

Beyond basic single-task helpers, AI agents have evolved into a more powerful system that can plan, criticize and work with other agents to solve complex problems. A recently introduced framework built on Langgraph, Deep Agent delivers these capabilities and enables multi-agent workflows that reflect real team dynamics. But the challenge is not only to build such agents, but also to ensure they are safely executed in production. This is where the Amazon Bedrock Agentcore Runtime appears. By providing a secure serverless environment for AI agents and tools, runtimes allow deep agents to be deployed at an enterprise scale without emphasising infrastructure management.

This post shows how to deploy a deep agent to the agent core runtime. As shown in the following diagram, the AgentCore runtime provides session isolation by scaling any agent and assigning a new MicroVM for each new session.

What is Amazon Bedrock Agentcore?

Amazon Bedrock AgentCore is framework-independent model-independent and offers the flexibility to deploy and operate sophisticated AI agents at scale and at safety. Whether you build on Strands Agent, Crewai, Langgraph, Llamaindex, or another framework and run them on a large language model (LLM), AgentCore provides the infrastructure to support them. Its modular services are dedicated to dynamic agent workloads and have tools to extend the agent functionality and controls needed for production use. Agent Core allows you to bring priority frameworks, models and deployments without rewriting your code by easing the management of the construction and management of specialized agent infrastructures.

Amazon Bedrock Agentcore offers a comprehensive suite of features designed to convert local agent prototypes into production-enabled systems. These include persistent memory to maintain within conversations and context, 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 the agent's inference process. This post focuses specifically on the Agent Core Runtime Component.

AgentCore Runtime Core Features

AgentCore Runtime provides a serverless, secure hosting environment designed specifically for agent workloads. It is equally suitable for running agents, tools, MCP servers, or running agents, tools, MCP servers, or other workloads that benefit from seamless scaling and integrated identity management. The Agent Core Runtime provides extended execution time up to 8 hours to provide large payloads for multimodal content based on complex inference, for complex inference, for complex inference, for large payloads for complex inference. LLM or tool waiting for a response. Each user session is completely isolated within a dedicated micro virtual machine (MicroVM) to help maintain security and prevent cross-session contamination between agent interactions. The runtime works with many frameworks (such as Langgraph, Crewai, Strand) and many foundation model providers, providing built-in corporate authentication, professional agent observability, and unified access to a wider agent core environment through a single SDK.

Real World Example: Deep Agent Integration

In this post, we will expand on an example of the recently released DeepEgents implementation of AgentCore Runtime. It shows that there is little effort required to get the latest Agent Innovations up and running.

The implementation of the sample in the previous diagram includes:

a Research Agent This uses the Tavily API to perform deep internet searches
a Criticism Agent It reviews and provides feedback on the generated reports
a Main Orchestrator Manage workflows and handle file operations

Deep Agent uses Langgraph State Management to create a multi-agent system that looks like this:

Built-in task planning In exchange write_todos Tools that help agents break down complex requests
Virtual File System Maintain context throughout interactions where agents can read/write files
Subagent architecture You can call special agents for specific tasks while maintaining context separation
Recursive reasoning High recursive limits (over 1,000) for handling complex, multi-step workflows

This architecture allows deep agents to handle research tasks that require multiple information collection, synthesis, and improvements. A key integration point in your code shows how agents work with AgentCore. Beauty is its simplicity. To create agent agent core compatibility, you just need to add two lines of code.

# 1. Import the AgentCore runtime
from bedrock_agentcore.runtime import BedrockAgentCoreApp
app = BedrockAgentCoreApp()

# 2. Decorate your agent function with @app.entrypoint
@app.entrypoint
async 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 bottom
if __name__ == "__main__":
    app.run()

that's it! The rest of the code (model initialization, API integration, and agent logic) was exactly what it was. The agent handles the infrastructure, and the agent handles the intelligence. This integration pattern works with most Python agent frameworks, so AgentCore is truly framework dependent.

Deployment to AgentCore Runtime: Step-by-Step

Use the Agent Core Starter Toolkit to proceed with the actual deployment process. This dramatically simplifies the deployment workflow.

Prerequisites

Before you begin, make sure you have:

Python 3.10 or later
Configured AWS Credentials
Amazon Bedrock AgentCore SDK installed

Step 1: IAM Permission

There are two different AWS Identity and Access Management (IAM) permissions that you need to consider when deploying agents to the Agent Core Runtime. This is the role that developers use to create agent core resources and the execution role that agents must run at the agent core runtime. The latter role is now automatically created by the Agent Core Starter Toolkit.auto_create_execution_role=True), the former must be defined as described in the IAM authorization of the AgentCore runtime.

Step 2: Add a wrapper to the agent

Add the AgentCore import and decorator to your existing agent code, as shown in the previous Deep Agent example.

Step 3: Deploy using the Agent Core Starter Toolkit

The Starter Toolkit offers a three-stage deployment process.

from bedrock_agentcore_starter_toolkit import Runtime

# Step 1: Configure
agentcore_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: Launch
launch_result = agentcore_runtime.launch()
print(f"Agent deployed! ARN: {launch_result['agent_arn']}")

# Step 3: Invoke
response = 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 will automatically look like this:

Generate optimized Docker files Python 3.13 Slim-Based Images and Opentelemetry Instrumentation
Build a container There are dependencies requirements.txt
Create Amazon Elastic Container Registry (Amazon ECR) Repository (if auto_create_ecr=True) And press your image
Deploy to AgentCore runtime Monitor deployment status
Configure networking and observability Using Amazon CloudWatch and AWS X-ray integration

The entire process usually takes 2-3 minutes, after which the agent is ready to process large requests. Each new session begins with its own fresh agent core runtime Mycroph, maintaining complete environmental isolation.

The starter kit generates a configuration file (.bedrock_agentcore.yaml) Capture your deployment settings and make it easier to redeploy or update agents later.

Calls the deployed agent

After deployment, there are two options to invoke the agent:

Option 1: Using the Start Kit (as shown in step 3)

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

Option 2: Use BOTO3 SDK directly

import boto3
import json

agentcore_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 response
for event in response['completion']:
    if 'chunk' in event:
        print(event['chunk']['bytes'].decode('utf-8'))

Deep Agent in Action

When code is run on the Bedrock AgentCore runtime, the primary agent coordinates specialized subagents with their own purposes, prompts, and tool access to solve complex tasks more effectively. In this case, the orchestrator prompt isresearch_instructions) Set up a plan:

Write your question in question.txt
Using the Internet_search tool, you can use one or more research agent calls (each on a single subtopic) to fan
Synthesize the survey results of final_report.md
Call critiques to assess gaps and structures
Optionally, return to more research/editing until quality is met

It's working here:

cleaning

Once finished, don't forget to fire any provisioned agent core runtimes in addition to the container repository created during the process.

agentcore_control_client = boto3.client(
    'bedrock-agentcore-control', region_name=region )
ecr_client = boto3.client('ecr',region_name=region )
runtime_delete_response = agentcore_control_client.delete_agent_runtime(    agentRuntimeId=launch_result.agent_id,)
response = ecr_client.delete_repository(
    repositoryName=launch_result.ecr_uri.split('/')[1],force=True)

Conclusion

Amazon Bedrock Agentcore represents a paradigm shift in how AI agents are deployed. Agent Core extracts infrastructure complexity while maintaining framework and model flexibility, allowing developers to focus on building sophisticated agent logic rather than managing their deployment pipelines. Deep Agent Deployment demonstrates the ability to deploy complex, multi-agent systems with external API integration with minimal code changes. The combination of enterprise-grade security, built-in observability and serverless scaling makes AgentCore the perfect choice for deploying production AI agents. Especially for deep research agents, AgentCore offers the following unique features:

The AgentCore runtime can handle asynchronous processing and long-term (up to 8 hours) agents. Asynchronous tasks allow agents to continue processing after responding to the client, and process long-term operations without blocking the response. Your background research subagent may be studying asynchronously for hours.
AgentCore Runtime works using agent core memory, allowing features such as building previous findings, recalling research preferences, and maintaining complex research contexts without losing progress between sessions.
AgentCore Gateway allows you to extend deep research to include unique insights from enterprise services and data sources. By exposing these differentiated resources as MCP tools, agents can quickly gain advantages and combine them with publicly available knowledge.

Are you ready to deploy your agents into production? Here's how to get started:

Install the Agent Core Starter Kit: pip install bedrock-agentcore-starter-toolkit
experiment: Follow this step-by-step guide to unpack the code.

Here is the era of production-ready AI agents. With AgentCore, the journey from prototype to production has been shorter than ever.

About the author

Vadim Omeltchenko Sr. AI/ML Solutions Architect is passionate about helping AWS customers innovate in the cloud. His previous IT experience was primarily on the ground.

Eashan Kaushik I am AI/ML, a specialized solution architect for Amazon Web Services. He is driven to create cutting-edge generator AI solutions while prioritizing a customer-centric approach to his work. Prior to this role, he obtained MS in Computer Science at the NYU Tandon School of Engineering. Outside of work, he enjoys sports, lifting and marathons.

Shreyas Subramanian A leading data scientist, helping customers by using Machine Learning to solve business challenges using the AWS platform. Shrayas has a background in optimization and machine learning at scale, and uses machine learning and reinforcement learning to accelerate optimization tasks.

Markroy He is AWS' leading machine learning architect and helps customers design and build generative AI solutions. His focus since early 2023 is leading the solution architecture effort for launching Amazon Bedrock, a flagship-generated AI offer from AWS for builders. Mark's work covers a wide range of use cases and has attracted major interest in ML scaling across generation AI, agents, and enterprises. He has supported companies in insurance, financial services, media and entertainment, healthcare, utilities and manufacturing. Prior to joining AWS, he was an architect, developer and technology leader for over 25 years, including financial services for over 19 years. Mark holds six AWS certifications, including ML Specialist Certification.