Strands Agents

Strands Agents is a model-driven SDK for building and running AI agents, maintained by AWS with a fully model-agnostic design supporting Amazon Bedrock, Anthropic, Gemini, LiteLLM, Llama, Ollama, OpenAI, Writer, and custom providers. It scales from simple conversational assistants to complex autonomous multi-agent workflows, and from local development to production deployment.

The project is a monorepo housing both Python and TypeScript SDKs alongside a documentation site and supporting packages. Its core design is a lightweight, customizable agent loop with native Model Context Protocol (MCP) support, giving agents access to thousands of pre-built tools out of the box.

What You Get

• A simple Agent(tools=[...]) API with a fully customizable agent loop under the hood
• Model-agnostic provider support: Amazon Bedrock, Anthropic, Gemini, LiteLLM, Llama, Ollama, OpenAI, Writer, SageMaker, and custom providers
• Native Model Context Protocol (MCP) client support for connecting agents to external tool servers
• Python-decorator-based custom tool authoring (@tool) alongside a large ecosystem of pre-built tools
• Multi-agent system support, session/state management, hooks, interrupts, and built-in OpenTelemetry-based tracing

Common Use Cases

• Building conversational assistants that call external tools (calculators, search, APIs) via a simple decorator-based tool interface
• Orchestrating multi-agent workflows where several specialized agents collaborate on a task
• Connecting an agent to existing MCP tool servers to give it access to a broad, pre-built tool ecosystem without custom integration work
• Deploying the same agent code across model providers (Bedrock, Anthropic, OpenAI, etc.) by swapping the model config rather than rewriting agent logic

Under The Hood

Architecture: strands-py/src/strands is organized into clearly separated concerns — agent/ defines the core Agent abstraction and its lifecycle, event_loop/ drives the actual conversational/tool-calling loop, models/ implements the provider-agnostic model interface with per-provider adapters, multiagent/ handles coordination between multiple agents, tools/ and vended_tools/ manage tool registration/execution (including MCP-sourced tools), hooks/ and interventions//interrupt.py provide extensibility points for customizing agent behavior mid-run, and telemetry/ wires in OpenTelemetry instrumentation. The session/ and storage/ modules persist agent state, and sandbox/ isolates tool execution. This is one Python package inside a larger monorepo that also ships a parallel TypeScript SDK (strands-ts) sharing the same conceptual model. Tech Stack: Core dependencies include boto3/botocore (Bedrock), pydantic for schema/data validation, mcp for Model Context Protocol support, jsonschema, opentelemetry-api/sdk for tracing, and watchdog — with an extensive set of optional extras (anthropic, gemini, litellm, llamaapi, mistral, ollama, openai, writer, sagemaker) gating each model provider’s SDK dependency so users only install what they need. Built with hatchling/hatch-vcs for git-tag-based versioning, and the monorepo enforces a single ruff/pyright configuration across all Python packages. Code Quality: The test suite is unusually large relative to the implementation — roughly 88,000 lines of tests (tests/ plus tests_integ/ covering tools, memory, MCP, models, hooks, interrupts, sandboxing, and more) against about 51,000 lines of src/, and the repo shows very active, consistent commit history (2,200+ commits since a May 2025 creation date), reflecting AWS-backed engineering rigor for a project used in production agent deployments. API Design: The headline API is deliberately minimal — Agent(tools=[calculator]) then agent("question") — with complexity (multi-agent coordination, custom model providers, MCP integration, hooks) layered in as opt-in extensions rather than required upfront configuration, which is the core design philosophy behind the ‘model-driven, few lines of code’ framing.