Amazon Bedrock AgentCore

AWS offers AgentCore as part of the Bedrock suite, giving teams a production-ready infrastructure for running AI agents. The service handles containerization, tool orchestration, and model access through a unified runtime that connects to Bedrock's foundation model catalog.

This guide covers instrumenting AgentCore agents with InteractiveAI via OpenTelemetry for full observability into agent execution, model interactions, and tool usage.

Prerequisites

• InteractiveAI account with API credentials

• AWS account with Bedrock access

---

Installation

Install the required packages:

pip install bedrock-agentcore-starter-toolkit strands-agents[otel] interactiveai boto3 mcp

---

Configuration

InteractiveAI and OpenTelemetry Setup

Configure your InteractiveAI credentials and prepare the OpenTelemetry exporter:

import os
import base64
from interactiveai import Interactive

# InteractiveAI credentials
os.environ["INTERACTIVEAI_PUBLIC_KEY"] = "pk-ia-..."
os.environ["INTERACTIVEAI_SECRET_KEY"] = "sk-ia-..."
os.environ["INTERACTIVEAI_HOST"] = "https://app.interactiveai.com"
interactiveai = Interactive(
    secret_key=os.getenv("INTERACTIVEAI_SECRET_KEY"),
    public_key=os.getenv("INTERACTIVEAI_PUBLIC_KEY")
)

# Construct Basic Auth header for OTLP export
auth_string = base64.b64encode(
    f"{os.environ['INTERACTIVEAI_PUBLIC_KEY']}:{os.environ['INTERACTIVEAI_SECRET_KEY']}".encode()
).decode()

# Configure OpenTelemetry exporter
os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = os.environ["INTERACTIVEAI_HOST"] + "/api/public/otel"
os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"Authorization=Basic {auth_string}"

AWS Credentials

Configure access to Amazon Bedrock services:

os.environ["AWS_ACCESS_KEY_ID"] = "..."
os.environ["AWS_SECRET_ACCESS_KEY"] = "..."
os.environ["AWS_DEFAULT_REGION"] = "us-west-2"

---

Creating an Instrumented Agent

Build an AgentCore agent with InteractiveAI tracing enabled through OpenTelemetry. This example uses Strands Agents SDK with MCP tools, though any compatible agent framework can be instrumented similarly.

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent
from strands.models import BedrockModel
from strands.telemetry import StrandsTelemetry
from mcp.client.streamable_http import streamablehttp_client
from strands.tools.mcp.mcp_client import MCPClient
from interactiveai import Interactive

# Initialize MCP client for external tool access
mcp_client = MCPClient(
    lambda: streamablehttp_client("https://your-mcp-endpoint.com/api/mcp")
)

# Configure foundation model
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-7-sonnet-20250219-v1:0",
    region_name="us-west-2",
    temperature=0.0,
    max_tokens=4096
)

system_prompt = """You are a knowledgeable assistant helping developers 
understand AI observability and agent monitoring best practices."""

app = BedrockAgentCoreApp()

@app.entrypoint
def agent_handler(payload):
    """Primary agent entrypoint with trace instrumentation"""
    user_input = payload.get("prompt")
    trace_id = payload.get("trace_id")
    parent_obs_id = payload.get("parent_obs_id")

    # Initialize telemetry and configure OTLP export
    telemetry = StrandsTelemetry()
    telemetry.setup_otlp_exporter()

    # Build agent with MCP tools
    with mcp_client:
        available_tools = mcp_client.list_tools_sync()

        agent = Agent(
            model=bedrock_model,
            system_prompt=system_prompt,
            tools=available_tools
        )

        # Execute within InteractiveAI trace context
        client = Interactive()
        with client.start_as_current_span(
            name="bedrock-agentcore-execution",
            trace_context={
                "trace_id": trace_id,
                "parent_observation_id": parent_obs_id
            }
        ):
            response = agent(user_input)

    return response.message["content"][0]["text"]

if __name__ == "__main__":
    app.run()

---

Deployment and Invocation

Deploy the agent to Amazon Bedrock AgentCore and invoke it with trace context propagation:

from bedrock_agentcore_starter_toolkit import Runtime
from interactiveai import Interactive
import boto3
import json

# Deploy agent to AgentCore
runtime = Runtime()
runtime.configure(
    entrypoint="./agent.py",
    auto_create_execution_role=True,
    auto_create_ecr=True,
    agent_name="traced-agentcore-agent",
    memory_mode="NO_MEMORY"
)

deployment = runtime.launch(
    env_vars={
        "BEDROCK_MODEL_ID": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
        "OTEL_EXPORTER_OTLP_ENDPOINT": os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"],
        "OTEL_EXPORTER_OTLP_HEADERS": os.environ["OTEL_EXPORTER_OTLP_HEADERS"],
        "SYSTEM_PROMPT": system_prompt
    }
)

# Invoke agent with trace propagation
bedrock_client = boto3.client("bedrock-agentcore", region_name="us-west-2")

# Retrieve current trace context
client = Interactive()
current_trace_id = client.get_current_trace_id()
current_obs_id = client.get_current_observation_id()

request_payload = json.dumps({
    "prompt": "How do I implement comprehensive monitoring for production AI agents?",
    "trace_id": current_trace_id,
    "parent_obs_id": current_obs_id
}).encode()

response = bedrock_client.invoke_agent_runtime(
    agentRuntimeArn=deployment.agent_arn,
    runtimeSessionId="session-123",
    payload=request_payload
)

---

Viewing Trace Data

After agent execution, the InteractiveAI dashboard displays complete trace information including:

• End-to-end agent execution flow

• Individual model calls with token consumption and cost calculations

• Tool invocations and MCP interactions

• Latency measurements for each operation

• Request and response payloads for debugging

These traces provide visibility into agent behavior across development, staging, and production environments.