Strands Agents for Rust

A model-driven approach to building AI agents in just a few lines of Rust.

Documentation ◆ Samples ◆ Tools ◆ Agent Builder ◆ MCP Server

Strands Agents is a simple yet powerful SDK that takes a model-driven approach to building and running AI agents. From conversational assistants to complex autonomous workflows, and from local development to production deployment, Strands Agents scales with your needs.

This repository contains the native Rust SDK, documentation site, and supporting packages:

Directory	Description
crates/strands-agents/	Rust SDK: agent loop, model providers, tools, hooks, sessions, multi-agent orchestration, and observability
crates/strands-engine/	Out-of-process Rust runtime that runs the agent loop behind a JSON stdio protocol for the TS and Python facades
packages/	Drop-in Agent facades over the engine: TypeScript (@strands-agents/sdk-rust) and Python (strands_rust)
tools/strandly/	Developer CLI for local builds and workspace tooling
test-infra/	Infrastructure definitions for credentialed integration tests
website/	Source for the Rust documentation site (Astro/Starlight and rustdoc)
team/	Governance and cross-SDK process docs, including tenets, decisions, compatibility policy, and design proposals

Why Strands

Build an agent harness. Control it end-to-end.

• Build your way. Any model, any cloud. Context management, execution limits, and observability are built in before you write configuration. Swap backends as you scale; your agent code stays stable.
• Model agnostic. The provider abstraction and adapters cover Amazon Bedrock, Anthropic, OpenAI, Google, Vercel AI SDK-compatible providers, and custom models. See model providers.
• Stay in control. The agent loop traces decisions by default. Hooks let you intercept lifecycle events to log, validate, or redirect execution.
• Deliver outcomes that work. Guardrails catch mistakes before execution. Steering handlers let agents correct themselves instead of failing silently.

MCP, streaming, A2A, graphs, swarms, structured output, session persistence, vended tools, plugins, interventions, storage adapters, telemetry, and sandbox integrations are all part of the SDK.

Quick Start

The SDK defaults to the Amazon Bedrock model provider, so configure AWS credentials and enable model access for Claude Sonnet. The Quickstart Guide covers provider configuration.

The development version is not claimed to be available from a registry. Add it directly from this repository:

[dependencies]
strands-agents = { git = "https://github.com/gautamsirdeshmukh/strands-rs" }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

For a local checkout:

[dependencies]
strands-agents = { path = "../strands-rs/crates/strands-agents" }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

use strands_agents::agent::InvokableAgent;
use strands_agents::Agent;

#[tokio::main]
async fn main() -> strands_agents::Result<()> {
    let agent = Agent::new()?;
    let result = agent
        .invoke("What is the square root of 1764?".into(), None)
        .await?;

    println!("{:?}", result.last_message);
    Ok(())
}

The examples cover tools, model providers, MCP, telemetry, graphs, swarms, and agents as tools.

TypeScript and Python

The same agent loop is available from TypeScript and Python through drop-in Agent facades that run the loop in the Rust strands-engine child process. Declared tools still execute in your own process. See the package READMEs for install and the full supported surface: @strands-agents/sdk-rust (TypeScript) and strands_rust (Python).

TypeScript — add @strands-agents/sdk-rust and its @strands-agents/sdk peer to package.json, then:

import { Agent } from "@strands-agents/sdk-rust";

const agent = new Agent({ model: "global.anthropic.claude-opus-5" });
const result = await agent.invoke("What is the square root of 1764?");
console.log(result.lastMessage);

Python — add strands-agents-sdk-rust (or pip install it), then:

from strands_rust import Agent

agent = Agent(model="global.anthropic.claude-opus-5")
result = agent("What is the square root of 1764?")
print(result.message)

A bare model id string selects Amazon Bedrock; pass a model instance to use another provider. Constructs that can't cross the process boundary (custom models, unsupported config) fail closed with UnsupportedInRustRuntimeError.

Documentation

For detailed guidance and examples:

• User Guide
• Quick Start Guide
• Agent Loop
• Examples
• Rust API landing page
• Production and Deployment Guide

Generate the complete API reference locally with:

cargo doc --workspace --all-features --no-deps --locked --open

Documentation sources live under website/, and documentation PRs are welcome alongside code changes.

Development

Git operations are performed at the repository root. The Rust workspace uses the toolchain pinned in rust-toolchain.toml:

cargo fetch --locked
cargo build -p strands-agents --all-features --locked
cargo test --workspace --all-targets --all-features --locked -- --test-threads=1
cargo fmt --all -- --check
cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
cargo check -p strands-agents --all-targets --no-default-features --locked
cargo package -p strands-agents --allow-dirty --locked

Run the documentation site:

cd website
npm ci
npm run dev

Do not deploy test-infra for ordinary SDK development. Infrastructure-backed integration tests use pre-provisioned resources in CI.

Contributing

We welcome contributions. See the Contributing Guide for:

• Reporting bugs and feature requests.
• Development setup and verification.
• Contributing through pull requests.
• Code of conduct expectations.
• Security reporting.

Stay in Touch with the Team

Meet the Strands team and other users on Discord.

License

This project is licensed under the Apache License 2.0. See LICENSE.APACHE.

Security

See CONTRIBUTING for security reporting instructions.