AWS Builder Center

Builder Center

Strands Agents SDK: A Comprehensive Technical Guide to Building Autonomous AI Agents on AWS (Part 1)

Strands Agents SDK: A Comprehensive Technical Guide to Building Autonomous AI Agents on AWS (Part 1)

A companion guide for an AWS Community Builder technical article—covering architecture, protocols, multi-agent patterns, and a real-world production case study.

Andre Rosa

TLDL

The problem it solves:

Language models (like ChatGPT on its own) can only generate text responses. They cannot access your database, use an application, maintain an organized history of past conversations, or seek human approval before sending an important email.
This framework transforms a simple AI into an autonomous Agent. It resolves the complexities of connecting AI to external tools, managing chat memory, monitoring errors, and ensuring the AI ​​can execute complex tasks.

What’s in the image (the building blocks):

Client / Application (left): The source of the request—whether you are typing in a chat interface, on a website, or in an app.
Strands Agent — Event Loop (center): The orchestra conductor. It receives your request and decides on the course of action, step by step. It consists of five main components:
ToolRegistry: The catalog of tools available to the AI ​​(web search, calculator, etc.).
ToolExecutor: The component that runs these tools (capable of executing multiple tools simultaneously or sequentially).
ConversationManager: The chat memory. It ensures the AI ​​doesn't "forget" the conversation topic while staying within text limits.
HookRegistry / Interventions: An emergency stop or control mechanism. It allows a human to review actions before the AI ​​performs critical tasks or to inject additional data in real-time.
EventLoopMetrics + Tracer: The dashboard that tracks speed, errors, and performance.
Model Providers (top right): The "actual AIs" (such as ChatGPT/OpenAI, Claude, Llama). The agent sends text to them for processing.
Tools & Protocols (middle right): The practical utilities the AI ​​can utilize (browsers, databases, connections to other AIs). Observability (bottom right): Security and monitoring systems that allow developers to see if something has gone wrong or if the AI ​​is taking too long to respond.
Deployment Targets (bottom): The cloud servers (such as AWS) where all this code runs 24/7.
Strands Agents SDK: Comprehensive Technical Guide to Building Autonomous AI Agents on AWS
Companion guide for an AWS Community Builder technical article — covering architecture, protocols, multi-agent patterns, and a real-world production case study.

Table of Contents

  1. Introduction: Why Strands Agents exists
  2. Timeline: From preview to tens of millions of downloads
  3. What is the Strands Agents SDK?
  4. The Model-First philosophy
  5. Minimal anatomy of a Strands agent
  6. Inside the Event Loop (Agent Loop)

1. Introduction: Why Strands Agents exists

Most agent frameworks that predated Strands (LangChain in its early days, AutoGen, and many of the "agent frameworks" from 2023–2024) solved the orchestration problem by writing explicit state graphs: the developer decides, in code, which step follows another, and the LLM is invoked within specific nodes of that graph.
Strands Agents flips this logic. The AWS team that built Amazon Q Developer noticed—back in 2023, shortly after the original ReAct (Reasoning and Acting) paper was published—that models were already capable of planning, chaining reasoning, and deciding when to call a tool, without the need for hardcoding. This internal insight gave rise to Strands: a model-driven SDK where the language model acts as the decision engine, and the developer needs to provide only three things—a prompt, a model, and a list of tools.

2. Timeline: from preview to tens of millions of downloads

DateMilestone
May 16, 2025Public announcement of Strands Agents (open-source preview, Apache 2.0); already in internal use within Amazon Q Developer, AWS Glue, and VPC Reachability Analyzer
May 15, 2025GA of AWS Transform for .NET
July 31, 2025Key technical post: "A technical deep dive into agent architectures and observability" (Jin Tan Ruan, AWS ML Blog)
July 2025Amazon Bedrock AgentCore enters public preview as a managed runtime for agents
~Sept 2025"Strands Agents 1.0": consolidation of 4 multi-agent primitives + native A2A support, remote session manager, and 5 new model providers contributed by partners (Anthropic, Meta, OpenAI, Cohere, Mistral, Stability, Writer, Baseten)
Dec 2025AWS re:Invent 2025: TypeScript SDK launched; multiple dedicated sessions (observability with OTEL, multimodality, self-evolving agents, AML use case with 8 agents)
May 15, 2026Strands Agents turns 1 year old — 25 million cumulative downloads
May 11, 2026Publication of the technical case study on modernization at scale (Strands + AWS Transform Custom + Bedrock AgentCore)
June 18, 2026Automatic context management (cutting token costs in half), launch of Strands Shell and Strands Evals 1.0 — surpassing 50 million total downloads
July 16, 2026"Open Protocols with the Strands Agents SDK" post: adoption of native MCP and A2A, plus complementary integrations for AG-UI and x402
July 24, 2026Main repository (now named Strands Harness) reaches 6.7k stars and 990 forks on GitHub
A key point for your article: Strands has evolved from "just an agent SDK" into a product family — Strands Harness (the core SDK), Strands Evals (evaluation), and Strands Shell (execution sandbox) — all housed under the strands-agents GitHub organization, with a sister organization, strands-labs, dedicated to cutting-edge experiments (such as the "Steering" feature).

