Strands Harness: Build end-to-end AI agents in Python or TypeScript
An AI-agent SDK for Python and TypeScript teams that avoids hand-written loops and hosted control planes.
GitHub strands-agents/harness-sdk Updated 2026-09-24 Branch main Stars 7.8K Forks 1.2K
Python TypeScript AI agents Amazon Bedrock Anthropic OpenAI Gemini MCP Apache License 2.0

🧭 Decision Guide

Why trending now: The repository gained 115 stars that day and appeared on GitHub Trending daily; the README also emphasizes Python, TypeScript, multiple model providers, create_harness(), and production capabilities, but the material cannot confirm which factor directly caused the growth.

Try it if you

  • You want a Python 3.10+ agent with default models, tools, memory, and sessions
    The README's “Quick Start” says create_harness() provides an optimized agent and lists the Python 3.10+ requirement
  • You need to switch among Amazon Bedrock, Anthropic, OpenAI, and Gemini
    The README's “Why Strands” lists first-class support for these four providers and says backends can be swapped
  • You need control over the agent loop, tools, MCP, structured output, or multi-agent patterns
    The README lists lifecycle controls, tools, structured output, MCP, and multi-agent patterns
  • You want an in-process agent with Hooks for logging, validation, or redirection
    The README says the agent runs in your process with no hosted control plane and describes Hooks under “Stay in control”

Skip it if you

  • Your architecture must rely on a hosted control plane to manage agent execution
    The README explicitly says Strands runs in your process with no hosted control plane
  • Your runtime is below Python 3.10 or Node.js 22
    The README's “Working with the SDK” section states Python 3.10+ and Node.js 22+
  • You only need a standalone CLI and do not need the Python or TypeScript SDKs
    The README describes strands-cli as a way to prototype and chat with a harness agent, while the core repository includes both SDKs

Requirements

  • Python SDK requires Python 3.10+
  • The Python harness is installed with pip install strands-harness
  • The TypeScript harness is installed with npm install @strands-agents/harness
  • The TypeScript SDK requires Node.js 22+
  • The Quickstart supports providers including Amazon Bedrock, Anthropic, OpenAI, Gemini, and Ollama

First step (verbatim from README)

pip install strands-harness

Watch out

  • Do not treat create_harness()'s benchmarked defaults as a published performance guarantee
    The README only calls the defaults benchmarked and provides no benchmark metrics
  • The TypeScript workflow uses npm ci and npm run build, so it is not the same as the Python workflow
    The README's “Development” section lists npm ci and npm run build for the TypeScript SDK
  • Confirm the integration details before relying on a custom model provider
    The README only says custom ones are supported and links the details to the model providers documentation

Alternatives

  • A hand-written agent loop：It is a better fit when you need to implement the agent loop yourself instead of using Strands lifecycle controls, tools, and model providers
    README section “Choose Strands when you would otherwise write your own agent loop”

Not stated in the README

  • The README does not provide authentication configuration details for Amazon Bedrock, Anthropic, OpenAI, or Gemini
  • The README does not provide benchmark data, latency, or throughput for create_harness()
  • The README does not specify production hardware, concurrency limits, or resource consumption
  • The README does not describe compatibility changes across the 5 releases leading to harness-cli/v0.1.2
  • The README does not specify the default rules for Guardrails and steering handlers

💡 Deep Analysis

6
Yes I maintain the agent loop in `strands-py/` and want to run the project-prescribed tests, formatting, and lint checks before submitting changes. Does the README provide a directly usable development workflow?
For: An open-source maintainer working on the Python SDK who needs to modify the agent loop while keeping unit tests and formatting checks passing

Yes, because the README gives a concrete local development entry point and verification commands for the Python SDK.

  • The repository table identifies strands-py/ as the Python SDK for the agent loop, model providers, and tools.
  • The Development section instructs maintainers to enter strands-py/ and install Hatch; hatch test runs unit tests, while hatch fmt handles formatting and linting.
  • The repository is a monorepo containing the SDKs, Harness packages, documentation site, and governance material, which helps coordinate changes across packages.
  • The project uses Apache License 2.0, permitting open-source modification and redistribution, although contribution details must still be checked in CONTRIBUTING.

