How to trace AWS Strands Agents with HoneyHive

Strands Agents is an open-source SDK from AWS for building AI agents. It provides a simple, code-first approach to creating agents with tools, multi-agent orchestration, and streaming support. HoneyHive integrates seamlessly with Strands—no instrumentor needed. Strands uses OpenTelemetry natively, so initializing HoneyHive first automatically captures all agent activity.

Python

Trace strands-agents with the HoneyHive Python SDK

TypeScript

Trace @strands-agents/sdk with a standard OTLP exporter

Quick Start

Zero configuration required. Just initialize HoneyHive before importing Strands and all agent runs, tool calls, and model calls are automatically traced.

To see where to initialize the tracer for your environment, including AWS Lambda and long-running servers, see Tracer Initialization.

pip install "honeyhive[aws-strands]"

# Or install separately
pip install honeyhive strands-agents

from honeyhive import HoneyHiveTracer
from strands import Agent

tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

# Your Strands code works unchanged - traces appear automatically
agent = Agent(model=your_model)
result = agent("Hello!")

Tested Versions

HoneyHive’s Strands integration is tested against the following versions, as of October 2026. Newer patch releases are generally safe; pin to these versions to reproduce a known-good configuration.

Package	Version
`honeyhive`	`1.7.0`
`strands-agents`	`1.58.0` (minimum: `>= 1.19.0`)
`boto3`	`1.42.97`, last tested April 2026 (minimum: `>= 1.26.0`, for AWS Bedrock model backend)

Requires Python 3.11+.

Don’t use openinference-instrumentation-strands-agents. That SpanProcessor (from Arize/OpenInference) isn’t supported by HoneyHive’s ingestion pipeline today and its spans may be dropped or misrouted. Strands’ native OTel path shown above is the recommended and fully supported approach.

What Gets Traced

HoneyHive automatically captures:

Agent invocations - Every agent() call with inputs and outputs
LLM calls - Model requests, responses, and token usage
Tool executions - Each tool call with arguments and results
Event loop cycles - Internal agent reasoning steps

No manual instrumentation required.

Example: Agent with Tools

from honeyhive import HoneyHiveTracer
from strands import Agent, tool
from strands.models.anthropic import AnthropicModel

# Initialize HoneyHive first
tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

@tool
def calculator(expression: str) -> str:
    """Evaluate a math expression."""
    return str(eval(expression))

agent = Agent(
    model=AnthropicModel(model_id="claude-sonnet-4-20250514", max_tokens=1024),
    tools=[calculator],
    system_prompt="You are a helpful assistant.",
)

result = agent("What is 25 * 4?")
print(result)

Example: AWS Bedrock Model Backend

Strands works with AWS Bedrock via BedrockModel. You’ll need AWS credentials configured via any standard mechanism — ~/.aws/credentials, an IAM role, or environment variables:

export AWS_ACCESS_KEY_ID="your-access-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
export AWS_DEFAULT_REGION="us-west-2"

pip install "honeyhive[aws-strands]"

from honeyhive import HoneyHiveTracer
from strands import Agent, tool
from strands.models import BedrockModel

# Initialize HoneyHive first
tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

@tool
def calculator(operation: str, a: float, b: float) -> float:
    """Perform basic math operations."""
    if operation == "add":
        return a + b
    elif operation == "multiply":
        return a * b
    return 0

# Use a cross-region inference profile for on-demand throughput
model = BedrockModel(model_id="us.anthropic.claude-haiku-4-5-20251001-v1:0")
agent = Agent(model=model, tools=[calculator])

result = agent("What is 5 + 3?")
print(result)

Use a cross-region inference profile (the us. or global. prefix on the model ID) rather than a bare model ID. Bedrock requires the prefixed form for on-demand requests to Claude models — without it, Strands will fail with a model-access error. Example: us.anthropic.claude-haiku-4-5-20251001-v1:0.

Example: Multi-Agent (Agents-as-Tools)

Strands supports wrapping agents as tools for orchestration patterns:

from honeyhive import HoneyHiveTracer
from strands import Agent, tool
from strands.models.anthropic import AnthropicModel

tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

def get_model():
    return AnthropicModel(model_id="claude-sonnet-4-20250514", max_tokens=1024)

