Strands Agents · 00 Overview

Strands Agents Overview

An open-source toolkit for building and running AI agents, driven by the model

Source: sdk · harness
Strands Agents · 00 Overview

Who am I?

Tinkerer · Cloud · IoT · Robotics · Generative AI

 

https://chiwaichan.co.nz
https://nz.linkedin.com/in/chiwaichan
https://github.com/chiwaichan
https://x.com/chiwaichanconz

Strands Agents · 00 Overview

Agenda

  • What Strands Agents is, and where it came from
  • The model-driven approach and the agent loop
  • The toolkit: Strands harness, Strands Harness SDK, Strands Shell, Evals SDK
  • A tour of what you build with: models, tools, memory, context, control
  • Running it: observability, security, deployment
  • The series ahead, deck by deck
Source: llms.txt · sdk · harness
Strands Agents · 00 Overview

Part 1

What Strands Agents is

Strands Agents · 00 Overview

What is Strands Agents?

  • An open-source SDK for building and running AI agents in Python and TypeScript
  • Takes a model-driven approach: the model plans, picks tools and reflects
  • You define a prompt and a list of tools in code, then test locally and deploy
  • Amazon Bedrock is the default; Anthropic, OpenAI, Google and Ollama also work
  • Licensed under Apache 2.0, and built in the open on GitHub

"Like the two strands of DNA, Strands connects two core pieces of the agent together: the model and the tools."

Source: llms.txt · introducing-strands-agents
Strands Agents · 00 Overview

A library, not a platform

  • Strands runs inside your own process
  • Creating an agent is constructing an object in Python or Node.js
  • There is no hosted control plane, scheduler or database to stand up first
  • The only service the agent reaches is the model provider
  • An AWS account is only required if you keep the default provider
  • Adding an agent to a FastAPI, Express or Next.js app is a dependency and a few lines
Source: quickstart-overview · choosing-an-agent-foundation
Strands Agents · 00 Overview

The smallest agent

from strands import Agent

agent = Agent()
agent("Explain the agent loop in one sentence.")

import { Agent } from '@strands-agents/sdk'

const agent = new Agent()
const result = await agent.invoke('Explain the agent loop in one sentence.')
console.log(result.lastMessage)
  • The smallest agent is a model with the loop around it
Source: sdk
Strands Agents · 00 Overview

The Strands toolkit at a glance

Your code calls the Strands harness or the Strands Harness SDK inside your own process, the harness is built on the SDK, the SDK calls model providers and tools, Strands Shell is a virtual shell, and the Evals SDK scores the agent

Source: harness · sdk · quickstart-overview · shell · evals-sdk · tools
Strands Agents · 00 Overview

How Strands got here

Timeline of four milestones: Strands Agents announced in May 2025, version 1.0 in July 2025, the model-driven approach post in September 2025, and Strands harness in September 2026

Source: introducing-strands-agents · strands-agents-1-0 · strands-agents-model-driven-approach · introducing-strands-harness
Strands Agents · 00 Overview

Part 2

The model-driven approach

Strands Agents · 00 Overview

Why model-driven?

  • Earlier frameworks: orchestration logic, state machines, predefined workflows
  • Those agents often broke on scenarios nobody anticipated during development
  • Modern models reason, plan and select tools natively
  • So Strands lets the model drive its own behaviour and adapt as it goes
  • When an API call fails, the model reasons about alternatives instead of crashing
  • Q Developer teams went from months to days and weeks to ship a new agent
Source: strands-agents-model-driven-approach · introducing-strands-agents
Strands Agents · 00 Overview

An agent is three things

Component What you provide
Model Any model with reasoning and tool use, from a supported provider
Tools Python functions with @tool, prebuilt tools, or MCP servers
Prompt The task, plus an optional system prompt for general behaviour
  • The agent uses the model to direct its own steps and to use tools
  • It interacts with its model and tools in a loop until the task is complete
Source: introducing-strands-agents
Strands Agents · 00 Overview

The agent loop

Input and context enter the agent loop, where the model reasons, selects a tool and Strands executes it, the result is added to context and the loop repeats until a final response, with limits, cancellation, hooks and retries as controls

Source: agent-loop · introducing-strands-agents · strands-agents-model-driven-approach
Strands Agents · 00 Overview