The README does not state which cross-SDK compatibility tests are required for agent-loop changes, nor does it provide a Python version matrix or complete CI gate list.

  • README directory table: `strands-py/`: "Python SDK: agent loop, model providers, tools"
  • Development / Python SDK: `cd strands-py`
  • Development / Python SDK: `pip install hatch`, `hatch test`, and `hatch fmt`
  • Project data: license is Apache License 2.0
cd strands-py
Not stated in the README：The README does not list supported Python versions, all mandatory CI checks, or cross-Python/TypeScript compatibility tests.；The contributor agreement, PR review gates, and regression-test scope for agent-loop changes require the omitted CONTRIBUTING content.
Yes I am building an autonomous agent in Python and do not want to maintain model calls, tool execution, and stop conditions myself from day one. Can I start with Strands Harness and move down to the SDK when the defaults are insufficient?
For: An application developer building autonomous agents in Python who wants to validate an idea with defaults before taking control of the agent loop

Yes, because the README explicitly positions Harness as the entry point from prototyping to a controllable production agent.

  • In Python, installing strands-harness and calling create_harness() provides an assembled agent with defaults for the model, tools, memory, sessions, and context management.
  • When those defaults are insufficient, the README says you can move to the SDK and control the loop, tools, model providers, memory, sessions, and hooks yourself.
  • The agent runs in your own process rather than behind a hosted control plane, so you retain control of execution.

The README does not specify how the default model, tool permissions, or context policy will perform for your task in cost, latency, or reliability.

  • Quick Start: `pip install strands-harness`
  • Quick Start: `from strands_harness import create_harness`
  • Working with the SDK: "control every part of the agent"
  • Why Strands: "it runs in your process with no hosted control plane"
pip install strands-harness
Not stated in the README：The supplied README excerpt does not identify the exact default model, model version, or default tool list used by Harness.；It does not provide latency, token-consumption, or success-rate benchmarks for the default configuration on the target task.
It depends I need to support Amazon Bedrock, Anthropic, OpenAI, and Gemini, and may add a custom model adapter. Can I keep business code stable while changing only the model-provider configuration?
For: An enterprise platform engineer who needs to switch between Amazon Bedrock, Anthropic, OpenAI, and Gemini

It depends: Strands provides a model-provider abstraction, but it cannot remove differences in tool calling, context limits, structured output, and cost across models.

  • The README lists Amazon Bedrock, Anthropic, OpenAI, and Gemini as first-class providers, while also allowing more providers and custom adapters.
  • The “Model agnostic” section says backends can be swapped as the application scales while the code stays the same, which helps isolate business logic from model APIs.
  • However, the project insights note that tool-call formats, context windows, structured-output support, error behavior, latency, and cost still vary by model.

A simple agent may migrate easily; an agent using MCP, structured output, or complex tools still requires provider-specific validation. The README does not include a complete capability matrix.

  • Why Strands: "First-class support for Amazon Bedrock, Anthropic, OpenAI, and Gemini"
  • Why Strands: "Any model, any cloud" and "Swap backends when you scale; your code stays the same"
  • README: "many more providers and custom ones"
Not stated in the README：The README does not provide a compatibility matrix for tool calling, structured output, streaming protocols, or context windows across providers.；It does not explain which interfaces a custom model adapter must implement or how provider-specific errors should be handled.
Yes My Python application needs MCP tools, multi-agent delegation, and real-time streaming of long-running task progress. Can Strands put these capabilities into one agent loop?
For: A Python application team that already needs MCP tools and multi-agent delegation while showing progress for long-running tasks

Yes, because the README lists MCP, multi-agent patterns, and streaming as built-in capabilities of the same SDK.

  • The tool system supports MCP, allowing external tools to participate in the agent execution flow; the README also provides a dedicated MCP Server link and documentation entry.
  • Multi-agent patterns are built in and can support delegation, collaboration, or compositional workflows.
  • Streaming is intended for interactive applications and long-running tasks, allowing progress to be exposed to a frontend or caller.
  • The agent loop includes turn limits, token budgets, cancellation, and stop reasons, which provide boundaries for long tasks.

Complex combinations still introduce session, permission, state, and recovery concerns. The README does not explain MCP authentication, cross-agent state sharing, or whether stream events identify each sub-agent boundary.

  • README opening section: "MCP", "multi-agent patterns", and "streaming"
  • Why Strands: "MCP, streaming, multi-agent patterns, and structured output are all built in"
  • Opening lifecycle list: "turn limits, token budgets, cancellation, stop reasons"
