Developing AgentCore Apps Locally

Introduction

Now that you understand what Bedrock AgentCore is and how it fits into the AWS ecosystem, it's time to get hands-on with the development process. You've already mastered building intelligent agents with Strands and integrating them with Bedrock models, knowledge bases, and external tools. In this lesson, we'll dive into the practical aspects of developing AgentCore applications locally using the Bedrock AgentCore SDK . We'll transform a standard Strands agent into a cloud-ready AgentCore application using the BedrockAgentCoreApp runtime wrapper from the SDK. This local development approach allows us to test our agents thoroughly, debug any issues, and ensure everything works perfectly before moving to production.

Bedrock AgentCore Python SDK

The Bedrock AgentCore SDK is a Python library provided by AWS that helps you deploy AI agents to Amazon Bedrock AgentCore's managed infrastructure. Think of it as a bridge that transforms your existing agents—whether built with Strands, LangGraph, or any other framework—into cloud-ready applications without requiring you to manage servers or infrastructure. The SDK's main component is the BedrockAgentCoreApp class, which acts as a wrapper around your agent logic. This wrapper handles all the HTTP server setup, request routing, and cloud deployment mechanics automatically, so you can focus on your agent's intelligence rather than infrastructure concerns. You can find the Bedrock AgentCore SDK in the official AWS GitHub repository, along with comprehensive documentation and examples to help you get started with your agent deployments.

Understanding AgentCore Runtime

The AgentCore Runtime is AWS's managed serverless environment specifically designed for running AI agents in production. It provides automatic scaling, session isolation, and seamless integration with AWS services, eliminating the need to manage servers or infrastructure yourself. The key innovation here is the runtime wrapper pattern : instead of running your Strands agent directly, you wrap it with BedrockAgentCoreApp from the SDK. This wrapper acts as a translation layer that: Converts your function-based agent into an HTTP web service Handles incoming requests from the cloud environment Routes those requests through your agent logic Formats responses in the structure expected by AgentCore Manages all the server infrastructure automatically This approach preserves your familiar Strands agent development experience while adding enterprise-grade capabilities like automatic scaling, secure session management, and cloud-native deployment. Your agent logic remains unchanged—you simply gain the ability to serve it at scale in AWS's managed environment. Let's see how this works in practice by setting up our Strands agent and wrapping it with the AgentCore runtime.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Setting Up Your Strands Agent

Let's start by setting up the Strands agent we'll be wrapping for AgentCore deployment. This should be familiar from our previous work with Strands agents:

Python

import os
from strands.models import BedrockModel
from strands import Agent
from strands_tools import calculator, retrieve

# Define the Bedrock model ID
MODEL_ID = "us.anthropic.claude-sonnet-4-20250514-v1:0"

# Read guardrail info from environment variables
GUARDRAIL_ID = os.getenv("GUARDRAIL_ID")
GUARDRAIL_VERSION = os.getenv("GUARDRAIL_VERSION", "DRAFT")

# Create a Bedrock model with guardrail configuration
model = BedrockModel(
    model_id=MODEL_ID,
    guardrail_id=GUARDRAIL_ID,
    guardrail_version=GUARDRAIL_VERSION
)

# Define the system prompt
system_prompt = "You are an AWS Technical Assistant. Provide clear, accurate information about AWS services."

# Create an agent with both calculator and retrieve tools
agent = Agent(
    model=model,
    system_prompt=system_prompt,
    tools=[calculator, retrieve]
)

import os
from strands.models import BedrockModel
from strands import Agent
from strands_tools import calculator, retrieve

# Define the Bedrock model ID
MODEL_ID = "us.anthropic.claude-sonnet-4-20250514-v1:0"

# Read guardrail info from environment variables
GUARDRAIL_ID = os.getenv("GUARDRAIL_ID")
GUARDRAIL_VERSION = os.getenv("GUARDRAIL_VERSION", "DRAFT")

# Create a Bedrock model with guardrail configuration
model = BedrockModel(
    model_id=MODEL_ID,
    guardrail_id=GUARDRAIL_ID,
    guardrail_version=GUARDRAIL_VERSION
)

# Define the system prompt
system_prompt = "You are an AWS Technical Assistant. Provide clear, accurate information about AWS services."

# Create an agent with both calculator and retrieve tools
agent = Agent(
    model=model,
    system_prompt=system_prompt,
    tools=[calculator, retrieve]
)

We're configuring our Bedrock model with guardrail integration using environment variables, which allows us to use different guardrail configurations across development and production environments. The agent includes both calculator and retrieve tools, giving it computational and information retrieval capabilities for handling AWS technical questions.

Implementing the Entrypoint Function

The entrypoint function is the heart of your AgentCore application—it's the designated function that processes all incoming requests from users and returns your agent's responses. When someone interacts with your deployed agent, their request flows through this function.

Python

# Mark this function as the entrypoint for the AgentCore runtime
@app.entrypoint
def invoke(payload: dict):
    """
    Receives a payload with a 'prompt' key and asks the Strands agent.
    Returns the agent's response in a dictionary.
    """
    
    # Get the prompt from the payload
    user_prompt = payload.get("prompt")

    # Ask the agent directly
    response = agent(user_prompt)

    # Return the result as a JSON-serializable dict
    return {"result": str(response)}

# Mark this function as the entrypoint for the AgentCore runtime
@app.entrypoint
def invoke(payload: dict):
    """
    Receives a payload with a 'prompt' key and asks the Strands agent.
    Returns the agent's response in a dictionary.
    """
    
    # Get the prompt from the payload
    user_prompt = payload.get("prompt")

    # Ask the agent directly
    response = agent(user_prompt)

    # Return the result as a JSON-serializable dict
    return {"result": str(response)}

The @app.entrypoint decorator is what makes this function special—it tells the AgentCore runtime that this is the main handler for incoming requests. When a user sends a message to your agent, the runtime automatically routes it to this function.

The function follows a simple three-step pattern: extract the user's input from the incoming payload, process it through your Strands agent using the familiar agent(user_prompt) syntax, and return the response in a JSON-serializable dictionary format. Note that the payload structure is entirely up to you—while we're using "prompt" as the key in this example, you could structure your payload with any keys that make sense for your application, such as {"message": "...", "context": "...", "user_id": "..."}. Similarly, your return dictionary can contain any structure you need, not just a "result" key.

This standardized interface keeps your agent logic clean while ensuring seamless integration with the AgentCore runtime environment.

Introduction

Bedrock AgentCore Python SDK

Understanding AgentCore Runtime

Join the 1M+ learners on CodeSignal

Setting Up Your Strands Agent

Creating the AgentCore Runtime Wrapper

Implementing the Entrypoint Function

Local Development Server Setup

Starting Your Agent Server

Testing Your Agent with HTTP Requests

Conclusion and Next Steps