Guiding the model through context

  • The model drives, but its behaviour is shaped by the context it receives
  • System prompts set the role and goals, and describe what success looks like
  • Tool specifications define capability boundaries and usage guidance
  • Conversation history keeps continuity, and needs managing as it grows
  • A shift from procedural programming to contextual programming

Instead of writing "if this, then that" logic, you craft the context that helps the model figure out the best approach.

Source: strands-agents-model-driven-approach
Strands Agents · 00 Overview

Framework, or your own loop?

Job a production agent needs Strands Your own loop
Limits, cancellation, stop reasons Built-in DIY
Tools, structured output, streaming Built-in DIY
MCP Built-in client DIY
Multi-agent Graph, swarm, agents as tools DIY
Memory, sessions, guardrails, interventions Built-in DIY
Model provider portability Built-in (many) Per provider
Tracing and observability OpenTelemetry-native DIY
Evaluation Companion Evals SDK DIY
Source: choosing-an-agent-foundation
Strands Agents · 00 Overview

Part 3

The toolkit: harness, SDK, Shell, Evals

Strands Agents · 00 Overview

Strands harness

# pip install strands-harness
from strands_harness import create_harness

agent = create_harness()
agent("Research the top three vector databases, compare pricing and limits, and write it up in comparison.md")
  • A fully assembled, state-of-the-art agent harness in one import
  • Benchmarked defaults for tools, context management, sessions, memory and hooks
  • Opinionated but not restrictive: every default is overridable
  • Returns a standard Strands Agent, with no wrapper or hidden abstraction
  • TypeScript: createHarness from @strands-agents/harness
Source: harness · introducing-strands-harness
Strands Agents · 00 Overview

What the default harness does

  • Runs on the model of your choice, with reasoning turned on
  • Follows a tuned system prompt: explore first, then act, verify before finishing
  • Has a shell, file tools (read, write, edit) and web access
  • Manages its own context window and caches the reused parts of each request
  • Keeps long-term memory across runs, and resumes a conversation from a session id
  • Delegates subtasks to a built-in helper agent, and loads Agent Skills when present
Source: harness
Strands Agents · 00 Overview

Strands harness or the Strands Harness SDK?

If you want to… Start with
Get a complete agent harness with tested defaults Strands harness
Build the agent harness yourself, piece by piece Strands Harness SDK
Start on Strands harness and drop down for more control later Compose with the Strands Harness SDK

Two starting points, and you can move between them without a rewrite.

Source: sdk · quickstart-overview
Strands Agents · 00 Overview

One stack, two starting points

Strands harness with a tuned system prompt, shell, file and web tools, context management and memory sits on top of the Strands Harness SDK with the agent loop, tools, memory, plugins and interventions, and create_harness returns a standard Agent

Source: harness · sdk · quickstart-overview · llms.txt
Strands Agents · 00 Overview

Strands Shell

  • A Bourne-compatible shell that runs inside your own process
  • Ships grep, sed, jq, curl, find and more without calling fork or exec
  • It can reach only the host files, URLs and credentials you declare
  • Runs from Python, Node.js or a built-in MCP server
Docker Cloud sandbox Strands Shell
Cold start ~200ms ~1s (network) under 1ms
Isolation Container namespace MicroVM In-process VFS
Network iptables or sidecar Platform policy URL allowlist plus SSRF guard
Source: shell · shell-how-it-works
Strands Agents · 00 Overview

Strands Evals SDK

pip install strands-agents-evals

# One-off check: does the agent's answer contain "Paris"?
strands-evals run \
  --input "What is the capital of France?" \
  --expected-output "Paris" \
  --agent my_agent:build_agent
  • Measure an agent before you ship it, and watch it after
  • Evaluators score output and trajectory; detectors find failures and their root cause
  • Red teaming probes for unsafe behaviour; simulators stand in for users and tools
  • Evaluator groups: quality, safety, multimodal, agentic, skill, deterministic, custom
Source: evals-sdk · evaluators
Strands Agents · 00 Overview

Part 4

A tour of what you build with

Strands Agents · 00 Overview

