Strands Agents Samples: a Python and TypeScript example set for the Strands SDK

What Strands Agents Samples actually is, and who it is for

The repository is a sample collection, not a runtime. Its README describes it as "easy-to-use examples to get started with Strands Agents," and the examples demonstrate concepts and techniques rather than shipping a supported library. The thing you install is the SDK, published as strands-agents and strands-agents-tools on PyPI for Python and as @strands-agents/sdk on npm for TypeScript. The samples repository is where you read code.

That distinction decides the audience. If you are an engineer deciding whether the Strands Agents SDK fits an agent you have to build, the samples give you working shapes to compare against your own design: a single agent, a multi-agent system, a streaming response, a deployment target. If you already committed to the SDK, the folders act as a map of what the maintainers consider idiomatic. If you need a library with a versioned API surface and a changelog, this repository is the wrong artifact. The README's own warning is unambiguous: the examples are "not intended for direct use in production."

How the sample tree is organized, and what the folder names tell you

The Python side is split into eight numbered directories, and the numbering is the intended reading order. 01-learn holds SDK tutorials covering fundamentals, multi-agent systems and streaming. 02-deploy covers deployment patterns for Lambda, Fargate and AgentCore. 03-integrate covers AWS services, databases and third-party tools. 04-industry-use-cases and 05-technical-use-cases split applications from architectural patterns, with Agentic RAG named explicitly under the technical folder. 06-evaluate covers evaluation tutorials and testing patterns, 07-ux-demos holds full-stack applications with user interfaces, and 08-edge covers edge device integrations including physical AI and robotics.

The TypeScript side is much thinner: 01-learn for SDK tutorials and 02-deploy for AgentCore deployment patterns. Nothing in the repository listing suggests the TypeScript samples reach the same breadth as the Python ones, so a team working in TypeScript should expect to read Python samples for anything past the fundamentals and translate the concepts themselves. That is a real asymmetry, not a documentation gap you can wait out.

The top-level requirements.txt is worth reading before you assume the samples are self-contained. It pins boto3>=1.26.0, botocore>=1.29.0, watchdog, jsonschema, mcp>=1.6.0 and retrying. The mcp entry lines up with the repository's Model Context Protocol topic, and boto3 and botocore point at AWS as the default cloud surface for the deploy and integrate folders.

Installing the SDK and running your first Strands agent

The README's Python quick start requires Python 3.10 or higher and pip. It gives two fallback commands if pip is missing, using Python's built-in module or the official installer script, so a bare interpreter is not a blocker.

The README recommends a virtual environment before installing anything. The commands below are copied from it, including the platform split for activation.

python -m venv venv
source venv/bin/activate
venv\Scripts\activate

The first two lines apply on macOS and Linux, the third on Windows. After activation, install the SDK and the companion tools package:

pip install strands-agents strands-agents-tools

The README's first agent is four lines. It constructs an Agent with no arguments and calls it with a string, which is the whole model-driven pitch: no explicit tool registry, no prompt template, no loop.

from strands import Agent

agent = Agent()
response = agent("Hello! Tell me a joke.")
print(response)

What you should see is the model's reply printed to stdout. What the README does not show here is which model answers. Provider setup is not in this repository; it points to the quickstart page on strandsagents.com for configuring your model provider and model access. Expect that step to be required before the snippet returns anything, and treat the four-line example as incomplete without it.

The TypeScript path is shorter and starts differently

The TypeScript quick start needs Node.js 18 or higher plus npm or yarn, and installs a single package:

npm install @strands-agents/sdk

The first agent differs from the Python version in two ways that matter for anyone porting code. It passes a systemPrompt in the constructor, and it calls the agent with invoke rather than calling it directly. The result is converted with toString before logging.

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

async function main() {
    const agent = new Agent({
        systemPrompt: "You are a helpful assistant."
    });

    const response = await agent.invoke("Hello! Tell me a joke.");
    console.log(response.toString());
}

main();

If you are moving a Python sample to TypeScript, that invoke call and the explicit systemPrompt are the first two things to check. The README does not document a TypeScript equivalent for the tools package, so a port that depends on strands-agents-tools has no stated counterpart on the npm side.

Where the samples stop being useful

The most important limitation is stated by the project itself. The README calls the examples demonstration and educational material and says they are not intended for direct use in production, adding that you should apply proper security and testing procedures first. That is not boilerplate caution from a third party; it is the maintainers telling you the code is illustrative. Copying a deploy sample into a live account without reading it is the failure mode this sentence exists to prevent.

The second limitation is the provider dependency. The samples assume a configured model provider, and the configuration instructions live on strandsagents.com, not in this repository. A sample that runs for the maintainer can fail immediately for you because no provider is set, and nothing in the repository layout tells you which provider a given sample expects.

The third is scope drift over time. This is a sample collection with no retrieved releases, so there is no changelog to tell you when a sample was last aligned with the SDK it demonstrates. When the SDK changes, a sample can quietly fall behind. Pin the SDK version you installed and re-read the sample if behaviour diverges. If you need a supported, versioned component, use the SDK repositories (sdk-python and sdk-typescript) rather than this one.

What to compare it against before you commit

The natural alternative is a general-purpose agent framework such as LangChain or LlamaIndex, and the difference is structural rather than cosmetic. Those projects ship a framework you adopt as a dependency, with abstractions for chains, retrievers and memory that your application code builds on. Strands Agents Samples ships no framework at all; it ships examples that call an SDK. You are not adopting an abstraction layer, you are reading how one team writes agents against a model-driven API.

A second comparison is the SDK repositories themselves. If you want the canonical, tested surface, the Python and TypeScript SDK repos are the source of truth; the samples are downstream of them and inherit their pace. Use the samples to decide whether the SDK's style suits you, then work from the SDK for anything real.

The repository's own topics give a sense of the intended ecosystem: anthropic, bedrock, litellm, llama, openai, ollama, mcp and opentelemetry. That spread suggests provider flexibility is a design goal, but the samples repository only demonstrates it; it does not document the provider matrix, and the README defers that to the documentation site.

Licence, maintenance and the cost of following along

The repository is licensed under Apache License 2.0, with the LICENSE and NOTICE files at the top level and a CONTRIBUTING.md that covers bug reports, development setup, pull requests, the code of conduct and security issue notifications. Apache-2.0 is permissive and includes an explicit patent grant, which matters if you intend to lift sample code into a commercial codebase. The NOTICE file is the one people skip; read it before redistributing anything, and get your own legal review rather than treating this paragraph as advice.

The repository is not archived, and the last push was on 2026-09-01, so it is current as of that date. There are no retrieved releases, which is consistent with a sample collection: there is nothing to upgrade on a version cadence, because you do not install the samples. Your upgrade cost lives entirely in the SDK packages you pinned. When you bump strands-agents or @strands-agents/sdk, expect to re-check any sample you copied, since the sample has no version of its own to hold it in place. That is the trade: low adoption cost, no compatibility guarantee.

Editorial conclusion

Adopt Strands Agents Samples if you are evaluating the Strands Agents SDK and want runnable reference code before writing your own agent loop; the 01-learn folders in python/ and typescript/ are the entry point. Do not adopt it as a dependency, a framework, or a starting point for a production service, because the README states the examples are for demonstration and educational purposes and are not intended for direct use in production. Before building on anything you copy out, verify which model provider the sample assumes, since provider configuration lives on the documentation site rather than in this repository, and read the LICENSE and NOTICE files at the repository root to confirm the Apache-2.0 terms cover the sample you intend to reuse.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. Project website
4. README
5. strands-agents/samples on GitHub