cloudparts

Strands Agents

AWS’s Apache 2.0 toolkit for building agents in Python and TypeScript: an SDK whose agent is a model, a system prompt and a list of tools run in a loop inside your own process, plus a ready-made harness, sandboxes and evals built on it.

What it is
Agent frameworks
Type
Open source
Made by
Amazon Web Services
License
Apache 2.0
Facts checked
13 October 2026
Website Source code

What it is

Strands takes what AWS calls a model-driven approach: rather than drawing a workflow, you give the Agent a model, a prompt and tools, and the loop lets the model plan. Each turn it sends the conversation and the tool descriptions to the model; if the model asks for a tool, Strands validates the request against the tool’s schema, runs it, appends the result (or the error, so the model can recover) and calls the model again, until the model ends its turn. Any Python function becomes a tool with the @tool decorator, whose docstring and type hints are what the model reads; MCP servers plug in as tools through MCPClient. Production controls are part of the loop: turn and token budgets, cancellation, stop reasons, hooks on every step, retries, conversation managers that keep history inside the context window, session persistence and OpenTelemetry traces.

Agents run in-process, with no hosted control plane: the docs show deployment to Lambda, Fargate, EKS, EC2, App Runner, Bedrock AgentCore, Docker and Kubernetes. Amazon Bedrock is the default model provider (Claude Sonnet 4.6 in us-west-2, using your AWS credentials), and the same agent code runs on Anthropic, OpenAI, Google, Ollama, LiteLLM and other providers. Version 1.0 added multi-agent primitives (agents as tools, swarms, graphs) and support for the Agent2Agent (A2A) protocol. The SDK, published as strands-agents on PyPI and @strands-agents/sdk on npm, is now documented as the Strands Harness SDK and lives in the strands-agents/harness-sdk repository; Strands harness, released in September 2026, is a fully assembled agent built on it with tuned defaults for prompts, tools, memory and context management.

Why teams pick it

  • Little code for an agent: Agent(tools=[...]) and a call, with the model, not your code, deciding which tools to use and in what order
  • Production controls in the box: invocation limits, cancellation, stop reasons, hooks, retries, session persistence and OpenTelemetry tracing
  • Not tied to one model vendor: Bedrock, Anthropic, OpenAI and Google are first-party providers, plus Ollama, LiteLLM and community packages
  • Runs inside your own process on any compute, and AWS uses it in production for Amazon Q Developer, AWS Glue and VPC Reachability Analyzer

Watch out for

  • Defaults lean on AWS: with no model configured it calls Bedrock, so you need AWS credentials and model access enabled, or must pick another provider
  • Python and TypeScript don’t match: Ollama, LiteLLM, llama.cpp, Mistral and SageMaker are Python-only providers, and Vercel is TypeScript-only
  • Prompt caching works only where the provider supports cache points (Bedrock, Anthropic, LiteLLM, llama.cpp, Vercel), not with OpenAI, Google or Ollama through Strands
  • Instructions in the prompt alone aren’t always followed: in a Strands team test over 600 runs, prompt instructions passed 82.5% of the time against 100% with steering hooks, so critical rules belong in hooks or interventions

Alternatives

What all agent frameworks have in common →Compare side by side →
GenkitOpen sourceGoogle’s Apache 2.0 framework for putting model calls, tools, RAG and agents into app backends, with SDKs for TypeScript, Go, Dart and Python and a local Developer UI that traces every step.LangChainOpen sourceAn MIT-licensed Python and JavaScript framework whose create_agent runs the model and tool-calling loop for you, with one interface over many model providers and middleware hooks around every step.LangGraphOpen sourceA low-level MIT-licensed runtime for agents written as graphs of nodes over shared state, which checkpoints that state after every step so a run can pause for a human, survive a crash and resume where it stopped.

How it fits with other technologies

A custom tool plus a vended tool on the default Bedrock model (pip install strands-agents) · python

from strands import Agent, tool
from strands.vended_tools import file_editor

@tool
def letter_counter(word: str, letter: str) -> int:
    """Count occurrences of a specific letter in a word."""
    if len(letter) != 1:
        raise ValueError("The 'letter' parameter must be a single character")
    return word.lower().count(letter.lower())

agent = Agent(tools=[letter_counter, file_editor])
agent('How many letter R\'s are in the word "strawberry"? Write the answer to answer.txt.')

See it in a real stack

No architecture uses Strands Agents yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2025–2026

Clare Liguori’s team at AWS started building agents for Amazon Q Developer in early 2023, when models weren’t trained to act as agents: getting one to reason and call tools took long prompt instructions, response parsers and orchestration logic, and the agent frameworks that provided that scaffolding meant months of tuning before an agent was ready for production. As models gained native tool use and reasoning, the team found those frameworks getting in the way, so they built a minimal loop instead. An early agent for network troubleshooting was little more than a system prompt, a Claude 3 model and tools.

AWS open-sourced Strands Agents as a preview on 16 May 2025, already used in production by Amazon Q Developer, AWS Glue and VPC Reachability Analyzer, with Anthropic and Meta contributing model providers. Version 1.0 followed on 15 July 2025 with multi-agent primitives, A2A support and a session manager. A TypeScript SDK followed, and by its first anniversary in May 2026 the project counted 25 million downloads. In September 2026 the team released Strands harness, a fully assembled agent on top of what is now called the Strands Harness SDK.

Why it’s built this way

Let the model plan instead of scripting workflows
Workflow scaffolding written for one model generation became technical debt when a better model arrived. A prompt plus tools in a loop lets the agent improve with the model without refactoring.
Multi-agent patterns as tools
Modeling sub-agents, graphs and swarms as tools lets the model decide when a task needs them, the same way it decides to call any other tool.
Retrieve tools instead of listing them all
One internal AWS agent had over 6,000 tools, more than a model can choose from accurately, so Strands showed a pattern where the agent searches a knowledge base for the few tools relevant to the task.

Timeline

  1. 2025

    AWS open-sources Strands Agents as a Python SDK preview

  2. 2025

    Strands Agents 1.0 adds agents-as-tools, graphs, swarms, A2A and remote session storage

  3. 2026

    First anniversary: 25 million downloads

  4. 2026

    Strands harness, a ready-made agent on the Strands Harness SDK, released under Apache 2.0

Sources10 · facts checked 13 October 2026

Improve this page on GitHub