# Specialist agents wrapped as tools
@tool
def research_agent(query: str) -> str:
    """Research factual information."""
    agent = Agent(model=get_model(), system_prompt="You are a research specialist.")
    return str(agent(query))

@tool
def math_agent(problem: str) -> str:
    """Solve math problems step-by-step."""
    agent = Agent(model=get_model(), system_prompt="You are a math specialist.")
    return str(agent(problem))

# Orchestrator routes to specialists
orchestrator = Agent(
    model=get_model(),
    tools=[research_agent, math_agent],
    system_prompt="""Route queries to the appropriate specialist:
- Factual questions → research_agent
- Math problems → math_agent""",
)

result = orchestrator("What is the square root of 144?")
print(result)

In HoneyHive, you’ll see the full trace hierarchy: orchestrator → specialist agent → LLM calls.

Adding Metadata

Session-Level (User Context)

Use enrich_session for metadata that applies to the entire session:

tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

tracer.enrich_session(
    user_properties={
        "user_id": "user_123",
        "plan": "enterprise",
    }
)

Span-Level (Agent Attributes)

Use Strands’ native trace_attributes for metadata on agent spans:

agent = Agent(
    model=model,
    tools=[...],
    trace_attributes={
        "environment": "production",
        "feature": "customer_support",
        "app_version": "2.1.0",
    },
)

These attributes appear on all spans created by that agent (invocations, LLM calls, tool executions).

Troubleshooting

Traces not appearing

Initialize HoneyHive first - Must be called before importing Strands:

# ✅ Correct order
from honeyhive import HoneyHiveTracer
tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

from strands import Agent  # Import after HoneyHive init

# ❌ Wrong - HoneyHive initialized after Strands
from strands import Agent
from honeyhive import HoneyHiveTracer
tracer = HoneyHiveTracer.init()  # Reads HH_INGESTION_API_KEY from your environment

Check environment variables - Ensure HH_INGESTION_API_KEY is set
Verify model credentials - Ensure your model provider credentials are configured (Anthropic API key, AWS credentials, etc.)

TypeScript

The Strands Agents TypeScript SDK also emits OpenTelemetry spans natively, so you can send them to HoneyHive with a standard OTLP exporter. HoneyHive groups spans into a session by honeyhive.session_id. Strands sets it only on the root agent span, so tracing.ts below copies it to every child span.

Install

npm init -y
npm pkg set type=module
npm install @strands-agents/sdk openai zod \
  @opentelemetry/api \
  @opentelemetry/sdk-trace-node \
  @opentelemetry/sdk-trace-base \
  @opentelemetry/exporter-trace-otlp-http
npm install -D tsx typescript @types/node

Configure the exporter

export HH_INGESTION_API_KEY="hh_ingst_..."
export HH_DATA_PLANE_URL="https://api.dp1.us.honeyhive.ai"
export OTEL_EXPORTER_OTLP_ENDPOINT="${HH_DATA_PLANE_URL}/opentelemetry"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer ${HH_INGESTION_API_KEY}"
export OPENAI_API_KEY="your-openai-key"

Create an ingestion API key under Settings > Project > API Keys > Ingestion. The same tab shows your data plane URL.

Register the tracer provider

tracing.ts

import { type Context, trace } from '@opentelemetry/api'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
import {
  BatchSpanProcessor,
  type ReadableSpan,
  type Span,
  type SpanProcessor,
} from '@opentelemetry/sdk-trace-base'
import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'

// Strands sets traceAttributes only on the root agent span.
// HoneyHive needs honeyhive.session_id on every span, so copy it to child spans.
class HoneyHiveSessionPropagator implements SpanProcessor {
  onStart(span: Span, parentContext: Context): void {
    const parent = trace.getSpan(parentContext) as ReadableSpan | undefined
    for (const [key, value] of Object.entries(parent?.attributes ?? {})) {
      if (key.startsWith('honeyhive.') && value !== undefined) {
        span.setAttribute(key, value)
      }
    }
  }
  onEnd(): void {}
  async forceFlush(): Promise<void> {}
  async shutdown(): Promise<void> {}
}

// OTLPTraceExporter reads OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS.
export const provider = new NodeTracerProvider({
  spanProcessors: [
    new HoneyHiveSessionPropagator(),
    new BatchSpanProcessor(new OTLPTraceExporter()),
  ],
})
provider.register()

