Start with a complete agent.

/harness

Strands harness gives you an agent with tools, memory, session management, and context management already configured. Replace individual components to fit your use case.

npm install @strands-agents/harness
TypeScript

          
          import { createHarness } from "@strands-agents/harness"
        
          
          
        
          
          const agent = await createHarness()
        
          
          await agent.invoke("Summarize what this repository does")
        
Build an agent

Built on

Control and improve your agent

Sandbox agent work

/box

Run agents in an OS-enforced sandbox. Set which files, programs, and network destinations they can access.

Explore Strands Box
Policy

          
          @id("no_deletes")
        
          
          forbid (principal, action == Box::Action::"fs:delete", resource);
        
          
          
        
          
          @id("push_after_tests")
        
          
          forbid (principal, action == Box::Action::"shell:spawn", resource)
        
          
          when { context.input.program == "git" &&
        
          
                 context.input has arg1 && context.input.arg1 == "push" }
        
          
          unless temporal {
        
          
            formerly within 1h (Box::Action::"shell:spawn"::response{
        
          
              input.program: "npm", input.arg1: "test", output.status: 0
        
          
            })
        
          
          };
        

Validate agent behavior

/evals

Run evaluations, detect failures, and measure agent behavior before deployment.

Run an evaluation
Python

          
          from strands import Agent
        
          
          from strands_evals import eval_task, Case, Experiment
        
          
          from strands_evals.evaluators import OutputEvaluator
        
          
          
        
          
          @eval_task()
        
          
          def task():
        
          
              return Agent(system_prompt="You are helpful.")
        
          
          
        
          
          cases = [Case[str, str](
        
          
            input="Capital of France?", expected_output="Paris")]
        
          
          
        
          
          Experiment[str, str](cases=cases,
        
          
            evaluators=[OutputEvaluator(rubric="Correct?")],
        
          
          ).run_evaluations(task)
        

Make fast decisions

/decider

Route, classify, or score known outcomes with a small decision model that reports confidence.

Explore the models
Shell

          
          strands-decider ask \
        
          
            StrandsAgents/strands-decider-2B-qwen3.5-v1-2610 \
        
          
            --state "Help! My payouts have been failing for 3 days." \
        
          
            --choice "Which team should handle this?=billing,technical,sales"
        

Use Cases

Built for the agent you need

Automate multi-step processes, ship assistants that reason over your own data, run research agents that work autonomously, or control robots in the physical world.

strands-agents/samples

lead_router.ts

1 import { createHarness } from '@strands-agents/harness'
2 import { tool } from '@strands-agents/sdk'
3 import z from 'zod'
4
5 const classifyLead = tool({
6 name: 'classify_lead',
7 description: 'Score and classify a lead.',
8 inputSchema: z.object({
9 email: z.string(),
10 company: z.string(),
11 }),
12 callback: ({ email, company }) => {
13 const data = crm.lookup(company)
14 return {
15 leadId: crm.createLead(email, company),
16 score: computeIcpScore(data),
17 segment: data.industry,
18 }
19 },
20 })
21
22 const routeToRep = tool({
23 name: 'route_to_rep',
24 description: 'Assign a lead to a rep.',
25 inputSchema: z.object({
26 leadId: z.string(),
27 region: z.string(),
28 }),
29 callback: ({ leadId, region }) => {
30 const rep = crm.getRepForRegion(region)
31 crm.assign(leadId, rep)
32 return `Assigned to ${rep}`
33 },
34 })
35
36 const agent = await createHarness({
37 tools: [classifyLead, routeToRep],
38 })
39
40 await agent.invoke(
41 'New lead: jane@acme.com, Acme Corp, US-West'
42 )

At Smartsheet, we chose Strands for our next generation of AI capabilities because it provided the perfect balance of enterprise-ready features and development efficiency. Its robust conversation memory and dynamic tool registration systems were crucial for creating a responsive, context-aware intelligent AI assistant. With Strands, we were able to quickly implement a secure and scalable solution, giving us a production-ready foundation to deliver a secure, high-performance, and enterprise-grade AI experience.

JB Brown

VP Engineering, Smartsheet

At Skai, our customers rely on Studio’s agents to make changes in live ad accounts across retail media, search and social. Strands gave us the ability to keep humans in control. Every agent step in Studio runs on Strands in AgentCore Runtime. Using hooks and interrupts ensure an agent stops and waits for approval before it touches a campaign, without forking the agent loop.

Lior Heber Knimach

VP Innovation, Skai

Transform traditional error alerts into intelligent incident responses using Amazon Bedrock, RAG with Amazon OpenSearch, Multi-Agent Orchestration with Strands SDK, and Kiro AI IDE - reducing MTTR by 60% without manual coding.

Harsha Mathan

Data Engineering Manager, Verisk Analytics

Strands’ SDK and great integration with AWS native services streamlined Landchecker’s development of agents. With easier integration of AgentCore Runtime, Bedrock Guardrails, and built-in support for OpenTelemetry, we could focus on what we do best – developing property information tools and data integrations.

