Amazon released Strands Agents as open source in May 2026, and it’s a genuinely interesting addition to a crowded framework space. The pitch is straightforward: a lightweight Python SDK that makes it simple to define tools, wire them to a model, and have an agent use them to complete tasks. No sprawling abstraction layers, no YAML configuration files, no separate orchestration runtime to learn.

It runs on AWS Bedrock by default, but it’s model-agnostic. You can point it at Anthropic’s API directly, OpenAI, or any provider that speaks the standard LLM interface. That flexibility matters if you’re building in an environment where your model choice might change, or where you’re running evals across multiple providers.

The Basics

The core abstraction in Strands is simple: an Agent takes a model, a list of tools, and an optional system prompt. You call it with a string and it runs until it completes the task or hits a configured limit.

Tools are defined with a @tool decorator. You write a Python function, annotate it, and Strands handles the JSON schema generation and model integration. The function’s docstring becomes the tool description, and type hints become the parameter schema. It’s the least boilerplate way to define tools I’ve seen in any framework.

from strands import Agent, tool

@tool
def get_weather(city: str) -> str:
    """Get current weather conditions for a city."""
    # your implementation here
    return f"Current weather in {city}: 18°C, partly cloudy"

agent = Agent(
    model="us.anthropic.claude-sonnet-4-5-20250514",
    tools=[get_weather],
    system_prompt="You are a helpful travel assistant."
)

response = agent("What's the weather like in Edinburgh?")

That’s the entire setup. The agent will figure out it needs to call get_weather, make the call, and incorporate the result into its response.

Built-In Tools

Strands ships with a standard library of tools you can drop in without writing anything: file read/write, shell execution, HTTP requests, Python code execution in a subprocess, and a browser automation tool using Playwright. For a lot of tasks — research agents, file processing pipelines, code execution workflows — these get you most of the way there without any custom implementation.

The use_llm tool is worth calling out specifically. It lets an agent spawn a sub-agent call to a different model or with a different system prompt. You can use this to route particular subtasks to a cheaper or more capable model without building a full multi-agent setup.

MCP Integration

Strands has first-class support for the Model Context Protocol, which means any MCP server — file systems, databases, web search, GitHub, and hundreds of community-built tools — works as a Strands tool with a few lines of configuration. If your organisation is already running MCP servers internally, plugging them into a Strands agent is much less work than writing custom tool wrappers.

from strands.tools.mcp import MCPClient

mcp_client = MCPClient(command="npx", args=["-y", "@modelcontextprotocol/server-filesystem", "/workspace"])
with mcp_client:
    agent = Agent(tools=mcp_client.list_tools_sync())

The MCP integration is synchronous by default but supports async contexts if you need non-blocking I/O.

Multi-Agent Patterns

Strands supports two multi-agent patterns. The first is the sub-agent approach using use_llm — the orchestrator delegates work to specialised agents inline. The second is explicit agent-to-agent handoffs, where one agent passes control entirely to another for a defined scope of work.

This is less sophisticated than LangGraph’s stateful graph execution or CrewAI’s role-based orchestration, and intentionally so. Strands doesn’t try to manage complex inter-agent state or give you a visual graph of your pipeline. If you need those things, LangGraph is probably still the right tool. If you want agents that can use other agents without a lot of setup, Strands handles it cleanly.

How It Compares

The clearest point of comparison is with LangGraph and CrewAI, the two most widely used Python agent frameworks.

LangGraph gives you stateful graph execution with explicit node definitions and edges. It’s powerful for complex multi-step workflows where you need precise control over branching and state. The trade-off is that it takes meaningful time to learn and adds real complexity. Strands is substantially simpler to start with.

CrewAI is built around the concept of agent teams with roles. If your use case maps naturally to a “team with specialists” model — a researcher, a writer, a reviewer working together — CrewAI’s abstractions fit well. For more general-purpose tool-using agents, it’s more framework than you need.

Strands sits between “roll your own with the Anthropic SDK” and the full complexity of LangGraph. The sweet spot is agents that need to use a set of tools to complete a task and should be able to hand work to sub-agents occasionally — without requiring a graph definition or a team metaphor.

AWS Bedrock Integration

The default model provider is Bedrock, which has practical implications for teams already on AWS. You get IAM-based auth, no separate API key management, and the same VPC-based network isolation as the rest of your AWS infrastructure. For enterprise teams with strict data residency requirements, running agents through Bedrock with a private VPC endpoint means model traffic stays within your AWS environment.

The Bedrock integration also gives Strands access to Bedrock’s inline agents API and knowledge bases, so you can incorporate RAG retrieval from Bedrock Knowledge Bases without writing a separate retrieval layer.

Worth Evaluating If

Strands is worth a look if you want a low-friction way to put tool-using agents into production on AWS, if you’re already running MCP servers, or if you need a framework that can run against multiple LLM providers without a rewrite. It’s also a reasonable choice if the complexity of LangGraph has felt like a deterrent — Strands is meaningfully simpler to pick up.

The source is on GitHub under an Apache 2.0 licence and the documentation covers the core use cases well. For teams already deep in the AWS ecosystem, it’s likely the path of least resistance for getting an agent into production.