🚀 AgentCore Runtime推出新的直接代码部署方式，简化Python代理部署流程，开发者无需创建Dockerfile和管理ECR镜像。

⏱️ 直接代码部署通过zip文件上传代码和依赖，显著缩短了代理更新的部署时间，从容器部署的平均30秒降至约10秒，提升开发效率。

📦 容器部署适用于超过250MB的软件包、已有的容器CI/CD流程以及需要高度定制化依赖和打包的场景；而直接代码部署则更适合小于250MB、使用常见Python框架且追求快速原型设计的项目。

🛠️ AgentCore starter toolkit简化了直接代码部署，能够自动检测依赖、打包并上传至S3，用户只需少量配置即可完成部署。

💡 混合部署策略也是一种选择，可以使用直接代码部署进行快速原型开发和实验，然后在需要更大包体积、多语言支持或复杂构建流程时切换到容器部署。

Amazon Bedrock AgentCore is an agentic platform for building, deploying, and operating effective agents securely at scale. Amazon Bedrock AgentCore Runtime is a fully managed service of Bedrock AgentCore, which provides low latency serverless environments to deploy agents and tools. It provides session isolation, supports multiple agent frameworks including popular open-source frameworks, and handles multimodal workloads and long-running agents.

AgentCore Runtime supports container based deployments where the container definition is provided in a Dockerfile, and the agent is built as a container image. Customers who have container build and deploy pipelines benefit from this method, where agent deployment can be integrated into existing pipelines. 

Today, AgentCore Runtime has launched a second method to deploy agents – direct code deployment (for Python). Agent code and its dependencies can be packaged as a zip archive, alleviating the need for Docker definition and ECR dependencies. This makes it straightforward for developers to prototype and iterate faster. This method is a good fit for customers who prefer not to worry about Docker expertise and container infrastructure when deploying agents.

In this post, we’ll demonstrate how to use direct code deployment (for Python).

Introducing AgentCore Runtime direct code deployment

With the container deployment method, developers create a Dockerfile, build ARM-compatible containers, manage ECR repositories, and upload containers for code changes. This works well where container DevOps pipelines have already been established to automate deployments. 

However, customers looking for fully managed deployments can benefit from direct code deployment, which can significantly improve developer time and productivity. Direct code deployment provides a secure and scalable path forward for rapid prototyping agent capabilities to deploying production workloads at scale.

We’ll discuss the strengths of each deployment option to help you choose the right approach for your use case. 

With direct code deployment, developers create a zip archive of code and dependencies, upload to Amazon S3, and configure the bucket in the agent configuration. When using the AgentCore starter toolkit, the toolkit handles dependency detection, packaging, and upload which provides a much-simplified developer experience. Direct code deployment is also supported using the API.

Let’s compare the deployment steps at a high level between the two methods:

Container-based deployment

The container-based deployment method involves the following steps:

Direct code deployment

The direct code deployment method involves the following steps:

Package your code and dependencies into a zip archive Upload it to S3 Configure the bucket in agent configuration Deploy to AgentCore Runtime

How to use direct code deployment

Let’s illustrate how direct code deployment works with an agent created with Strands Agents SDK and using the AgentCore starter-toolkit to deploy the agent.

Prerequisites

Before you begin, make sure you have the following:

Any of the versions of Python 3.10 to 3.13 Your preferred package manager installed. For example, we use uv package manager. AWS account for creating and deploying agents Amazon Bedrock model access to Anthropic Claude Sonnet 4.0

Step 1: Initialize your project

Set up a new Python project using the uv package manager, then navigate into the project directory:

uv init <project> --python 3.13cd <project>

Step 2: Add the dependencies for the project

Install the required Bedrock AgentCore libraries and development tools for your project. In this example, dependencies are added using .toml file, alternatively they can be specified in requirements.txt file:

uv add bedrock-agentcore strands-agents strands-agents-toolsuv add --dev bedrock-agentcore-starter-toolkitsource .venv/bin/activate

Step 3: Create an agent.py file

Create the main agent implementation file that defines your AI agent’s behavior:

