Building Intelligent Agents with Strands: A Hands-On Guide

Strands Agents SDK is an open-source framework developed by AWS for building autonomous AI agents using a model-driven approach.

Released in May 2025 under the Apache-2.0 license, it enables developers to create intelligent agents—from simple conversational assistants to complex multi-agent workflows—in just a few lines of code.

The name “Strands” draws from DNA, symbolizing how it connects core components: the AI model (the “brain” for reasoning) and tools (for actions and execution).

This lightweight SDK scales seamlessly from local prototyping on a laptop to production deployments on AWS services, eliminating thousands of lines of boilerplate code while boosting accuracy and reliability.

Since its launch, Strands has garnered over 5 million downloads and is actively used in production by AWS teams for features in services like Amazon Q Developer (a generative AI assistant for software development), AWS Glue (data integration), VPC Reachability Analyzer (network diagnostics), and Kiro (DevOps agent). It’s community-driven, with contributions from companies like Accenture, Anthropic, Meta, PwC, Langfuse, mem0.ai, Ragas.io, and Tavily—such as Anthropic’s API integration and Meta’s Llama model support.

Core Features and Architecture

Strands emphasizes simplicity and flexibility, treating the foundation model as the central intelligence for autonomous reasoning. Key features include:

• Model-First Design: Agents are defined with a prompt, tools, and a large language model (LLM). The SDK handles the agent loop (reasoning, planning, tool execution, and reflection) dynamically, allowing models to orchestrate actions without rigid orchestration code.
• Model Agnosticism: Supports a wide range of providers and models, including Amazon Bedrock (default: Anthropic Claude 4 Sonnet), OpenAI, Anthropic, Gemini, LiteLLM, Llama, Ollama, Writer, and custom integrations. This lets you swap models easily for experimentation or cost optimization.
• Tool Integration: Built-in and extensible tools for tasks like calculations, web searches, or AWS service calls (e.g., via AWS Lambda or Step Functions). Tools can be async for non-blocking execution.
• Multi-Agent Orchestration: Version 1.0 (announced July 2025) introduced primitives for multi-agent systems, including the Agent-to-Agent (A2A) protocol for seamless handoffs, session management for state persistence, and async support for concurrent operations.
• Observability and Tracing: Built-in logging, real-time streaming of events (text, tool calls, reasoning steps), and integration with tools like Langfuse for monitoring performance in production.
• Security and Scalability: Native AWS integrations ensure secure deployments with identity management, encryption, and auto-scaling. Agents can run as monoliths or microservices behind APIs.

The architecture supports four common patterns used internally at AWS:

1. Monolithic: Agent loop and tools in one environment for simplicity.
2. API-Backed: Deployed behind AWS Lambda, Fargate, or EC2 for external access.
3. Workflow-Orchestrated: Using AWS Step Functions for long-running tasks.
4. Multi-Agent: Hierarchical or collaborative agents with state sharing.

Getting Started: Quick Example

Installation is straightforward via pip:

pip install strands-agents strands-agents-tools

For the default setup, configure AWS credentials (e.g., via aws configure) and enable access to Claude 4 Sonnet in Amazon Bedrock (us-west-2 region).

Here’s a basic “Hello World” agent in Python:

from strands import Agent
from strands_tools import calculator  # Built-in tool example

# Create an agent with tools and default model
agent = Agent(tools=[calculator])

# Invoke the agent
response = agent("What is the square root of 1764?")
print(response)  # Output: "The square root of 1764 is 42."

This agent reasons over the query, selects the calculator tool, executes it, and returns the result—all in under 10 lines. For multi-agent setups, define hierarchies with prompts like “Delegate math tasks to the calculator agent.”

Recent Updates from AWS re:Invent 2025

At AWS re:Invent 2025 (December 2025), Swami Sivasubramanian highlighted Strands as a key enabler for “building without limits” in agentic AI. Major announcements include:

• TypeScript Support (Preview): Developers can now choose Python or TypeScript for building agents. The TS version offers full type safety, async/await, and idiomatic patterns, ideal for client-side apps, browsers, or serverless runtimes like AWS Lambda and Bedrock AgentCore. Use AWS CDK for full-stack TS deployments.
• Edge Device Support (General Availability): Run agents on resource-constrained devices (ARM/x86) with sub-100ms latency, supporting local models via llama.cpp for offline scenarios like robotics, in-vehicle AI, or gaming. Includes bidirectional streaming.
• Steering (Experimental): A modular prompt mechanism to guide agents mid-execution with feedback, enforcing workflows without hardcoding—e.g., nudging toward safer or more accurate outputs.
• Evaluation Framework (Preview): Systematic testing with 13+ metrics (e.g., safety, accuracy, efficiency) to validate agent behavior, measure improvements, and build confidence before release.

These updates extend Strands to new frontiers, like integrating with Amazon Bedrock AgentCore for memory management (short-term episodic memory for learning from interactions) and Amazon Nova Act for automating legacy systems without APIs.

Deployment and Production Use Cases

Strands deploys effortlessly to AWS:

• Local to Cloud: Test on your machine, then deploy to EKS, Lambda, EC2, or Fargate using reference GitHub implementations.
• Memory and Sessions: Integrates with Bedrock AgentCore for persistent state, e.g., remembering user preferences like “I like sushi with tuna” for personalized recommendations.
• Real-World Examples:
  • Jit: Infrastructure drift detection agent for security scanning.
  • Swisscom: Enterprise-grade multi-agent backbone for customer workflows.
  • TeamForm: Secure, scalable agents for team collaboration.
  • AWS Transform for .NET: Autonomous modernization of legacy apps—analyzes code, plans migrations, and executes transformations.

For edge cases, pair with reinforcement learning (via “RL gems”) for simulated training, achieving up to 90% reliability in enterprise settings.

Community and Resources

Strands is hosted on GitHub (strands-agents/sdk-python for Python; TS repo forthcoming), with comprehensive docs at strandsagents.com. Check the samples repo for A2A integrations and the AWS Open Source Blog for deep dives. Join the open community to contribute or explore integrations like AG-UI for real-time frontend collaboration.

In essence, Strands democratizes agentic AI, letting developers focus on innovation rather than infrastructure. As Sivasubramanian noted, it’s about “agents we can rely on”—powerful, efficient, and ready to tackle complex problems at scale. Dive in on GitHub and start building today!