Why Strands?

Most AI agent frameworks ask you to define every step your agent should take. Strands takes a different approach: let the model decide.

Model-Driven vs. Workflow-Driven

In a workflow-driven framework, you build a graph of steps — nodes, edges, conditional branches — and the model fills in each step. You control the flow; the model provides the text.

In a model-driven framework like Strands, you give the model a goal and a set of tools. The model decides which tools to call, in what order, and when it’s done. The agent loop handles the orchestration automatically.

Here’s the difference in code:

Strands (model-driven)

from strands import Agent
from strands_tools import calculator, web_search

agent = Agent(tools=[calculator, web_search])
agent("What is the population of Tokyo divided by the area of France?")

Three lines. The model figures out that it needs to search for two facts, then do the math.

Workflow-driven (pseudocode)

# Define the graph
graph = StateGraph()
graph.add_node("search_population", search_population)
graph.add_node("search_area", search_area)
graph.add_node("calculate", calculate)
graph.add_edge("search_population", "calculate")
graph.add_edge("search_area", "calculate")

# Define each node function
def search_population(state):
    result = web_search("population of Tokyo")
    state["population"] = parse_number(result)
    return state

def search_area(state):
    result = web_search("area of France in km2")
    state["area"] = parse_number(result)
    return state

def calculate(state):
    state["answer"] = state["population"] / state["area"]
    return state

# Compile and run
app = graph.compile()
app.invoke({"question": "..."})

You had to anticipate the steps, wire the graph, and handle the state yourself.

When to Use Each Approach

Model-driven development works best when:

• The steps aren’t predictable. If you don’t know in advance what tools the agent needs to call or in what order, let the model figure it out.
• You want to iterate quickly. Changing behavior means changing the prompt or the tool set — not rewiring a graph.
• You need flexibility. The same agent can handle variations of a task without code changes.

Workflow-driven frameworks can be a better fit when:

• You need deterministic, auditable execution paths (e.g., compliance workflows).
• You want fine-grained control over every decision point.
• The task is always the same sequence of steps.

Strands supports both styles. You can use the model-driven agent loop for flexible tasks and graph workflows or structured workflows when you need explicit control.

What You Get

• Any model, any provider. Amazon Bedrock, Anthropic, OpenAI, Gemini, Ollama, and more. Switch providers without changing your agent code.
• Tools as plain functions. Write a Python function with a docstring and it becomes a tool. No schemas, no boilerplate.
• Multi-agent out of the box. Agents as tools, swarms, A2A protocol — simple primitives that compose.
• Production-ready deployment. Deploy to AWS Lambda, Fargate, EKS, Bedrock AgentCore, and more.
• Built-in observability. Traces, metrics, and logs with OpenTelemetry integration.

Python & TypeScript

Strands is available in both Python and TypeScript. The Python SDK is mature and production-ready. The TypeScript SDK is experimental with focus on core agent functionality.

Feature comparison

Category	Feature	Python	TypeScript
Core	Agent creation and invocation	✅	✅
	Streaming responses	✅	✅
	Structured output	✅	❌
Model providers	Amazon Bedrock	✅	✅
	OpenAI	✅	✅
	Anthropic	✅	❌
	Ollama	✅	❌
	LiteLLM	✅	❌
	Custom providers	✅	✅
Tools	Custom function tools	✅	✅
	MCP (Model Context Protocol)	✅	✅
	Built-in tools	30+ via community package	4 built-in
Conversation	Null manager	✅	✅
	Sliding window manager	✅	✅
	Summarizing manager	✅	❌
Hooks	Lifecycle hooks	✅	✅
Multi-agent	Swarms, workflows, graphs	✅	❌
	Agents as tools	✅	❌
Session management	File, S3, repository managers	✅	❌
Observability	OpenTelemetry integration	✅	❌
Experimental	Bidirectional streaming	✅	❌

Next Steps

• Quickstart: Python — build your first agent
• Quickstart: TypeScript — if you prefer TypeScript
• Adding Tools — give your agent capabilities
• Multi-Agent Systems — coordinate multiple agents