Anatomy of an agent

An agent in Strands is a model wrapped in a loop that reasons, calls your tools, and works toward a goal across as many turns as the task needs. You build one by composing a few parts on that loop: the prompts that shape how it behaves, the state it carries between turns, the tools it can reach for, and the hooks and interventions that let you control it while it runs. Each part is its own page in this section; this is the map of how they fit together.

The agent core

Agent loopHow the agent reasons, calls tools, and decides when a task is done.

PromptsShape behavior with a system prompt and structure what you send each turn.

Structured outputGet typed, schema-validated results back instead of free-form text.

State it carries

StateHold data the agent reads and writes across the turns of a single run.

Conversation managementControl what stays in the context window as the conversation grows.

Session managementPersist the conversation so an agent resumes where it left off.

SnapshotsCapture and restore agent state to pause, branch, or recover a run.

Control at runtime

HooksRun your own code at each step of the loop to observe or change behavior.

InterventionsGate, steer, and pause the agent while it runs, with a human or a policy.

Retry strategiesRecover from model and tool errors without failing the whole run.

A composed agent

The smallest agent that shows the composition: a model with a system prompt, a tool it can call, and the loop that decides when to use it.

Python

from strands import Agent, tool


@tool
def word_count(text: str) -> str:
    """Count the words in a piece of text."""
    return f"{len(text.split())} words"


agent = Agent(
    system_prompt="You are a concise writing assistant.",
    tools=[word_count],
)
agent("How many words are in this sentence?")

TypeScript

import { Agent, tool } from '@strands-agents/sdk'
import { z } from 'zod'

const wordCount = tool({
  name: 'word_count',
  description: 'Count the words in a piece of text.',
  inputSchema: z.object({ text: z.string() }),
  callback: (input) => `${input.text.split(/\s+/).length} words`,
})

const agent = new Agent({
  systemPrompt: 'You are a concise writing assistant.',
  tools: [wordCount],
})
await agent.invoke('How many words are in this sentence?')

The loop, the prompt, and the tool are the whole agent here. Every other part in this section adds to that same core rather than replacing it.

Where to go next

New to the SDK? Start with the Python quickstart or TypeScript quickstart, then read the agent loop to understand the cycle everything else builds on.

Building a feature? Give the agent capabilities with tools, then reach for the part of the anatomy your task needs: session management to persist a conversation, hooks to run code at each step, or interventions to keep a human or a policy in the loop.