AWS quietly shipped two pieces of infrastructure in the back half of 2026 that change how agent development gets done on top of Bedrock: a maturing Strands Agents SDK, now at version 1.59.0, and a brand-new open-weight model called Strands Decider 2B, released October 1, 2026, built specifically to make the small, fast choices an agent makes dozens of times per task. Neither tool gets much mainstream coverage, but developer search interest tells a different story: “strands sdk” pulls roughly 1,000 monthly US searches with low competition, and the GitHub repo for the core SDK has already crossed 8,800 stars.
This tutorial walks through the entire setup from a blank terminal to a deployed, multi-tool agent that uses Strands Decider for routing decisions. You will install the SDK, wire up a model provider, attach custom tools, run the Decider model locally, stream responses, and ship the result to AWS Lambda and Bedrock AgentCore. Budget 90 to 120 minutes if this is your first agent framework, less if you have already touched LangChain, CrewAI, or the Claude Agent SDK.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is the AWS Strands Agents SDK, and Why It Matters Right Now
Strands Agents is AWS’s open-source, model-driven framework for building AI agents in Python and TypeScript. It launched as a preview in May 2025 and reached a production-ready 1.0 release on July 15, 2025, adding production-ready orchestration, with AWS reporting over 2,000 GitHub stars and 150,000 PyPI downloads within that early window. By October 2026 the project had grown past 8,800 stars on its main sdk-python repository, and AWS had layered a higher-level “Harness SDK” on top, reachable through a single create_harness() call for teams that want a pre-tuned agent instead of assembling one piece by piece.
The pitch is simple: define a system prompt, a set of Python functions decorated as tools, and a model provider, then let Strands run the agent loop. That loop (call the model, parse tool calls, execute tools, feed results back, repeat) is the same pattern every agent framework implements, but Strands keeps it unusually thin and model-agnostic. The SDK ships built-in support for Amazon Bedrock, Anthropic, OpenAI (including the Responses API), Google Gemini, Cohere, Mistral AI, Ollama, llama.cpp, LiteLLM, SageMaker, and Writer, each behind its own provider class, so switching from a Claude model to a self-hosted Llama checkpoint is a one-line change rather than a rewrite. That flexibility is part of why Strands shows up next to self-hosted Ollama setups and multi-model LiteLLM routers in a growing number of production stacks.
What makes late 2026 a reasonable moment to pick this up: Bedrock AgentCore reached general availability as the managed runtime for Strands agents, giving teams a path from a laptop script to a session-isolated, auto-scaling deployment without hand-rolling a container pipeline. Combined with Strands Decider, a model purpose-built to sit inside that loop and make routing calls fast, the framework now covers the full span from prototype to production on one AWS-native stack.
There is also a structural reason Strands has grown the way it has. Most agent frameworks pick a side early: some lock you into a single model vendor, others optimize for graph-based workflow complexity at the cost of a steep learning curve. Strands tries to stay unopinionated about both. The core Agent class does not care whether the underlying model is a Bedrock-hosted Nova model, a self-hosted Llama checkpoint behind Ollama, or a frontier API from Anthropic or OpenAI, and the tool-calling interface stays identical across all of them. That is why teams comparing frameworks for a Bedrock-centric stack tend to land on Strands rather than retrofitting a vendor-neutral tool onto AWS-specific services after the fact.
Meet Strands Decider 2B: A Model Built to Make Decisions, Not Essays
Most of the tokens an agent burns during a multi-step task do not go toward generating prose. They go toward small decisions: which tool to call, which of three retrieved documents is most relevant, whether a step succeeded or needs a retry. Running a full frontier model for every one of those micro-decisions is slow and expensive. Strands Labs built Strands Decider 2B to fill that gap, and released it as open source under the Apache 2.0 license on October 1, 2026.
Decider is a 1.9 billion parameter decoder model with a lightweight pointer head, roughly a million extra parameters, swapped in for the usual language-modeling head. Instead of generating free text, it scores a fixed set of candidate options and returns a calibrated confidence value for each one. On an Nvidia RTX 3090, AWS and independent benchmarks both clock median latency at about 115 milliseconds, with a 95th-percentile figure near 299 milliseconds. That is fast enough to sit inside an agent’s decision loop without becoming the bottleneck, and small enough to run on a local CPU, a consumer GPU, or an Apple Silicon Mac.
Strands Labs also published four size variants of the same underlying approach, trading model size for both speed and accuracy on their internal JevBench evaluation. The numbers below come directly from the project’s published benchmark table on GitHub.
| Variant | Approx. Memory | Median Latency | JevBench Accuracy |
|---|---|---|---|
| strands-decider-E2B | ~9 GB | 102 ms | 0.652 |
| strands-decider-E4B | ~15 GB | 139 ms | 0.684 |
| strands-decider-12B | ~23 GB | 136 ms | 0.708 |
| strands-decider-26B-A4B | higher | 245 ms | 0.870 |
| strands-decider-2B (default) | ~4 GB | 115 ms | 0.779 |
Installing it is a single pip command, and the package exposes both a command-line interface and a local HTTP server, which means you can run it as a sidecar process next to your main agent and call it over localhost rather than embedding it directly in your Python process. That separation matters for the Lambda and AgentCore deployment steps later in this tutorial.
The pointer-head design is the detail worth understanding before you use this in production. A standard language model head predicts the next token across its entire vocabulary, which is overkill when the actual question is “pick option A, B, or C.” Decider’s pointer head instead scores a small, closed set of candidates directly, which is both why it runs so much faster than a general chat model and why it returns a usable confidence number per option rather than a single greedy token. That confidence number is calibrated against the model’s own JevBench evaluation, so a 0.78 score from Decider means roughly what a well-calibrated probability should mean, not just a relative ranking between options.
Prerequisites: Versions, Accounts, and Tools You Need First
Gather these before Step 1. Skipping any one of them is the most common reason this setup stalls halfway through.
- Python 3.10 or newer, since the strands-agents 1.59.0 package will not install on anything older.
- pip 23 or newer and a working virtual environment tool. The built-in venv module is sufficient.
- An AWS account with Bedrock model access enabled in your target region, if you plan to use Bedrock as a model provider. This is optional if you only plan to run Ollama or Decider locally.
- boto3 and botocore, kept current, since the Bedrock provider depends on them directly.
- 8 GB of free RAM minimum for running Strands Decider 2B locally on CPU. A consumer GPU with 4 to 6 GB VRAM speeds this up considerably.
- Node.js 22 or newer and npm, only if you also want to try the TypeScript SDK, which is not required for this tutorial.
- AWS CLI v2, configured with a profile that has bedrock:InvokeModel permissions, for the Bedrock and Lambda steps.
- A terminal and code editor. Nothing in this tutorial requires an IDE plugin.
Step 1: Create and Activate a Clean Python Virtual Environment
Isolate this project from whatever else lives in your global Python install. An old boto3 pin dragged in from another project is a frequent source of confusing Bedrock errors later.
mkdir strands-tutorial && cd strands-tutorial
python3 -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
python --version # confirm 3.10 or newerIf python –version reports anything below 3.10, install a newer interpreter before continuing. On macOS, run brew install [email protected] and then recreate the virtual environment with that binary explicitly.
Step 2: Install the Strands Agents SDK and the Companion Tools Package
The core package is strands-agents on PyPI, currently at version 1.59.0 as of its October 8, 2026 release. AWS recommends installing it alongside strands-agents-tools, which bundles a set of ready-made tools (web fetch, file operations, shell execution, and more) so you are not writing every tool from scratch.
pip install --upgrade pip
pip install strands-agents strands-agents-tools boto3 botocore
pip show strands-agents | grep -i versionInstalling only the base package does not pull in every provider’s client library. If you plan to use Anthropic, Gemini, OpenAI, or Ollama directly rather than through Bedrock, install the matching extra:
# Pick whichever providers you actually plan to use
pip install "strands-agents[anthropic]"
pip install "strands-agents[openai]"
pip install "strands-agents[ollama]"
pip install "strands-agents[litellm]"Each extra installs the underlying SDK that provider needs, the official OpenAI Python client for instance, without bloating the base install for people who only use Bedrock.
Step 3: Set Up AWS Credentials for Bedrock Access
Skip this step if you are only testing with Ollama or Decider locally. For Bedrock, the SDK reads standard AWS credential chains, so any of the usual methods work.
# Option A: interactive configuration
aws configure
# Option B: environment variables
export AWS_ACCESS_KEY_ID="your-access-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
export AWS_REGION="us-east-1"In the Bedrock console, open Model Access for your chosen region and request access to the models you intend to call. Model access is granted per account and per region, and a correct API call against a model you have not been granted access to returns an access-denied error that looks identical to a credentials problem, which trips up a lot of first-time setups.
Step 4: Choose and Configure Your Model Provider
Strands exposes each provider as a class you instantiate and pass to Agent(model=…). Here is the Bedrock path, the most common choice for teams already inside AWS.
from strands import Agent
from strands.models import BedrockModel
model = BedrockModel(
model_id="amazon.nova-lite-v1:0",
region_name="us-east-1"
)
agent = Agent(model=model)
print(agent("Summarize what an AI agent decision loop does in two sentences."))Swapping providers is a matter of importing a different class. To route the same agent through Ollama running locally instead:
from strands import Agent
from strands.models import OllamaModel
model = OllamaModel(host="http://localhost:11434", model_id="llama3.1")
agent = Agent(model=model)The table below maps the provider classes the SDK ships today to the extra you need and a typical use case, pulled directly from the current PyPI listing and AWS’s own documentation.
| Provider | Class | Install Extra | Typical Use |
|---|---|---|---|
| Amazon Bedrock | BedrockModel | none, built in | AWS-native production deployments |
| Anthropic | AnthropicModel | anthropic | Direct Claude API access |
| OpenAI | OpenAIModel | openai | GPT models via standard API |
| Ollama | OllamaModel | ollama | Fully local, offline development |
| LiteLLM | LiteLLMModel | litellm | Routing across 100+ providers |
| Google Gemini | GeminiModel | gemini | Gemini 3.x family access |
| Mistral AI | MistralModel | mistral | Mistral’s hosted API |
| SageMaker | SageMakerModel | sagemaker | Custom-trained model endpoints |
Step 5: Write and Run Your First Strands Agent
Save the Bedrock example from Step 4 as agent.py and run it.
python agent.pyExpected output looks like a plain text response, something close to:
An AI agent decision loop repeatedly sends context to a language model, interprets
any tool calls the model requests, executes those tools, and feeds the results back
in until the model produces a final answer instead of another tool call.If you see that kind of output, the SDK, your credentials, and your chosen model are all wired correctly. Everything from here builds on this working baseline.
Step 6: Attach Custom Tools With the @tool Decorator
Tools are what separate an agent from a chatbot. Strands turns an ordinary Python function into a callable tool with a single decorator, using the function’s type hints and docstring as the schema the model sees.
from strands import Agent, tool
@tool
def get_stock_price(ticker: str) -> str:
"""Look up the current price for a stock ticker symbol."""
fake_prices = {"AMZN": "224.50", "GOOGL": "198.10", "MSFT": "512.30"}
return fake_prices.get(ticker.upper(), "Ticker not found")
@tool
def add(a: float, b: float) -> float:
"""Add two numbers together."""
return a + b
agent = Agent(model=model, tools=[get_stock_price, add])
print(agent("What is the price of AMZN, and what would it be if it rose by 12.50?"))The model decides on its own whether a tool call is needed, which tool to call, and how to combine the result with the rest of its reasoning. You never manually route the request. That routing decision is exactly the kind of step Strands Decider was built to speed up once an agent has more than a couple of tools competing for the model’s attention.
Step 7: Install and Run Strands Decider 2B Locally
Decider ships as its own PyPI package, separate from the agent SDK, with both a CLI and a local HTTP server built in.
pip install strands-decider
strands-decider serve --port 8787On first run, the command downloads the model weights from Hugging Face, roughly 4 GB for the default 2B variant, and starts a local HTTP server. On a laptop with a decent CPU, expect the first request to take a few seconds longer than later ones while the model warms up. After that, median response time should land close to the 115-millisecond figure Strands Labs reports on an RTX 3090, and noticeably higher, though still usable, on CPU-only hardware.
Test it directly with a plain HTTP request before wiring it into an agent:
curl -X POST http://localhost:8787/decide \
-H "Content-Type: application/json" \
-d '{
"prompt": "Which tool should handle a request to look up a stock price?",
"options": ["get_stock_price", "add", "none"]
}'A working response returns the chosen option along with a calibrated confidence score, which is the detail that separates a decision model from a general-purpose chat model answering the same question in prose.
Step 8: Route Agent Decisions Through Strands Decider
With the Decider server running, call it from inside your agent code as a lightweight pre-filter before invoking the full model, particularly useful once an agent has a dozen or more tools and you want to narrow the candidate set cheaply.
import requests
def decide_tool(user_prompt: str, tool_names: list) -> str:
response = requests.post(
"http://localhost:8787/decide",
json={"prompt": user_prompt, "options": tool_names},
timeout=2
)
return response.json()["choice"]
chosen = decide_tool(
"What is the price of AMZN?",
["get_stock_price", "add", "none"]
)
print(f"Decider picked: {chosen}")This pattern keeps the expensive, general-purpose model, whichever provider you chose in Step 4, focused on reasoning and generation, while Decider handles the high-volume, low-latency classification work in front of it. For agents making hundreds of routing decisions per session, that split can meaningfully cut both latency and token spend.
Step 9: Stream Agent Responses in Real Time
Waiting for a complete response before showing anything to a user feels sluggish once an agent is doing multi-step reasoning. Strands exposes a streaming interface that yields events as they happen.
from strands import Agent
agent = Agent(model=model, tools=[get_stock_price, add])
for event in agent.stream("Explain what an AI agent is, then add 4 and 7."):
if "data" in event:
print(event["data"], end="", flush=True)Each event dictionary carries either a text delta, a tool-call notification, or a tool result, so a frontend can show “Calling get_stock_price…” style status updates rather than a blank screen while the agent works through a multi-tool task.
Step 10: Swap Model Providers Without Rewriting Your Agent
Because tools and system prompts live on the Agent object independently of the model, you can test the same agent logic across providers by changing only the model instantiation. This is useful for cost comparisons or for building the kind of fallback behavior covered in a multi-model AI router setup.
from strands.models import AnthropicModel, OpenAIModel
# Same agent, different backend, zero changes to tools or prompts
claude_agent = Agent(model=AnthropicModel(model_id="claude-haiku-5-5"), tools=[get_stock_price, add])
gpt_agent = Agent(model=OpenAIModel(model_id="gpt-6.1-sol"), tools=[get_stock_price, add])Run the same test prompts against both and compare latency, tool-call accuracy, and output quality before committing to a provider in production.
Step 11: Build a Complete Working Project, a Research Assistant Agent
Put everything together into a single file that combines a Bedrock-backed agent, two custom tools, a Decider-based routing check, and streaming output. This is the complete, runnable project referenced throughout the rest of this tutorial.
# research_agent.py
import requests
from strands import Agent, tool
from strands.models import BedrockModel
DECIDER_URL = "http://localhost:8787/decide"
@tool
def get_stock_price(ticker: str) -> str:
"""Look up the current price for a stock ticker symbol."""
fake_prices = {"AMZN": "224.50", "GOOGL": "198.10", "MSFT": "512.30"}
return fake_prices.get(ticker.upper(), "Ticker not found")
@tool
def web_summary(topic: str) -> str:
"""Return a short placeholder summary for a research topic."""
return f"Summary placeholder for topic: {topic}. Replace with a real search call."
def route_with_decider(prompt: str) -> str:
try:
r = requests.post(
DECIDER_URL,
json={"prompt": prompt, "options": ["get_stock_price", "web_summary", "none"]},
timeout=2
)
return r.json()["choice"]
except requests.exceptions.RequestException:
return "unknown"
def build_agent() -> Agent:
model = BedrockModel(model_id="amazon.nova-lite-v1:0", region_name="us-east-1")
return Agent(
model=model,
tools=[get_stock_price, web_summary],
system_prompt="You are a concise research assistant. Use tools when helpful."
)
if __name__ == "__main__":
agent = build_agent()
prompt = "What is MSFT trading at, and give me a one-line summary of quantum computing."
hint = route_with_decider(prompt)
print(f"[Decider routing hint: {hint}]")
for event in agent.stream(prompt):
if "data" in event:
print(event["data"], end="", flush=True)Run it with python research_agent.py while the Decider server from Step 7 is still running in a separate terminal. You should see a routing hint printed first, followed by the streamed agent response combining a tool-sourced stock price with a generated summary.
Step 12: Deploy the Agent to AWS Lambda
For lightweight, request-driven workloads, wrap the agent in a Lambda handler. AWS’s own guidance identifies Lambda as a standard integration target for Strands-based workflows.
# lambda_handler.py
from research_agent import build_agent
agent = build_agent()
def lambda_handler(event, context):
prompt = event.get("prompt", "Say hello.")
result = agent(prompt)
return {
"statusCode": 200,
"body": str(result)
}Package the function with its dependencies, either as a .zip deployment or a container image given how large the boto3 and strands-agents dependency tree gets, set the timeout to at least 30 seconds to account for Bedrock latency, and attach an execution role scoped to the specific Bedrock model ARNs you call rather than a blanket Bedrock policy.
Step 13: Deploy at Scale With Amazon Bedrock AgentCore
Lambda works for simple, stateless calls, but production agents that need session memory, identity, and managed scaling benefit from Bedrock AgentCore, the managed runtime AWS built specifically for agent workloads like Strands. AgentCore runs each session in an isolated microVM, which AWS and independent builder benchmarks have used directly to test Strands Decider’s cold-start and per-decision latency against raw GPU instances. AgentCore is advertised as consumption-based, with no upfront commitments or minimum fees, and Runtime instances are charged for the underlying EC2 session plus a 12% management fee, according to the official pricing example.
# Install the AgentCore CLI and starter kit
pip install bedrock-agentcore-starter-toolkit
agentcore configure --entrypoint research_agent.py
agentcore launchAgentCore handles the container build, session isolation, and scaling policy for you. For agents that also need persistent memory across sessions, the same toolkit exposes memory strategies configurable either through its CLI or directly in SDK code, which is the natural next step once this base setup is working reliably. If you are already running security-sensitive agent credentials, pair this with the practices in a secure AI agent credentials setup before exposing anything to production traffic.
Securing Your Strands Agent: IAM Scope and Credential Handling
An agent with tool access is, by definition, a piece of software that can take actions on your behalf, which makes its credential scope worth getting right before anything ships past a local test. Three practices cover most of the risk.
- Scope IAM policies to specific Bedrock model ARNs rather than a wildcard bedrock:* permission. If your agent only ever calls amazon.nova-lite-v1:0, the policy should say so explicitly, which limits the blast radius if the Lambda execution role or AgentCore identity is ever compromised.
- Keep long-lived AWS keys out of environment variables in deployed code. Local development with exported AWS_ACCESS_KEY_ID variables is fine for the steps in this tutorial, but Lambda and AgentCore deployments should use IAM execution roles instead, so no static credential ever needs to live in a config file or container image.
- Treat tool functions as untrusted input handlers. A tool that shells out to the filesystem or calls an internal API is exactly as dangerous as any other code path that accepts model-generated arguments. Validate and sanitize tool inputs the same way you would validate a web form submission, since the model choosing to call a tool with unexpected arguments is a normal failure mode, not an edge case.
These three practices map closely to the broader guidance in a dedicated AI agent credential security setup, which is worth reading in full before any Strands agent built here gets access to real production systems or customer data.
Common Pitfalls When Setting Up Strands Agents
Five mistakes account for most of the friction developers hit during this setup, based on recurring patterns in the SDK’s issue tracker and AWS’s own troubleshooting guidance.
- Installing strands-agents without the provider extra you need. The base package installs cleanly, then the first call to AnthropicModel or OpenAIModel fails with an import error because the underlying client library was never installed.
- Requesting a Bedrock model ID the account has not been granted access to. Model access in Bedrock is opt-in per region. A perfectly correct model_id string still fails with an access-denied error until you approve it in the console.
- Forgetting that tool docstrings are not optional. The model relies on the docstring to understand what a tool does and when to call it. A tool with no docstring or a vague one gets called at the wrong times or never at all.
- Running Strands Decider’s HTTP server and the main agent process in the same terminal session. The serve command blocks the terminal, so the agent script that tries to call it from the same window will hang. Always run Decider in its own terminal or as a background service.
- Pinning an old boto3 version from a different project’s virtual environment. The Bedrock provider depends on recent boto3 APIs, and an outdated pin produces errors that look like authentication failures but are actually missing SDK methods.
- Calling Strands Decider without a timeout set. It is fast under normal conditions, but a sidecar process competing for CPU with a local LLM or a loaded-down laptop can stall. Always set a short timeout on the HTTP call and fall back to the primary model’s own judgment if Decider does not respond in time, rather than letting the whole agent hang.
- Underestimating Lambda cold-start latency on top of model latency. A cold Lambda container adds its own delay before your code even runs, which stacks on top of whatever the Bedrock call takes. For latency-sensitive agents, provisioned concurrency or a persistent AgentCore deployment avoids the double penalty that a cold Lambda plus a cold model call produces together.
Troubleshooting Guide: Errors You Will Likely Hit and How to Fix Them
These are the specific errors most commonly reported during Strands Agents and Strands Decider setup, along with their root cause and fix.
| Error | Likely Cause | Fix |
|---|---|---|
| ModuleNotFoundError: No module named ‘anthropic’ | Installed strands-agents without the anthropic extra | Run pip install “strands-agents[anthropic]” |
| AccessDeniedException on Bedrock call | Model access not enabled for that model in that region | Open Bedrock console, Model Access, request access, wait for approval |
| NoCredentialsError | AWS credentials not set in the current shell or profile | Run aws configure or export the three AWS environment variables |
| Connection refused on localhost:8787 | Strands Decider server not running, or running in a blocked terminal | Start strands-decider serve in its own terminal window first |
| Tool never gets called by the agent | Missing or vague docstring on the @tool function | Add a clear, specific one-line docstring describing exactly what the tool does |
| AttributeError on BedrockModel methods | Outdated boto3 or botocore version | Run pip install –upgrade boto3 botocore strands-agents |
| Agent hangs with no output | Using agent() instead of agent.stream() while expecting incremental output | Switch to the streaming interface if you need incremental events |
| Lambda timeout after 3 seconds | Default Lambda timeout too short for Bedrock round-trip latency | Raise the function timeout to at least 30 seconds |
| PortAudio-related error on bidi install | Missing system-level PortAudio library needed for audio extras | Install PortAudio via your OS package manager before the bidi-pyaudio extra |
Advanced Tips: Multi-Agent Orchestration and Observability
Once a single agent is stable, the next question most teams run into is coordination between multiple agents. Strands supports composing agents where one agent calls another as a tool, which lets you split a research assistant into a planner agent and a specialist execution agent without changing the underlying loop architecture. Keep each sub-agent’s tool list narrow. An agent juggling fifteen tools is both slower to reason over and more prone to picking the wrong one, which is exactly the problem Strands Decider addresses when used as a pre-filter rather than letting the main model sort through every option itself.
For observability, the SDK’s otel install extra wires up OpenTelemetry tracing across the agent loop, so every model call, tool invocation, and routing decision shows up as a span in whatever tracing backend you already run. This matters more than it sounds once an agent is making dozens of decisions per request. Without tracing, debugging why an agent chose one tool over another means reading raw logs line by line. With it, the full decision path is a single trace you can inspect in one view.
On the Decider side, treat its confidence scores as a signal, not a hard cutoff. A low-confidence routing decision is a reasonable trigger to fall back to the full model for a second opinion rather than trusting Decider blindly, particularly for decisions with real consequences like approving a financial transaction or selecting between conflicting data sources. This fits the same architectural pattern used by teams running ultrafast-mode API setups, where a fast, cheap pass handles the bulk of traffic and a slower, more capable model only gets invoked when confidence drops.
Strands Agents SDK vs Other Agent Frameworks
Strands is not the only option for building agents on top of Bedrock or other model providers, and it is worth knowing where it fits relative to the alternatives most developers already have on their radar.
| Framework | Primary Backer | Best Fit |
|---|---|---|
| Strands Agents | AWS | Bedrock-native teams, model-agnostic flexibility, AgentCore deployment |
| LangChain / LangGraph | LangChain Inc. | Complex graph-based workflows, large existing ecosystem |
| CrewAI | CrewAI Inc. | Role-based multi-agent teams with less custom wiring |
| Claude Agent SDK | Anthropic | Deep Claude-specific features and Agent Skills integration |
The deciding factor for most teams is less about raw capability and more about where the rest of the stack already lives. Teams already running workloads on Amazon Strands Decider or Bedrock get the most immediate value from Strands Agents, since the provider classes, IAM model, and AgentCore deployment path are all built for that environment specifically rather than bolted on afterward.
Where Strands and Decider Fit in Real Agent Pipelines
The research assistant built in Step 11 is deliberately simple so the mechanics stay visible, but the same pattern scales to the kinds of workloads teams are actually shipping. A support triage agent might use Decider to classify an incoming ticket into one of eight categories before handing it to a specialist agent built with a larger model, cutting both latency and the number of expensive model calls per ticket. A DevOps agent monitoring deploy pipelines could use Decider to decide, in well under 300 milliseconds, whether a failed build warrants paging a human or retrying automatically, reserving the slower, costlier reasoning model for genuinely ambiguous failures.
The common thread across these patterns is a two-tier structure: a small, fast, calibrated model handles the high-volume classification work, and a larger model only gets invoked for the subset of requests that actually need full reasoning. This is not a new idea in machine learning generally, cascade classifiers have used a similar structure for years, but having it packaged as an open-weight model with a ready-made agent SDK on top lowers the bar for teams that would otherwise need to train their own routing classifier from scratch.
Before extending any of these patterns into a system with real consequences, write a small evaluation set of representative prompts and known-correct tool choices, then run both the full model and Decider against it to see where they disagree. Decider’s calibrated confidence score makes this comparison straightforward: look specifically at the cases where Decider was both wrong and confident, since those are the failure modes most likely to cause silent problems in production rather than the low-confidence cases a well-designed fallback would already catch.
Frequently Asked Questions
Is the Strands Agents SDK free to use?
Yes. The SDK itself is open source under the Apache 2.0 license and costs nothing to install or run. You only pay for the underlying model calls, whether that is Bedrock on-demand pricing, a direct Anthropic or OpenAI API bill, or nothing at all if you run Ollama or Strands Decider entirely on local hardware.
Do I need an AWS account to use Strands Agents?
No. While the SDK is built by AWS and integrates tightly with Bedrock and AgentCore, it works with Anthropic, OpenAI, Gemini, Ollama, and several other providers without touching AWS at all. An AWS account is only required if you specifically want Bedrock models or AgentCore deployment.
What is the difference between Strands Agents and Strands Decider?
Strands Agents is the general-purpose framework for building agents, the loop, tools, providers, and deployment. Strands Decider is a separate, small open-weight model released October 1, 2026, designed specifically to make fast routing and classification decisions inside that loop. You can use Strands Agents without ever touching Decider, but Decider is built to plug directly into it.
Can Strands Decider run on a laptop without a GPU?
Yes. The default 2B variant needs roughly 4 GB of memory and runs on CPU, a consumer GPU, or an Apple Silicon Mac. It will be slower than the 115-millisecond figure measured on an RTX 3090, but it remains functional on modest hardware, which is part of the point of keeping the model this small.
Does Strands Agents support TypeScript, or only Python?
Both. AWS ships a TypeScript SDK alongside the Python version, installed via npm as @strands-agents/sdk, with the same core concepts: an Agent class, tool definitions, and pluggable model providers. This tutorial focuses on Python since it remains the more common choice for agent prototyping.
How is this different from just using the Bedrock API directly?
Calling Bedrock’s API directly means writing your own agent loop: parsing tool-call responses, executing functions, re-sending results, and handling streaming manually. Strands handles that loop for you and adds a consistent interface across a dozen model providers, so the same agent code works whether the backend is Bedrock, Anthropic, or a local Ollama model.
What happened to the older Strands Agents preview from 2025?
The May 2025 preview became the 1.0 production release that summer, and the SDK has continued shipping incremental versions since, reaching 1.59.0 in October 2026. AWS also added a higher-level Harness SDK on top of the core package for teams that want a pre-assembled agent with benchmarked defaults rather than configuring every piece manually.
Is Bedrock AgentCore required to deploy a Strands agent?
No. A Strands agent is a regular Python process and can run anywhere Python runs, including a plain EC2 instance, a Docker container, or AWS Lambda for simpler request-driven workloads. AgentCore is the recommended path specifically when you need session isolation, managed memory, and automatic scaling without building that infrastructure yourself.