Rupert de Guzman

CTO, Landchecker

At Swisscom, we need an agentic AI backbone that is both enterprise-ready and future-proof. Strands Agents gives us the best of both worlds: a native fit with our cloud environment, yet fully open source and flexible. That combination allowed us to build proof-of-concepts within just a few weeks and now sets us on the path to scale multi-agent systems with confidence, while keeping our focus on delivering real value to customers and the business.

Arun Sittampalam

Director of Product Management, Swisscom

The advisor is where things get interesting. We use the Strands Agents SDK to define an agent with a tool, a function the model can call during its reasoning loop.

Anton Ganhammar

Principal Engineer, Elva

We chose Strands because it’s AWS-native, intuitive, and made agent development accessible across our engineering team. Its abstraction layer and built-in multi-agent patterns (like Agent-as-Tool and Swarm) let us focus on remediation logic instead of infrastructure work. We’ve already built multiple agents, and wiring them together has been seamless. On top of that, we layered our Agentic Remediation™ capability to automate vulnerability fixes and configuration validation/fault correction workflows, coordinating cross-agent remediation with precision

Ben Seri

CTO & Co-Founder, Zafran Security

Scaling our global trading platform required reimagining our support capabilities, and Strands Agents was the key to making it happen at enterprise scale. What would traditionally take months of development, Strands allowed us to achieve in just 10 days - delivering a secure, robust, production-ready agentic solution. The results speak for themselves: investigation time dropped on average from 30 minutes to 45 seconds, investigation quality improved by 94%, and we saved $5M in operational costs. Strands didn’t just accelerate our development - it gave us the confidence to explore other agentic AI use cases across our entire business, including launching our Agentic Security Operations Center

Bryn Newell

CIO, Eightcap

Adding bidirectional voice to my existing Strands agent was surprisingly straightforward. BidiAgent handles the WebSocket complexity and interruption logic, my @tool functions carried over unchanged, and the same code deploys to AgentCore without modification. Strands made real-time voice feel like a natural extension, not a separate project.

Darryl Ruggles

Cloud Solutions Architect, Ciena

We see Strands as a great fit to power TeamForm’s next evolution of Agentic AI. Our customers need enterprise-grade security and scalability, which is exactly what Strands delivers. Its seamless integration with AWS and simplicity enables us to focus on innovating our AI capabilities and delivering value to our customers.

David Marozas

Head of Engineering, TeamForm

For Jit’s infrastructure drift detection agent, we leverage Strands Agents, an open-source framework developed by AWS for building production-ready AI agents. Strands Agents provides several advantages including simplified development, native AWS integration, and built-in security.

David Melamed

Co-Founder & CTO, Jit

As someone who builds agents with LangGraph daily at work, Strands was a genuine surprise. The model-driven approach cut my setup from 40 lines to 3 — and for the 80% case, it just works without sacrificing flexibility.

Tetiana Mostova

Software Engineer & AWS Community Builder

Strands Agents on Bedrock turns autonomous agents into an enterprise product: governed, observable, and safe by design. Together with Claude models, we analyze live webpages and generate code responsibly - helping customers reduce risk while accelerating delivery. Safety is non-negotiable in offensive security. On Amazon Bedrock, Strands Agents plus Claude let us scale autonomous pen-testing with Bedrock Guardrails - increasing coverage without increasing risk.

Gal Malachi

Co-founder & CTO, Terra Security

The combination of the Strands Agents SDK and Tavily represents a significant advancement in enterprise-grade research agent development. This integration can help organizations build sophisticated, secure, and scalable AI agents while maintaining the highest standards of security and performance. Learn more in this blog.

Dean Sacoransky

Forward Deployed Engineering Leader, Tavily

Strands was used to build a growing set of agents that run a company to do actual tasks.

Jacob Verhoeks

AWS Community Builder / Field CTO Data & AI

Community & learning hub

Tutorials, deep-dive articles, and community projects to help you go from your first agent to production, and connect with others building on Strands.

Start learning

FAQ

Start with five common questions about choosing, building, evaluating, and deploying an agent.

View all FAQs
Should I use Strands harness or the Strands Harness SDK?

Strands harness gives you a complete agent harness with defaults you can replace. Use the SDK when you want to choose and wire the components yourself.

Should I use Python or TypeScript?

Choose the SDK that matches your runtime. Both cover the core agent loop; check the feature pages for gaps such as Python-only bidirectional agents.

Should I build a custom tool or use an MCP tool?

Use a custom tool for code registered directly with an agent. Use an MCP tool when the capability comes from an MCP server. You can use both together.

How do I evaluate a Strands agent before production?

Use Strands Evals to run repeatable cases, score the agent's output and behavior, and diagnose failed runs before production.

Where can I deploy a Strands agent?

Strands agents run inside your application process, which you can deploy to a serverless platform, a container or Kubernetes environment, or a managed agent runtime.

Push the boundaries of what agents can do.