Not stated in the README：The supplied README does not specify authentication, permission isolation, timeouts, or retry policies for MCP connections.；It does not describe state transfer, nested cancellation, or the streaming event model across multiple agents.
Yes I am building an interactive application with TypeScript and Node.js 22+, and I need both streamed agent output and a final result for a downstream API. Is the Strands TypeScript Harness and SDK suitable?
For: A TypeScript web or server-side engineer running on Node.js 22+ who needs streaming output and structured results

Yes, because the project provides a TypeScript Harness and SDK together with streaming and structured-output capabilities, matching both interface requirements.

  • The README lists harness-ts/, which creates a complete agent through createHarness(), while strands-ts/ provides the agent loop, model providers, and tools.
  • Streaming and structured output are explicitly listed as built-in capabilities. Structured results can feed a downstream API, while streaming supports an interactive UI.
  • Project data shows TypeScript is one of the two main implementations, and the monorepo maintains both Python and TypeScript packages.

However, two SDKs do not guarantee identical edge-case behavior. The README does not provide a Node.js compatibility matrix, streaming event schema, or a precise error contract for invalid structured output.

  • README directory table: `harness-ts/` and `strands-ts/`
  • Why Strands: "MCP, streaming, multi-agent patterns, and structured output are all built in"
  • Project data: the language distribution includes Python and TypeScript
npm ci
Not stated in the README：The supplied README does not state the minimum Node.js 22+ requirement or compatibility range for each TypeScript package.；It does not specify the streaming event types, backpressure behavior, or handling of structured-output validation failures.
It depends I need to deploy a production agent in my own process without relying on a hosted control plane, and I require tracing, guardrails, cancellation, turn limits, and token budgets. Can this project cover those runtime controls?
For: A Python platform team preparing a production deployment that requires in-process execution, tracing, guardrails, cancellation, and token budgets

It depends: the SDK covers major agent runtime controls, but it is not a complete enterprise-hosted platform.

  • The README explicitly says agents run in the user’s process without a hosted control plane, matching the deployment-control requirement.
  • Lifecycle controls include turn limits, token budgets, cancellation, and stop reasons; hooks can intercept, log, validate, or redirect execution steps.
  • The README also lists guardrails, tracing, and evals, showing that production governance and observability are within the SDK’s scope.
  • However, the project insights state that autoscaling, secret management, permissions, queues, persistence, and SLA guarantees remain the user’s responsibility. Project data shows only 5 releases, with the latest harness-cli/v0.1.2.

It is therefore suitable as an in-process agent SDK, but should not be treated as a complete production execution platform.

  • README opening section: "it runs in your process with no hosted control plane"
  • README opening section: "turn limits, token budgets, cancellation, stop reasons"
  • Why Strands: "Hooks let you intercept any step to log it, validate it, or redirect it"
  • Project data: release_count is 5 and latest_release is `harness-cli/v0.1.2`
Not stated in the README：The README does not state which queueing, persistence, recovery, or cross-process execution options are supported for production.；It does not specify integrations for enterprise secret management, tenant isolation, auditing, SLAs, or autoscaling.；The data does not establish whether the 5 releases represent the maturity of every component or only repository release records.

✨ Highlights

  • create_harness() assembles models, tools, memory, and sessions
  • Supports Bedrock, Anthropic, OpenAI, and Gemini
  • Includes MCP, streaming, guardrails, and tracing
  • The latest release is harness-cli/v0.1.2 across 5 releases

🔧 Engineering

  • Python create_harness() provides a fully assembled agent
  • The agent loop supports turn limits, token budgets, and cancellation
  • Hooks intercept every step, while Guardrails catch errors before execution
  • The strands CLI prototypes and chats with a Harness agent in the terminal

⚠️ Risks

  • The Python SDK requires Python 3.10+, while TypeScript requires Node.js 22+
  • The latest release is harness-cli/v0.1.2, with only 5 releases
  • The README explicitly says it runs in-process without a hosted control plane
  • create_harness() has benchmarked defaults, but no metrics are provided

👥 For who?

  • Teams building model-agnostic agents with Python 3.10+
  • Agent engineers using Node.js 22+ and TypeScript
  • Application teams needing MCP, memory, sessions, and multi-agent patterns