> ## Documentation Index > Fetch the complete documentation index at: https://docs.honeyhive.ai/llms.txt > Use this file to discover all available pages before exploring further. # AWS Strands Agents > Add HoneyHive observability to your Strands Agents applications [Strands Agents](https://strandsagents.com/) 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. ## 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](/v2/tracing/tracer-initialization). ```bash theme={null} pip install "honeyhive[aws-strands]" # Or install separately pip install honeyhive strands-agents ``` ```python theme={null} import os from honeyhive import HoneyHiveTracer from strands import Agent tracer = HoneyHiveTracer.init( api_key=os.getenv("HH_API_KEY"), project=os.getenv("HH_PROJECT"), ) # 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 April 2026. Newer patch releases are generally safe; pin to these versions to reproduce a known-good configuration. | Package | Version | | ---------------- | --------------------------------------------------------------- | | `strands-agents` | `1.37.0` (minimum: `>= 1.19.0`) | | `boto3` | `1.42.97` (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 ```python theme={null} import os from honeyhive import HoneyHiveTracer from strands import Agent, tool from strands.models.anthropic import AnthropicModel # Initialize HoneyHive first tracer = HoneyHiveTracer.init( api_key=os.getenv("HH_API_KEY"), project=os.getenv("HH_PROJECT"), ) @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: ```bash theme={null} export AWS_ACCESS_KEY_ID="your-access-key" export AWS_SECRET_ACCESS_KEY="your-secret-key" export AWS_DEFAULT_REGION="us-west-2" ``` ```bash theme={null} pip install "honeyhive[aws-strands]" ``` ```python theme={null} import os from honeyhive import HoneyHiveTracer from strands import Agent, tool from strands.models import BedrockModel # Initialize HoneyHive first tracer = HoneyHiveTracer.init( api_key=os.getenv("HH_API_KEY"), project=os.getenv("HH_PROJECT"), ) @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: ```python theme={null} import os from honeyhive import HoneyHiveTracer from strands import Agent, tool from strands.models.anthropic import AnthropicModel tracer = HoneyHiveTracer.init( api_key=os.getenv("HH_API_KEY"), project=os.getenv("HH_PROJECT"), ) 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: ```python theme={null} tracer = HoneyHiveTracer.init(project="your-project") 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: ```python theme={null} 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 1. **Initialize HoneyHive first** - Must be called before importing Strands: ```python theme={null} # ✅ Correct order from honeyhive import HoneyHiveTracer tracer = HoneyHiveTracer.init(project="your-project") from strands import Agent # Import after HoneyHive init # ❌ Wrong - HoneyHive initialized after Strands from strands import Agent from honeyhive import HoneyHiveTracer tracer = HoneyHiveTracer.init(project="your-project") ``` 2. **Check environment variables** - Ensure `HH_API_KEY` and `HH_PROJECT` are set 3. **Verify model credentials** - Ensure your model provider credentials are configured (Anthropic API key, AWS credentials, etc.) *** ## Related Add user IDs and custom metadata to Strands traces Create spans for business logic around agent calls Trace agents across service boundaries Export traces programmatically *** ## Resources * [Strands Agents Documentation](https://strandsagents.com/) * [Strands GitHub](https://github.com/strands-agents/sdk-python)