Getting started and the agent loop

  • Quickstarts for Python and TypeScript: install, pick a provider, run, add a tool
  • The loop: invoke the model, run the tool it asks for, repeat until a final response
  • Invocation limits cap the turns and tokens one call may use
  • Cancellation stops a running agent mid-loop with agent.cancel()
  • Stop reasons report why the loop ended, such as cancelled or limit_turns
  • Limit stop reasons leave history valid, so you can reinvoke with a higher budget
Source: quickstart-overview · agent-loop
Strands Agents · 00 Overview

Model providers

from strands import Agent
from strands.models.anthropic import AnthropicModel

agent = Agent(model=AnthropicModel(
    client_args={"api_key": "<KEY>"}, model_id="claude-sonnet-5"))
print(agent("What can you help me build?"))
  • The model is one object you hand to the agent; the rest of the code does not change
  • First-party providers include Amazon Bedrock, Anthropic, OpenAI and Google
  • Community packages add more, and a custom provider interface covers anything else
  • Streaming, tool calling and structured output work on every first-party provider
  • Prompt caching is the capability that varies most between providers
Source: quickstart-overview · model-providers
Strands Agents · 00 Overview

Tools

from strands import Agent, tool

@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"It's sunny in {city}."

agent = Agent(tools=[get_weather])
agent("What's the weather in Seattle?")
  • You pass tools to an agent, and the agent decides when to call them
  • Works with tools you write, prebuilt tools, and any MCP server
  • Tools run with the permissions of the host process, so audit what each one does
Source: tools
Strands Agents · 00 Overview

Streaming and structured output

from pydantic import BaseModel, Field
from strands import Agent

class PersonInfo(BaseModel):
    name: str = Field(description="Name of the person")
    age: int = Field(description="Age of the person")

result = Agent()("John Smith is a 30 year-old software engineer", structured_output_model=PersonInfo)
person_info: PersonInfo = result.structured_output
  • Streaming: text tokens, tool calls and lifecycle events as they occur
  • Structured output: define a schema, pass it in, read a validated object back
Source: streaming · structured-output
Strands Agents · 00 Overview

Sessions and memory

  • A session persists conversation history and agent state across restarts and requests
  • Built-in persistence captures and restores it automatically through a session manager
  • By default an agent starts every conversation from zero
  • MemoryManager adds long-term memory that persists across sessions
  • It does three jobs across memory stores: recall, injection and extraction
  • Stores: a zero-setup test store, Amazon Bedrock Knowledge Bases, or your own
Source: session-management · memory-overview
Strands Agents · 00 Overview

Context management

from strands import Agent

agent = Agent(context_manager="auto")
Value Behaviour
"auto" Background compression with tuned defaults. No model involvement.
"agentic" Model-driven: the model manages its own context.
Custom config Full control over the strategy pipeline, targets and conditions.
false No context management. Overflow errors propagate directly.
Source: context-management
Strands Agents · 00 Overview

Hooks and plugins

  • Hooks add logging, validation or custom logic at any point in the agent loop
  • A hook event marks a point in the lifecycle; a callback runs when it fires
  • Register one with agent.add_hook(), for events such as BeforeToolCallEvent
  • Plugins change the typical behaviour of an agent by composing on its primitives
  • Built-in plugins: Skills, Context Offloader, Context Injector and GoalLoop
  • Or write your own plugin that registers hooks and tools and manages state
Source: hooks · plugins
Strands Agents · 00 Overview

Interventions

  • A composable control layer: authorization, guardrails, steering, content transformation
  • Handlers return typed decisions: proceed, deny, guide, confirm, transform
  • The framework applies them with ordered evaluation and short-circuiting
  • Human in the loop: a person approves, edits or rejects a tool call
  • Steering: context-aware guidance that appears when relevant
  • Cedar authorization: Cedar policies evaluated before each tool call
Source: interventions · human-in-the-loop · steering · cedar-authorization
Strands Agents · 00 Overview

Multi-agent

from strands import Agent

weather_agent = Agent(
    name="weather_agent",
    description="Answers questions about the weather.",
    system_prompt="You are a weather specialist.",
)
orchestrator = Agent(
    system_prompt="Route weather questions to weather_agent; answer the rest yourself.",
    tools=[weather_agent],
)
orchestrator("What should I pack for Seattle this weekend?")
Source: multi-agent-patterns
Strands Agents · 00 Overview