from bedrock_agentcore import BedrockAgentCoreApp from strands import Agent, tool from strands_tools import calculator  from strands.models import BedrockModel import logging app = BedrockAgentCoreApp(debug=True) # Logging setup logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # Create a custom tool  @tool def weather():      """ Get weather """       return "sunny" model_id = "us.anthropic.claude-sonnet-4-20250514-v1:0" model = BedrockModel(      model_id=model_id, ) agent = Agent(      model=model,      tools=[calculator, weather],      system_prompt="You're a helpful assistant. You can do simple math calculation, and tell the weather." ) @app.entrypoint def invoke(payload):      """Your AI agent function"""      user_input = payload.get("prompt", "Hello! How can I help you today?")      logger.info("\n User input: %s", user_input)      response = agent(user_input)      logger.info("\n Agent result: %s ", response.message)      return response.message['content'][0]['text'] if __name__ == "__main__":      app.run() 

Step 4: Deploy to AgentCore Runtime

Configure and deploy your agent to the AgentCore Runtime environment:

agentcore configure --entrypoint agent.py --name <agent-name>

This will launch an interactive session where you configure the S3 bucket to upload the zip deployment package to and choose a deployment configuration type (as shown in the following configuration). To opt for direct code deployment, choose option 1 – Code Zip.

Deployment Configuration

Select deployment type:

Code Zip (recommended) – Simple, serverless, no Docker required Container – For custom runtimes or complex dependencies

agentcore launch

This command creates a zip deployment package, uploads it to the specified S3 bucket, and launches the agent in the AgentCore Runtime environment, making it ready to receive and process requests.

To test the solution, let’s prompt the agent to see how the weather is:

agentcore invoke '{"prompt":"How is the weather today?"}'

The first deployment takes approximately 30 seconds to complete, but subsequent updates to the agent benefit from the streamlined direct code deployment process and should take less than half the time, supporting faster iteration cycles during development.

When to choose direct code instead of container-based deployment

Let’s look at some of the dimensions and see how the direct code and container-based deployment options are different. This will help you choose the option that’s right for you:

Deployment process: Direct code deploys agents as zip files with no Docker, ECR, or CodeBuild required. Container-based deployment uses Docker and ECR with full Dockerfile control. Deployment time: Although there is not much difference during first deployment of an agent, subsequent updates to the agent are significantly faster with direct code deployment (from an average of 30 seconds for containers to about 10 seconds for direct code deployment). Artifact storage: Direct code stores ZIP packages in an S3 bucket. Container-based deployment stores Docker images in Amazon ECR. Direct code deployment incurs storage costs at standard S3 storage rates (starting February 27th  2026) as artifacts are stored in the service account. Container-based deployment incurs Amazon ECR charges in your account. Customization: Direct code deployment supports custom dependencies through ZIP-based packaging, while container based depends on a Dockerfile. Package size: Direct code deployment limits the package size to 250MB whereas container-based packages can be up to 2GB in size. Language Support: Direct code currently supports Python 3.10, 3.11, 3.12, and 3.13. Container-based deployment supports many languages and runtimes.

Our general guidance is:

Container-based deployment is the right choice when your package exceeds 250MB, you have existing container CI/CD pipelines, or you need highly specialized dependencies and custom packaging requirements. Choose containers if you require multi-language support, custom system dependencies or direct control over artifact storage and versioning in your account.

Direct code deployment is the right choice when your package is under 250MB, you use Python 3.10-3.13 with common frameworks like LangGraph, Strands, or CrewAI, and you need rapid prototyping with fast iteration cycles. Choose direct code if your build process is straightforward without complex dependencies, and you want to remove the Docker/ECR/CodeBuild setup.

A hybrid approach works well for many teams, use direct code for rapid prototyping and experimentation where fast iteration and simple setup accelerate development, then graduate to containers for production when package size, multi-language requirements, or specialized build processes demand it.

Conclusion

Amazon Bedrock AgentCore direct code deployment makes iterative agent development cycles even faster, while still benefiting from enterprise security and scale of deployments. Developers can now rapidly prototype and iterate by deploying their code directly, without having to create a container. To get started with Amazon Bedrock AgentCore direct code deployment, visit the AWS documentation.

About the authors

Chaitra Mathur