AWS Strands Agents & AgentCore

Overview

AWS Strands Agents SDK

Open-source Python framework for building AI agents with model-driven orchestration (minimal code, model decides tool usage)

Amazon Bedrock AgentCore

Enterprise platform for deploying, operating, and scaling agents in production

Relationship

Strands SDK runs standalone OR with AgentCore platform services. AgentCore is optional but provides enterprise features (8hr runtime, streaming, memory, identity, observability).

Quick Start Decision Tree

What are you building?

Single-purpose agent

:

Event-driven (S3, SQS, scheduled) → Lambda deployment

Interactive with streaming → AgentCore Runtime

API endpoint (stateless) → Lambda

Multi-agent system

:

Deterministic workflow → Graph Pattern

Autonomous collaboration → Swarm Pattern

Simple delegation → Agent-as-Tool Pattern

Tool/Integration Server (MCP)

:

ALWAYS

deploy to ECS/Fargate or AgentCore Runtime

NEVER Lambda

(stateful, needs persistent connections)

See

architecture.md

for deployment examples.

Critical Constraints

MCP Server Requirements

Transport

MUST use

streamable-http

(NOT

stdio

)

Endpoint

MUST be at

0.0.0.0:8000/mcp

Deployment

MUST be ECS/Fargate or AgentCore Runtime (NEVER Lambda)

Headers

Must accept

application/json

and

text/event-stream

Why

MCP servers are stateful and need persistent connections. Lambda is ephemeral and unsuitable.

See

limitations.md

for details.

Tool Count Limits

Models struggle with > 50-100 tools

Solution

Implement semantic search for dynamic tool loading

See

patterns.md

for implementation.

Token Management

Claude 4.5: 200K context (use ~180K max)

Long conversations REQUIRE conversation managers

Multi-agent costs multiply 5-10x

See

limitations.md

for strategies.

Deployment Decision Matrix

Component

Lambda

ECS/Fargate

AgentCore Runtime

Stateless Agents

✅ Perfect

❌ Overkill

❌ Overkill

Interactive Agents

❌ No streaming

⚠️ Possible

✅ Ideal

MCP Servers

❌ NEVER

✅ Standard

✅ With features

Duration

< 15 minutes

Unlimited

Up to 8 hours

Cold Starts

Yes (30-60s)

No

No

Multi-Agent Pattern Selection

Pattern

Complexity

Predictability

Cost

Use Case

Single Agent

Low

High

1x

Most tasks

Agent as Tool

Low

High

2-3x

Simple delegation

Graph

High

Very High

3-5x

Deterministic workflows

Swarm

Medium

Low

5-8x

Autonomous collaboration

Recommendation

Start with single agents, evolve as needed. See architecture.md for examples. When to Read Reference Files patterns.md Base agent factory patterns (reusable components) MCP server registry patterns (tool catalogues) Semantic tool search (> 50 tools) Tool design best practices Security patterns Testing patterns observability.md AWS AgentCore Observability Platform setup Runtime-hosted vs self-hosted configuration Session tracking for multi-turn conversations OpenTelemetry setup Cost tracking hooks Production observability patterns evaluations.md AWS AgentCore Evaluations - Quality assessment with LLM-as-a-Judge 13 built-in evaluators (Helpfulness, Correctness, GoalSuccessRate, etc.) Custom evaluators with your own prompts and models Online (continuous) and on-demand evaluation modes CloudWatch integration and alerting limitations.md MCP server deployment issues Tool selection problems (> 50 tools) Token overflow Lambda limitations Multi-agent cost concerns Throttling errors Cold start latency

-Driven Philosophy

Key Concept

Strands Agents delegates orchestration to the model rather than requiring explicit control flow code.

Traditional: Manual orchestration (avoid)

while not done : if needs_research : result = research_tool ( ) elif needs_analysis : result = analysis_tool ( )

Strands: Model decides (prefer)

agent

Agent

(

system_prompt

=

"You are a research analyst. Use tools to answer questions."

,

tools

=

[

research_tool

,

analysis_tool

]

)

result

=

agent

(

"What are the top tech trends?"

)

automatically orchestrates

:

research_tool → analysis_tool → respond

Selection

Primary Provider

Anthropic Claude via AWS Bedrock Model ID Format : anthropic.claude-{model}-{version} Current Models (as of January 2025): anthropic.claude-sonnet-4-5-20250929-v1:0 - Production anthropic.claude-haiku-4-5-20251001-v1:0 - Fast/economical anthropic.claude-opus-4-5-20250514-v1:0 - Complex reasoning Check Latest Models : aws bedrock list-foundation-models --by-provider anthropic \ --query 'modelSummaries[*].[modelId,modelName]' --output table Quick Examples Basic Agent from strands import Agent from strands . models import BedrockModel from strands . session import DynamoDBSessionManager from strands . agent . conversation_manager import SlidingWindowConversationManager agent = Agent ( agent_id = "my-agent" , model = BedrockModel ( model_id = "anthropic.claude-sonnet-4-5-20250929-v1:0" ) , system_prompt = "You are helpful." , tools = [ tool1 , tool2 ] , session_manager = DynamoDBSessionManager ( table_name = "sessions" ) , conversation_manager = SlidingWindowConversationManager ( max_messages = 20 ) ) result = agent ( "Process this request" ) See patterns.md for base agent factory patterns. MCP Server (ECS/Fargate) from mcp . server import FastMCP import psycopg2 . pool