Five ways to compose agents

Five multi-agent patterns side by side: agents as tools with an orchestrator and specialists, a swarm handing off between agents, a graph with branching and loops, a workflow of tasks, and two agent services connected by the A2A protocol

Source: multi-agent-patterns · strands-agents-1-0
Strands Agents · 00 Overview

Voice

agent = BidiAgent(
    model=model,
    system_prompt="You are a helpful voice assistant. Keep responses concise and natural."
)
audio_io = AudioIO()

async def main():
    await agent.run(inputs=[audio_io.input()], outputs=[audio_io.output()])
  • BidiAgent listens and talks in real time over a persistent connection
  • Three providers: Amazon Nova Sonic, OpenAI and Gemini Live
  • Handles barge-ins and tool calls mid-conversation; Python SDK only
Source: bidi-quickstart · quickstart-overview · llms.txt
Strands Agents · 00 Overview

Part 5

Running it in production

Strands Agents · 00 Overview

Observability

  • All observability APIs are embedded directly in the SDK
  • Three telemetry primitives: traces, metrics and logs
  • A trace is one end-to-end request; its spans are model and tool invocations
  • Model spans can carry the system prompt, parameters, messages and token usage
  • Metrics include tool invocations, latency, agent loop count and token usage
  • Strands uses OpenTelemetry to emit to any OTEL-compatible backend
Source: observability · introducing-strands-agents
Strands Agents · 00 Overview

Security and guardrails

bedrock_model = BedrockModel(
    guardrail_id="your-guardrail-id",         # Your Bedrock guardrail ID
    guardrail_version="1",                    # Guardrail version
    guardrail_trace="enabled",                # Enable trace info for debugging
)
agent = Agent(system_prompt="You are a helpful assistant.", model=bedrock_model)
  • Guardrails screen what reaches the model and what it returns
  • Content filtering, PII detection and redaction, and topic boundaries
  • Configured per model provider; Amazon Bedrock guardrails integrate directly
  • When a Bedrock guardrail triggers, the stop reason is guardrail_intervened
Source: guardrails · sdk
Strands Agents · 00 Overview

Deployment targets

The same Strands agent code deploys to Bedrock AgentCore Runtime, AWS Lambda, AWS Fargate, AWS App Runner, Amazon EKS, Amazon EC2, or Docker, Kubernetes and Terraform, and from there calls a model provider and sends telemetry to an OpenTelemetry backend

Source: llms.txt · sdk · operating-agents-in-production · observability
Strands Agents · 00 Overview

Python and TypeScript

Feature Python TypeScript
Agents, streaming, structured output ✅ ✅
Bedrock, OpenAI, Anthropic, Google, custom providers ✅ ✅
Custom function tools, MCP ✅ ✅
Vended tools (files, HTTP, notebooks, shell) ✅ ✅
Hooks, sessions, steering, OpenTelemetry ✅ ✅
Swarm, graph, workflow, agents as tools, A2A ✅ ✅
Voice (bidirectional streaming) ✅ ❌
Source: quickstart-overview · tools · vended-tools
Strands Agents · 00 Overview

Versioning and Strands Labs

  • The SDK follows semantic versioning: MAJOR.MINOR.PATCH
  • Minor and patch upgrades should not need code changes
  • Features in strands.experimental can change between minor versions
  • MCP, A2A and OpenTelemetry GenAI conventions still evolve: pin a minor version
  • Deprecated features warn first and are removed in the next major version
  • Strands Labs is the experimental arm: robots, benchmark harnesses, AI Functions
Source: versioning-and-support · labs
Strands Agents · 00 Overview

The series

  • 00 Overview · this deck
  • 01 Getting Started · Python and TypeScript
  • 02 Agent Loop · controls, state, retries
  • 03 Model Providers · Bedrock, Ollama, caching
  • 04 Tools · custom, MCP, vended, executors
  • 05 Streaming and Structured Output
  • 06 Sessions and Memory
  • 07 Context Management
  • 08 Hooks and Plugins · skills, goal loop
  • 09 Interventions · human in the loop, Cedar
  • 10 Multi-Agent · swarm, graph, workflow, A2A
  • 11 Voice · bidirectional agents, barge-in
  • 12 Harness and Shell · tools, sandboxes
  • 13 Observability · metrics, traces, logs
  • 14 Evals · evaluators, simulators, red teaming
  • 15 Security and Guardrails
  • 16 Deployment · AgentCore, Lambda, EKS