3. What is the Strands Agents SDK

Strands Agents is an open-source framework (Apache 2.0) available for Python and TypeScript. It is maintained by AWS but open to external contributions—Anthropic, Meta, Accenture, PwC, Langfuse, mem0.ai, and Tavily are among the early contributors. It is not a managed service; rather, it is a library you import into your code that can run anywhere (locally, on other clouds, or on-premises), though it features native, optimized integration with the AWS ecosystem (Amazon Bedrock, Lambda, Fargate, Bedrock AgentCore).
The minimal definition of an agent requires three elements:
  • Model — the LLM provider (by default, a model on Amazon Bedrock).
  • Prompt — the system prompt that defines the role and behavior.
  • Tools — Python/TypeScript functions, MCP servers, or other aagents exposed as tools.

4. The Model-First Philosophy

Strands AgentsTraditional frameworks (e.g., "classic" LangChain)
Who decides the next stepThe model, at each loop iterationThe graph/state machine defined in code
Orchestration effortMinimal — few lines of configurationHigh — explicit nodes, edges, and transitions
Initial learning curveLowModerate to high
Fine-grained flow controlPossible via hooks, interventions, and multi-agent primitivesNative and granular
This does not imply a lack of control: Strands offers hooks (events such as BeforeModelCallEvent, AfterInvocationEvent, and BeforeToolCallEvent), interventions (e.g., HumanInTheLoop, which pauses execution before a tool call for human approval), and the four multi-agent primitives described in Section 10—meaning you can reintroduce determinism exactly where it is needed without sacrificing the simplicity of the common use case. ## 5. Minimal anatomy of a Strands agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from strands import Agent, tool

@tool
def check_inventory(sku: str) -> dict:
"""Checks the current inventory of an SKU in the internal system."""
# actual API/DB call would go here
return {"sku": sku, "quantity": 42, "warehouse": "SP-01"}

agent = Agent(
system_prompt="You are an e-commerce operations assistant. "
"Respond based on real inventory data.",
tools=[check_inventory],
)

response = agent("Do we still have SKU ABC-123 available?")
print(response)
The model receives the question, decides (on its own) that it needs to call check_inventory, the SDK executes the Python function, injects the result back into the conversation, and the model formulates the final answer—all within a single agent(...) call.

6. Inside the Event Loop (Agent Loop)

This is the SDK's fundamental concept—"everything else is built on top of it," in the words of the official documentation itself. The cycle is simple on the surface, but it is worth understanding the actual internal components (these aren't generic names—they are public SDK classes):
  1. Context preparation — the Agent assembles the message history (managed by a ConversationManager) and resolves the JSON schemas for available tools via the ToolRegistry.
  2. Model invocation — the model provider (Bedrock, Anthropic, OpenAI, etc.) receives messages + tool schemas and returns text, one or more tool_use requests, or both (streaming).
  3. Tool execution — the agent's tool_executor processes the calls. By default, this is the ConcurrentToolExecutor, which runs all tools requested by the model in the same response in parallel (the final latency becomes that of the slowest tool, rather than the sum of all of them); there is also the SequentialToolExecutor for cases requiring guaranteed order. 4. Feedback to the model — the result of each tool execution (success or error—errors become an error message for the model rather than an exception that crashes the loop) is serialized and returned as a new message.
  4. Conversation management — after each cycle, ConversationManager.apply_management() decides whether the history needs to be trimmed or summarized. The default is SlidingWindowConversationManager; there are also NullConversationManager (which does nothing) and SummarizingConversationManager (which uses an LLM to summarize old messages). Since mid-2026, there has also been a context_manager="auto" mode, which enables proactive compression based on token thresholds and—according to the Strands team itself—has halved production token costs in some scenarios.
  5. Convergence — the cycle repeats (via the internal recurse_event_loop function) until the model produces a final response without tool_use or until the max_iterations limit is reached.
All this orchestration is instrumented by a HookRegistry (allowing interception of any loop event) and EventLoopMetrics (telemetry on tokens, latency, and calls), which feed the observability layer described in Section 11.
An additional component worth mentioning, as it is often misunderstood, is the ContextInjector. This is an actual SDK plugin (strands.vended_plugins.context_injector) that injects ephemeral text—such as the current time or the result of a quick query—directly into the input of a specific model call, without persisting that text in the conversation history. It differs from the ConversationManager: one maintains the conversation's long-term memory, while the other injects specific, disposable facts at each turn.
# strands# langchain# langgraph
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article