Persistent connection pool (why Lambda won't work)

db_pool

psycopg2 . pool . SimpleConnectionPool ( minconn = 1 , maxconn = 10 , host = "db.internal" ) mcp = FastMCP ( "Database Tools" ) @mcp . tool ( ) def query_database ( sql : str ) -

dict : conn = db_pool . getconn ( ) try : cursor = conn . cursor ( ) cursor . execute ( sql ) return { "status" : "success" , "rows" : cursor . fetchall ( ) } finally : db_pool . putconn ( conn )

CRITICAL: streamable-http mode

if name == "main" : mcp . run ( transport = "streamable-http" , host = "0.0.0.0" , port = 8000 ) See architecture.md for deployment details. Tool Error Handling from strands import tool @tool def safe_tool ( param : str ) -

dict : """Always return structured results, never raise exceptions.""" try : result = operation ( param ) return { "status" : "success" , "content" : [ { "text" : str ( result ) } ] } except Exception as e : return { "status" : "error" , "content" : [ { "text" : f"Failed: { str ( e ) } " } ] } See patterns.md for tool design patterns. Observability AgentCore Runtime (Automatic) :

Install with OTEL support

pip install 'strands-agents[otel]'

Add 'aws-opentelemetry-distro' to requirements.txt

from bedrock_agentcore . runtime import BedrockAgentCoreApp app = BedrockAgentCoreApp ( ) agent = Agent ( . . . )

Automatically instrumented

@app . entrypoint def handler ( payload ) : return agent ( payload [ "prompt" ] ) Self-Hosted : export AGENT_OBSERVABILITY_ENABLED = true export OTEL_PYTHON_DISTRO = aws_distro export OTEL_RESOURCE_ATTRIBUTES = "service.name=my-agent" opentelemetry-instrument python agent.py General OpenTelemetry : from strands . observability import StrandsTelemetry

Development

telemetry

StrandsTelemetry ( ) . setup_console_exporter ( )

Production

telemetry

StrandsTelemetry ( ) . setup_otlp_exporter ( ) See observability.md for detailed patterns. Session Storage Selection Local dev → FileSystem Lambda agents → S3 or DynamoDB ECS agents → DynamoDB Interactive chat → AgentCore Memory Knowledge bases → AgentCore Memory See architecture.md for storage backend comparison. When to Use AgentCore Platform vs SDK Only Use Strands SDK Only Simple, stateless agents Tight cost control required No enterprise features needed Want deployment flexibility Use Strands SDK + AgentCore Platform Need 8-hour runtime support Streaming responses required Enterprise security/compliance Cross-session intelligence needed Want managed infrastructure See architecture.md for platform service details. Common Anti-Patterns ❌ Overloading agents with > 50 tools → Use semantic search ❌ No conversation management → Implement SlidingWindow or Summarising ❌ Deploying MCP servers to Lambda → Use ECS/Fargate ❌ No timeout configuration → Set execution limits everywhere ❌ Ignoring token limits → Implement conversation managers ❌ No cost monitoring → Implement cost tracking from day one See patterns.md and limitations.md for details. Production Checklist Before deploying: Conversation management configured AgentCore Observability enabled or OpenTelemetry configured AgentCore Evaluations configured for quality monitoring Observability hooks implemented Cost tracking enabled Error handling in all tools Security permissions validated MCP servers deployed to ECS/Fargate Timeout limits set Session backend configured (DynamoDB for production) CloudWatch alarms configured Reference Files Navigation architecture.md - Deployment patterns, multi-agent orchestration, session storage, AgentCore services patterns.md - Foundation components, tool design, security, testing, performance optimisation limitations.md - Known constraints, workarounds, mitigation strategies, challenges observability.md - AgentCore Observability platform, ADOT, GenAI dashboard, OpenTelemetry, hooks, cost tracking evaluations.md - AgentCore Evaluations, built-in evaluators, custom evaluators, quality monitoring Key Takeaways MCP servers MUST use streamable-http, NEVER Lambda Use semantic search for > 15 tools Always implement conversation management Multi-agent costs multiply 5-10x (track from day one) Set timeout limits everywhere Error handling in tools is non-negotiable Lambda for stateless, AgentCore for interactive AgentCore Observability and Evaluations for production Start simple, evolve complexity Security by default Separate config from code