Source: llms.txt
Strands Agents · 00 Overview

Key takeaways

  • Strands is a library, not a platform: the agent is an object in your own process
  • Model-driven: the model plans and picks tools, and you shape it through context
  • An agent is a model, tools and a prompt, running in the agent loop
  • Strands harness is the assembled start; the Harness SDK is the build-it-yourself one
  • Strands Shell contains commands in-process; the Evals SDK measures the agent
  • The same agent code runs across providers and deployment targets
Source: quickstart-overview · strands-agents-model-driven-approach · harness · sdk · shell · evals-sdk
Strands Agents · 00 Overview

Up next

01 · Getting Started

Open the next deck → · All decks in the series

Strands Agents · 00 Overview

References

Strands Agents documentation and blog — 35 sources (https://strandsagents.com/<path>/)

Notes: This deck is the map for the whole series: what Strands is, the model-driven approach, the four parts of the toolkit, and a quick tour of every topic the later decks cover. Source: pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/harness/index.md

Notes: Quick hello before we start. Source: src/pages/cv.md, docusaurus.config.ts (site links)

Notes: The order follows the docs map: the four products first, then the build guides, then the run guides. Source: llms.txt, pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/harness/index.md

Notes: Section break: the one-paragraph definition, the library shape, and the product map.

Notes: The launch post says AWS teams such as Amazon Q Developer, AWS Glue and VPC Reachability Analyzer already used Strands in production before the public release. Source: llms.txt, pages/blog/introducing-strands-agents/index.md

Notes: The docs are explicit about what Strands does not add: a platform. That is the main difference from a managed service such as the AgentCore harness in the previous series. Source: pages/docs/user-guide/sdk/quickstart/overview/index.md, pages/docs/user-guide/migrate/choosing-an-agent-foundation/index.md

Notes: Both snippets are from the Harness SDK overview page. No model is passed, so the agent uses the default provider, Amazon Bedrock. Source: pages/docs/user-guide/sdk/index.md

Notes: Walk it top to bottom. Your code calls create_harness for an assembled agent or Agent for one you build yourself. The harness is built on the Harness SDK. The SDK runs the loop and calls model providers and tools. Strands Shell is a separate in-process virtual shell, and the Evals SDK scores what the agent produced and how it got there. Source: pages/docs/user-guide/harness/index.md, pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/sdk/quickstart/overview/index.md, pages/docs/user-guide/shell/index.md, pages/docs/user-guide/evals-sdk/index.md, pages/docs/user-guide/sdk/tools/index.md

Notes: The dates are the publish dates of the four posts on the Strands blog. 1.0 added four multi-agent primitives, A2A support, a session manager and async support. The harness post introduced the assembled Strands harness on top of the Strands Harness SDK, and the Strands CLI. Source: pages/blog/introducing-strands-agents/index.md, pages/blog/strands-agents-1-0/index.md, pages/blog/strands-agents-model-driven-approach/index.md, pages/blog/introducing-strands-harness/index.md

Notes: Section break: why Strands lets the model drive, and what the loop looks like.

Notes: The story in the launch post: the frameworks built for earlier models started to get in the way of what newer models could do on their own. Using the model as orchestrator does not mean giving up developer control. Source: pages/blog/strands-agents-model-driven-approach/index.md, pages/blog/introducing-strands-agents/index.md

Notes: This is the simplest definition from the launch post: a model, tools and a prompt. Everything else in the series is a way of shaping or controlling those three. Source: pages/blog/introducing-strands-agents/index.md

Notes: Invoke the model, check whether it wants a tool, run the tool, then invoke the model again with the result. Context accumulates each iteration. The loop ships with invocation limits, cancellation, stop reasons, hooks and retry strategies. Deck 02 covers all of these. Source: pages/docs/user-guide/sdk/agents/agent-loop/index.md, pages/blog/introducing-strands-agents/index.md, pages/blog/strands-agents-model-driven-approach/index.md

Notes: These three levers map to later decks: prompts in deck 02, tools in deck 04, and conversation and context management in deck 07. Source: pages/blog/strands-agents-model-driven-approach/index.md

Notes: The docs page also compares the OpenAI Agents SDK, LangGraph, the Vercel AI SDK and Pydantic AI, and says to treat the table as a starting map, not a scoreboard. It says to keep your own loop for one model, a handful of tools and short, tightly scoped runs. The trap it warns about is quietly rebuilding a framework inside your own loop. Source: pages/docs/user-guide/migrate/choosing-an-agent-foundation/index.md

Notes: Section break: the four products in the docs map.

Notes: An agent harness is the software around a model that turns it into an agent. The launch post positions the Strands harness as a general-purpose agent rather than a coding agent, and also introduces the Strands CLI, installed with npm install -g @strands-agents/cli. Source: pages/docs/user-guide/harness/index.md, pages/blog/introducing-strands-harness/index.md

Notes: Every one of these defaults can be narrowed, swapped or turned off. The harness also tracks multi-step work with a checklist and lets the model orchestrate its own tools in code. Deck 12 goes through each of them. Source: pages/docs/user-guide/harness/index.md

Notes: Strands harness is built on the Strands Harness SDK, so starting on one does not lock you out of the other. The SDK is the layer this series spends most of its time on, decks 01 to 11. Source: pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/sdk/quickstart/overview/index.md

Notes: The docs map calls the harness a thin composition layer over the Strands Harness SDK. What create_harness returns is a plain Agent, so the whole Harness SDK stays reachable, and every default is overridable. Source: pages/docs/user-guide/harness/index.md, pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/sdk/quickstart/overview/index.md, llms.txt

Notes: The docs call this a different tradeoff, not a strictly better one: a container isolates at the kernel, Strands Shell isolates at the process. Deck 12 covers the Kernel boundary and the security model. Source: pages/docs/user-guide/shell/index.md, pages/docs/user-guide/shell/how-it-works/index.md

Notes: The same evaluation is available as a Python API with eval_task, Case, Experiment and an evaluator. Model-driven agents make dynamic decisions, so evaluation matters more, not less. Deck 14 covers it. Source: pages/docs/user-guide/evals-sdk/index.md, pages/docs/user-guide/evals-sdk/evaluators/index.md

Notes: Section break: one slide per build topic, each one a later deck.

Notes: Decks 01 and 02. The agent-loop page also covers concurrent invocations, hooks and retry strategies. The quickstart overview says the guides get you running a simple agent in less than 20 minutes. Source: pages/docs/user-guide/sdk/quickstart/overview/index.md, pages/docs/user-guide/sdk/agents/agent-loop/index.md

Notes: Deck 03. The provider table also lists Ollama, LiteLLM, Mistral, Llama API, llama.cpp, SageMaker, Vercel and Writer. Source: pages/docs/user-guide/sdk/quickstart/overview/index.md, pages/docs/user-guide/sdk/model-providers/index.md

Notes: Deck 04. The tools section also covers vended tools for files, HTTP, notebooks and shell, and tool executors that control whether multiple tool calls run concurrently or in sequence. Source: pages/docs/user-guide/sdk/tools/index.md

Notes: Deck 05. The code is trimmed from the structured output page, which also has an occupation field. Streaming emits the same events whether you consume them with async iterators or with callback handlers in synchronous Python. Source: pages/docs/user-guide/sdk/streaming/index.md, pages/docs/user-guide/sdk/agents/structured-output/index.md

Notes: Deck 06. Recall and injection are enabled by default when you attach a store; writing memories is opt-in. Sessions also cover multi-agent systems: orchestrator state, node transitions and shared context. Source: pages/docs/user-guide/sdk/agents/session-management/index.md, pages/docs/user-guide/sdk/memory/overview/index.md

Notes: Deck 07. Strategies run as an ordered pipeline with an emergency truncation step appended last. The docs describe the ContextManager strategy API as experimental, and conversation managers and the ContextOffloader keep working alongside it. Source: pages/docs/user-guide/sdk/context-management/index.md

Notes: Deck 08. Hooks are composable and type-safe, and every event type accepts multiple subscribers. Skills follow the AgentSkills specification. Source: pages/docs/user-guide/sdk/agents/hooks/index.md, pages/docs/user-guide/sdk/plugins/index.md

Notes: Deck 09. Unlike raw hooks and plugins, which mutate event objects directly, intervention handlers return decisions. With Cedar, if no permit statement matches, the tool call is denied and the agent gets feedback explaining why. Source: pages/docs/user-guide/sdk/agents/interventions/index.md, pages/docs/user-guide/sdk/agents/interventions/human-in-the-loop/index.md, pages/docs/user-guide/sdk/agents/interventions/steering/index.md, pages/docs/user-guide/sdk/agents/interventions/cedar-authorization/index.md

Notes: Deck 10. The simplest way to compose agents is to pass one agent to another as a tool. The orchestrator reads each specialist's description and calls it when the query fits, exactly as it would call any other tool. Source: pages/docs/user-guide/sdk/multi-agent/multi-agent-patterns/index.md

Notes: Agents as tools: an orchestrator delegates to specialists. Swarm: a pool of agents that hand off to one another. Graph: a flowchart of agents with branching and loops. Workflow: a fixed task graph run as a single tool, with independent tasks in parallel. A2A: agents running as separate services. The 1.0 post says the patterns nest and combine. Source: pages/docs/user-guide/sdk/multi-agent/multi-agent-patterns/index.md, pages/blog/strands-agents-1-0/index.md

Notes: Deck 11. Install with pip install "strands-agents[bidi-all]"; AudioIO for a local microphone and speakers also needs PortAudio and the bidi-pyaudio extra. The quickstart needs Python 3.10 or later, and 3.12 or later for Nova Sonic. The docs map says session management and interrupt support for BidiAgent are still in development. Source: pages/docs/user-guide/sdk/bidi/quickstart/index.md, pages/docs/user-guide/sdk/quickstart/overview/index.md, llms.txt

Notes: Section break: observe, secure, deploy, and what is supported where.

Notes: Deck 13. Traces show how the agent arrived at its answer, which feeds back into prompt, tool and context management improvements. Source: pages/docs/user-guide/sdk/observability-evaluation/observability/index.md, pages/blog/introducing-strands-agents/index.md

Notes: Deck 15. The SDK overview lists guardrails, PII redaction and trusted message history under securing for production. The guardrails page also shows how to run them in shadow mode before you enforce. Source: pages/docs/user-guide/sdk/safety-security/guardrails/index.md, pages/docs/user-guide/sdk/index.md

Notes: Deck 16. The docs have one guide per target. The operating-in-production page adds the checklist: configure the model explicitly, pass an explicit tool list, and keep automatic tool loading disabled, which is the default. Source: llms.txt, pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/sdk/deploy/operating-agents-in-production/index.md, pages/docs/user-guide/sdk/observability-evaluation/observability/index.md

Notes: This condenses the feature availability table on the quickstart overview page. The series shows Python first and TypeScript where the two differ. The vended tools row comes from the vended tools page, which lists the file editor, HTTP request, notebook and bash tools for both languages. Source: pages/docs/user-guide/sdk/quickstart/overview/index.md, pages/docs/user-guide/sdk/tools/index.md, pages/docs/user-guide/sdk/tools/vended-tools/index.md

Notes: Labs projects move faster than the core SDK. Some graduate into it or become standalone products, and others stay experimental. Each lives in its own repository under the strands-labs organization. Source: pages/docs/user-guide/sdk/versioning-and-support/index.md, pages/docs/labs/index.md

Notes: One deck per fortnight, in the order of the docs map: build topics first, then the run topics. The series page lists every deck with its post. Source: llms.txt

Notes: Leave the audience with the map: four products, one loop, and a model that drives. Every later deck fills in one box on that map. Source: pages/docs/user-guide/sdk/quickstart/overview/index.md, pages/blog/strands-agents-model-driven-approach/index.md, pages/docs/user-guide/harness/index.md, pages/docs/user-guide/sdk/index.md, pages/docs/user-guide/shell/index.md, pages/docs/user-guide/evals-sdk/index.md

nav:up-next

Notes: That's the end of the Overview. Next up is Getting Started; the series page lists every deck in order.

Notes: All content in this deck comes from these Strands Agents documentation and blog pages. Source: strands-agents-docs-live/pages and llms.txt