Run an agent

agent.ts

import { provider } from './tracing.js' // Import first so Strands uses this provider
import { randomUUID } from 'node:crypto'
import { Agent, tool } from '@strands-agents/sdk'
import { OpenAIModel } from '@strands-agents/sdk/models/openai'
import { z } from 'zod'

const calculator = tool({
  name: 'calculator',
  description: 'Multiply two numbers.',
  inputSchema: z.object({ a: z.number(), b: z.number() }),
  callback: ({ a, b }) => a * b,
})

const sessionId = randomUUID() // New UUID per conversation

const agent = new Agent({
  model: new OpenAIModel({ modelId: 'gpt-4.1-mini' }),
  tools: [calculator],
  systemPrompt: 'Use the calculator tool for arithmetic.',
  traceAttributes: {
    'honeyhive.session_id': sessionId,
    'honeyhive.session_name': 'strands-ts-agent',
    'honeyhive.session_auto_create': true, // Creates the session in HoneyHive on the first span
  },
})

const result = await agent.invoke('What is 25 * 4?')
console.log(String(result))
console.log(`Session ID: ${sessionId}`)

await provider.shutdown() // Flush spans before the process exits

Run it with npx tsx agent.ts. The agent, model, and tool spans appear in one session in HoneyHive.

Generate a new honeyhive.session_id for each conversation. Reuse it across invoke calls to keep a multi-turn conversation in one session.
To use Bedrock, replace OpenAIModel with BedrockModel from @strands-agents/sdk/models/bedrock.

Tested in October 2026 with @strands-agents/sdk 1.19.0, @opentelemetry/sdk-trace-node 2.12.0, Node.js 22, and the OpenAI model provider.

Add metadata, metrics, and feedback

To enrich a session after the run, use the TypeScript API SDK with the session ID that agent.ts prints.

npm install @honeyhive/api-client

enrich.ts

import { Client } from '@honeyhive/api-client'

const sessionId = process.argv[2]! // The session ID that agent.ts printed

const client = new Client() // Reads HH_INGESTION_API_KEY and HH_DATA_PLANE_URL

await client.events.update({
  event_id: sessionId,
  metadata: { customer_tier: 'enterprise' },
  metrics: { answer_correct: true },
  feedback: { rating: 5 },
})

Run it with npx tsx enrich.ts <session-id>.

Enrich Your Traces

Add user IDs and custom metadata to Strands traces

Custom Spans

Create spans for business logic around agent calls

Distributed Tracing

Trace agents across service boundaries

Query Trace Data

Export traces programmatically

Agent Frameworks & Platforms

Model Providers

AI Gateways

Coding Agents

OpenTelemetry

Evaluation

How to trace AWS Strands Agents with HoneyHive

Python

TypeScript

Quick Start

Tested Versions

What Gets Traced

Example: Agent with Tools

Example: AWS Bedrock Model Backend

Example: Multi-Agent (Agents-as-Tools)

Adding Metadata

Session-Level (User Context)

Span-Level (Agent Attributes)

Troubleshooting

Traces not appearing

TypeScript

Install

Configure the exporter

Register the tracer provider

Run an agent

Add metadata, metrics, and feedback

Enrich Your Traces

Custom Spans

Distributed Tracing

Query Trace Data

Resources

Python

TypeScript

​Quick Start

​Tested Versions

​What Gets Traced

​Example: Agent with Tools

​Example: AWS Bedrock Model Backend

​Example: Multi-Agent (Agents-as-Tools)

​Adding Metadata

​Session-Level (User Context)

​Span-Level (Agent Attributes)

​Troubleshooting

​Traces not appearing

​TypeScript

​Install

​Configure the exporter

​Register the tracer provider

​Run an agent

​Add metadata, metrics, and feedback

​Related

Enrich Your Traces

Custom Spans

Distributed Tracing

Query Trace Data

​Resources

Quick Start

Tested Versions

What Gets Traced

Example: Agent with Tools

Example: AWS Bedrock Model Backend

Example: Multi-Agent (Agents-as-Tools)

Adding Metadata

Session-Level (User Context)

Span-Level (Agent Attributes)

Troubleshooting

Traces not appearing

TypeScript

Install

Configure the exporter

Register the tracer provider

Run an agent

Add metadata, metrics, and feedback

Related

Resources