strands-agents/samples: What the Reference Repository Actually Gives You
Agent samples built using the Strands Agents SDK.
At a glance
- What is it?
- The samples repo is a teaching corpus for the Strands Agents SDK, not a library you install. Its value is in the directory layout and the two-line agent, and its risk is that the README itself declares the code unfit for production.
- Who is it for?
- Adopt this repository if you are evaluating the Strands Agents SDK and want runnable reference code across deployment, integration and evaluation tracks, or if you need a worked example of a Python agent before committing to the SDK in a real service.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 14 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What Problem a Samples Repository Solves
An SDK's quickstart answers one question: what is the smallest program that works. It rarely answers the next five. How does an agent get deployed to Lambda or Fargate? How does it talk to a database? What does evaluation look like once the agent is non-trivial? The strands-agents/samples repository exists to answer those follow-up questions by example rather than by prose. The README frames the SDK as 'a model-driven approach to building AI agents in just a few lines of code', and the repository is the evidence for that claim: the Python quickstart is an import, an Agent() construction and a call.
The audience is narrow and identifiable. This is for engineers who have already decided to evaluate Strands Agents and want to see the shape of real programs before writing their own, and for engineers who are comparing agent frameworks and want to read working code rather than marketing pages. It is not for someone looking for a component to import. Nothing in the README suggests the repository is distributed as a package; the install command pulls strands-agents and strands-agents-tools, which live in separate repositories linked from the header. The samples repo is the map, not the territory.
The Repository Layout Is the Actual Documentation
The most useful thing here is the directory taxonomy, because it tells you what the SDK maintainers consider the hard parts of agent work. The Python side splits into eight tracks: 01-learn covers fundamentals, multi-agent systems and streaming; 02-deploy covers Lambda, Fargate and AgentCore; 03-integrate covers AWS services, databases and third-party tools; 04-industry-use-cases covers finance, healthcare, retail and productivity; 05-technical-use-cases covers architectural patterns including Agentic RAG; 06-evaluate covers evaluation tutorials and testing patterns; 07-ux-demos covers full-stack applications with user interfaces; and 08-edge covers edge device integrations including physical AI and robotics.
That ordering is a claim about where effort goes. Learning the Agent class is one track. Deployment, integration and evaluation get three separate tracks, which suggests the maintainers expect the SDK itself to be the easy part and the surrounding engineering to be the work. The TypeScript side is much thinner: only 01-learn and 02-deploy, with 02-deploy limited to AgentCore. If you are working in TypeScript, the repository covers tutorials and one deployment target, and the remaining categories have no TypeScript counterpart in the README. That asymmetry is worth knowing before you plan around it.
The Agent Loop in Two Languages
The README gives the minimal agent for both SDKs, and the difference between them is instructive. Python:
from strands import Agent agent = Agent() response = agent("Hello! Tell me a joke.") print(response)
TypeScript:
import { Agent } from "@strands-agents/sdk"; const agent = new Agent({ systemPrompt: "You are a helpful assistant." }); const response = await agent.invoke("Hello! Tell me a joke."); console.log(response.toString());
The Python form constructs an agent with no arguments and calls it directly, which is the model-driven posture the README advertises: the model decides what to do, and the framework stays out of the way until you add tools or a system prompt. The TypeScript form is explicit, taking a configuration object and awaiting an invoke call. Whether those are genuinely different designs or just different idiomatic surfaces in each language is not something the README resolves, and the samples are where you would find out. Note that the Python example prints the response object directly while the TypeScript example calls toString() on it, which hints the two SDKs return different shapes from a call. That is the kind of detail a samples repository is supposed to settle, and this README only hints at it.
Getting a Sample Running
The prerequisites are stated plainly: Python 3.10 or higher and pip. The README notes pip usually ships with Python 3.4+ installers from python.org and gives two recovery paths if it is missing, python -m ensurepip --upgrade or the get-pip.py bootstrap script. Then a virtual environment:
python -m venv venv source venv/bin/activate
On Windows the activation line is venv\Scripts\activate. The install step is a single command: pip install strands-agents strands-agents-tools. The TypeScript path requires Node.js 18 or higher and npm or yarn, then npm install @strands-agents/sdk.
There is one step the README does not inline. Model provider setup is delegated to an external page, https://strandsagents.com/latest/user-guide/quickstart/#model-providers, described as configuring your model provider and model access. The repository topics list anthropic, bedrock, litellm, llama, ollama and openai, so the SDK clearly supports several backends, but the README does not show which environment variables or config keys any of them need. That is a real gap for anyone trying to run a sample cold. Budget for reading the quickstart page before the first sample executes, and expect the first failure to be a missing credential rather than a missing package.
The Production Disclaimer Is Not Boilerplate
The README states that the examples are for demonstration and educational purposes only, that they demonstrate concepts and techniques, and that they are not intended for direct use in production, with a further instruction to apply proper security and testing procedures before using them in production environments. This sentence is repeated in bold in the original, which is unusual for a samples repository and worth taking at face value.
The practical consequence is that copying a sample into a service is a rewrite, not a lift. Deployment samples for Lambda, Fargate and AgentCore show a pattern; they do not carry the hardening you would need. Integration samples for AWS services and databases show a call shape; they do not carry error handling or credential scoping. The 06-evaluate track exists precisely because evaluation and testing are separate work from writing the agent, and the fact that it is a track rather than a section of the deployment track tells you the maintainers see it as its own discipline. Treat every sample as a starting sketch and expect to own everything around the agent loop.
A second limitation is structural: there are no retrieved releases for this repository. If you want to cite a version of a sample in a design document, there is no tag to point at. You get the main branch as it stands on the day you clone it.
Where a Samples Repo Is the Wrong Tool
If you need a maintained abstraction over agent orchestration, this repository is not it. A framework such as LangGraph takes the opposite approach: it publishes a versioned library with its own graph and state abstractions, so your code depends on the framework's API surface and inherits its upgrade path. Strands Agents, as presented here, keeps the abstraction thin and pushes structure into your code; the samples show patterns you reimplement rather than APIs you call into. Neither approach is strictly better, but they fail differently. A library gives you a compatibility contract and a changelog to read. A samples repository gives you code you own outright from the moment you copy it, with no upstream obligation to keep it working against your use case.
There is a second case where this repository misleads. If your work is TypeScript, the two available tracks cover tutorials and AgentCore deployment only. The integration, evaluation, UX and edge categories that exist on the Python side have no README-listed TypeScript equivalent, so a TypeScript team reading the Python taxonomy and assuming parity will plan against material that is not there. Check the typescript directory listing before you commit to a design that assumes those samples exist.
Maintenance, Licensing and What You Inherit
The repository is licensed under Apache License 2.0, stated in the README and in a LICENSE file at the root. Apache-2.0 is a permissive licence that includes an express patent grant, which matters more for agent code than for a utility library because agent systems touch model providers, retrieval pipelines and tool integrations where patent exposure is harder to reason about informally. This is not legal advice; if you are incorporating sample code into a commercial product, have counsel confirm the notice and attribution requirements you inherit, particularly if you modify and redistribute the samples.
On maintenance cost, the material supports a few concrete observations. The repository is not archived and the last push recorded is 2026-09-01. There are no retrieved releases, so there is no versioned artifact to track and no changelog-driven upgrade path for the samples themselves. The Python samples depend on strands-agents and strands-agents-tools as separately versioned packages, which means a sample can break when either package changes even though the sample file is untouched. The README also links a Contributing Guide covering bug reports, development setup, pull requests, a Code of Conduct and security issue reporting, so there is a defined contribution path if a sample is wrong. What there is not is a stated support window or a compatibility matrix between sample tracks and SDK versions.
Editorial conclusion
Adopt this repository if you are evaluating the Strands Agents SDK and want runnable reference code across deployment, integration and evaluation tracks, or if you need a worked example of a Python agent before committing to the SDK in a real service. Do not adopt it as a dependency: nothing here is published as a package, the README states the examples are for demonstration and educational purposes only and are not intended for direct use in production, and there are no retrieved releases to pin. Before you build on any sample, verify three things yourself: that the sample's track (01-learn through 08-edge) matches your target runtime, that you have configured a model provider as the quickstart page describes, and that the sample's dependencies resolve against the strands-agents and strands-agents-tools versions you intend to ship.
Community notes