The Strands Agent Loop

You've built agentic loops from scratch. You know the cycle: send messages to the model, check if it wants to call a tool, execute the tool, feed the result back, repeat until the model says "done." Strands implements exactly this pattern — but gives you lifecycle hooks, invocation limits, cancellation, conversation management, and observability for free.

This lesson maps what you already know to Strands' TypeScript API. By the end, you'll have a running agent with a custom tool, configured for Bedrock with Claude Sonnet 4.6, with explicit control over how many cycles it can run.

Language Support

The Strands Agents SDK is available natively in two languages:

Using tools written in other languages

While the agent orchestration itself runs in Python or TypeScript, your tools can be written in any language via MCP (Model Context Protocol). An MCP server is a standalone process that exposes tools over stdio or HTTP — it can be written in Go, Rust, Java, C#, or anything else that speaks the protocol.

// Connect to an MCP server written in any language
import { Agent } from '@strands-agents/sdk'
import { McpClient, StdioClientTransport } from '@strands-agents/sdk/mcp'

// This could be a Go binary, a Rust server, a Java JAR — anything
const mcpClient = new McpClient({
  transport: new StdioClientTransport({
    command: './my-tool-server',  // Your binary in any language
    args: ['--mode', 'mcp'],
  }),
})

const agent = new Agent({
  tools: [mcpClient],  // Tools auto-discovered from the MCP server
})

await agent.invoke('Use the tools from my custom server')

This means: orchestrate in TypeScript, but delegate heavy lifting to tools in whatever language suits the task. A Go binary for file system operations, a Rust process for data parsing, a Java service for legacy system integration — all accessible as MCP tools.

Both SDKs share the same architecture and concepts. We're using TypeScript throughout this course. The Python SDK has a larger community tools ecosystem, but the core features (agent loop, multi-agent, hooks, plugins, streaming, structured output) are at parity.

What Strands Calls Things

The vocabulary maps cleanly to what you've built by hand:

The Loop Internals

Strands' agent loop follows this cycle on every invocation:

Key details that differ from a naive hand-rolled loop:

• Parallel tool calls. If the model requests multiple tools in one turn, Strands executes them all (sequentially by default, or with a custom executor) before the next model invocation.
• Error recovery. A failed tool returns an error result to the model rather than crashing the loop. The model gets a chance to retry or work around it.
• Invocation limits. You can cap turns, output tokens, or total tokens per invoke() call. The loop checks limits at the top of each cycle.
• Cancellation. Call agent.cancel() or pass an AbortSignal. The loop checks for cancellation at four checkpoints: top of cycle, during streaming, before tool execution, and between sequential tool calls.

Your First Strands Agent (TypeScript)

Let's build a minimal agent that does something concrete: counts words in text. This maps directly to the tool-use pattern you've built before, but through Strands' API.

Project setup

mkdir strands-hello && cd strands-hello
npm init -y
npm pkg set type=module
npm install @strands-agents/sdk

The agent

Create agent.ts:

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

// Define a tool — Zod schema replaces hand-written JSON schema
const wordCounter = tool({
  name: 'word_counter',
  description: 'Count words in a given text',
  inputSchema: z.object({
    text: z.string().describe('The text to count words in'),
  }),
  callback: async (input) => {
    const count = input.text.trim().split(/\s+/).length
    return { result: `${count} words` }
  },
})

// Create the agent — Bedrock + Claude Sonnet 4.6
const agent = new Agent({
  systemPrompt: 'You are a helpful text analysis assistant.',
  model: 'us.anthropic.claude-sonnet-4-6-20250725-v1:0',
  tools: [wordCounter],
})

// Invoke with an explicit turn limit
const result = await agent.invoke(
  'How many words are in: "The quick brown fox jumps over the lazy dog"',
  { limits: { turns: 3 } }
)

console.log('Stop reason:', result.stopReason)
console.log('Response:', result.message?.content)

Run it

npx tsx agent.ts

What You Get For Free

Compare what you'd need to build yourself versus what Strands handles:

Controlling the Loop

The limits option is your primary lever for determinism. In a consulting context where you're running agents against client data, unbounded loops are unacceptable. Three caps:

const result = await agent.invoke('Analyze this codebase', {
  limits: {
    turns: 5,          // Max 5 reason→act cycles
    outputTokens: 2000, // Cap model output per invocation
    totalTokens: 10000,  // Cap total (input + output) tokens
  },
})

// Check why the loop stopped
switch (result.stopReason) {
  case 'endTurn':
    // Normal completion — model finished its response
    break
  case 'limitTurns':
    // Hit the turn budget — model wanted to keep going
    break
  case 'limitTotalTokens':
    // Token budget exhausted
    break
  case 'cancelled':
    // External cancellation (AbortSignal or agent.cancel())
    break
}

Cancellation with AbortSignal

This is the TypeScript-native pattern — pass standard AbortSignal instances for timeout or user-driven cancellation:

// Timeout after 30 seconds
const result = await agent.invoke('Summarize this report', {
  cancelSignal: AbortSignal.timeout(30_000),
})

// Or with a manual controller (e.g., user clicks "Stop")
const controller = new AbortController()
someButton.onclick = () => controller.abort()

const result2 = await agent.invoke('Long analysis task', {
  cancelSignal: controller.signal,
})

Tools can also participate in cancellation by forwarding the signal:

const fetchTool = tool({
  name: 'fetch_url',
  description: 'Fetch content from a URL',
  inputSchema: z.object({ url: z.string().url() }),
  callback: async (input, context) => {
    // Forward cancel signal to fetch
    const res = await fetch(input.url, {
      signal: context?.agent.cancelSignal,
    })
    return { result: await res.text() }
  },
})

The Mental Model

Think of Strands as the framework layer on top of the loop you already understand. It doesn't change the fundamental mechanic — it standardizes the interfaces around it:

The value proposition for your workflow: you stop writing loop plumbing and start writing tools and prompts. The framework handles the mechanics. When you need to customize behavior (hook into pre/post tool execution, manage conversation windows, add guardrails), you extend rather than rewrite.