Anthropic’s Official Harness Launch: A Complete Breakdown of Managed Agents
Introducing Claude Managed Agents: Composable APIs for Cloud-Hosted AI Agents
Unlike typical agent frameworks, our core offering is Harness — a finely-tuned orchestration engine that drives the entire agent loop. It intelligently handles tool‑calling decisions, manages context, recovers from errors, and evolves automatically as our models advance.
Built for developers who demand reliability at scale, Claude Managed Agents remove the overhead of building, maintaining, and iterating on complex agent logic — so you can focus on what matters most: creating seamless AI experiences.
🚀 Now available. Start building with the orchestration engine that grows smarter over time.
Production-Ready Infrastructure for AI Agents That Think and Act Autonomously
Until now, building a reliable, long-running AI agent capable of using tools was a massive infrastructure challenge. Companies faced the daunting task of constructing sandboxes, managing state, handling permissions, and writing complex error-recovery logic—often work that outweighed the agent’s core business logic.
Claude Managed Agents closes this gap. You define the agent’s task, tools, and constraints. Anthropic runs it.
We provide the complete, cloud-hosted environment for agents that operate over hours, execute code, and recover from failures—so you can focus on what your agent does, not how it’s built.
What It Does
-
Production‑Grade Sandbox: Each agent runs in a secure, isolated cloud container. Pre‑load environments (Python, Node.js, Go), configure network access, and mount files. Code execution, file editing, and command runs are contained and safe.
-
Long‑Running, Persistent Sessions: Agents can operate autonomously for hours. Sessions persist through disconnections, with progress and outputs saved, eliminating the “what if it crashes mid‑task?” problem.
-
Built‑In Orchestration (The Harness): At the core is the Harness—a finely‑tuned orchestration engine that automates tool‑calling decisions, context management, and error recovery. It includes performance optimizations like prompt caching and compaction, and evolves as our models improve.
-
Governance & Observability: Built‑in tools for scoped permissions, identity management, and full execution tracing. Inspect every tool call, decision point, and failure mode directly in the Claude Console, with integrated analytics.
-
Multi‑Agent Coordination & Self‑Evaluation (Research Preview):
-
Enable agents to launch sub‑agents for parallel task execution.
-
Define success criteria and let the agent iterate autonomously until goals are met. In internal testing, this self‑evaluation improved success rates in structured output generation by up to 10 percentage points, with the largest gains on the most complex tasks.
-
Define your agent through natural language description or a structured YAML file. Supports MCP servers and Agent Skills for extended capabilities.
How the Harness Works: Decoupling the Brain from the Hands
The most profound technical insight behind this release is articulated in our engineering blog: “Scaling Managed Agents: Decoupling the brain from thehands.”
The Harness encodes assumptions about what the model cannot do—assumptions that will become outdated. For example, Sonnet 3.5 exhibited “context anxiety” near its token limit, prompting us to add context‑resets to the Harness. This behavior vanished in Opus 3.5, making those resets unnecessary overhead.
Therefore, Managed Agents are designed for programs that haven’t been written yet—a philosophy borrowed from operating systems, which virtualize hardware (processes, files) to support software that doesn’t yet exist. The abstraction outlives the underlying components.
The Three‑Layer Virtualization
We virtualize the agent into three independent, decoupled interfaces:
-
Session: An append‑only log of all events, stored persistently outsidethe Harness.
-
Harness: The orchestration loop that calls Claude and routes its tool requests to the correct infrastructure.
-
Sandbox: The containerized environment where Claude executes code and edits files.
This decoupling means any one component can fail, be upgraded, or be replaced without impacting the others. It’s a system built for resilience and continuous evolution.
Build the Future, Not the Plumbing
Stop wrestling with infrastructure. Start deploying intelligent agents that work reliably, at scale.
Claude Managed Agents are available now. Begin building on the orchestration engine that grows smarter over time.
From Pets to Livestock: The Architecture That Powers Reliability
In early designs, we bundled all agent components into a single container. The benefit was raw efficiency: file operations were direct system calls, with no service boundaries. But the cost was operational fragility. That container became a “pet”—unique, cherished, and when it broke, you had to nurse it back to health.
Managed Agents are built as “livestock.” If one component fails, you replace it. The herd continues.
Our three-layer virtualization—separating Session, Harness, and Sandbox—turns agents into scalable, resilient, and replaceable units. Sessions persist independently, the orchestration loop is stateless, and sandboxes are ephemeral. This means you can upgrade, restart, or horizontally scale any layer without losing state or breaking the agent’s workflow.
It’s the shift from bespoke infrastructure to standardized, operationalized systems—engineered not for simplicity, but for reliability at scale.
After decoupling, the containers become livestock. The Harness calls a container via
execute(name, input) → string, just like any other tool. If a container fails, the Harness captures the error and passes it to Claude, who decides whether to retry. A retry simply launches a new container.The Harness itself becomes livestock, too. Since the Session log lives outside the Harness, nothing is lost if it crashes. A new Harness instance starts via
wake(sessionId)and continues right where the previous one left off.This decoupling also cleans up the security boundary. In a coupled design, Claude’s untrusted code runs in the same container as your credentials. After decoupling, credentials never enter the sandbox. Git tokens are written to a local remote during initialization—the Agent never handles them directly. OAuth tokens reside in a secure vault and are accessed via a proxy.
A Session is not a context window.
Long tasks often exceed Claude’s context limit. Compression, truncation, and summarization are irreversible operations that can discard information needed later. The Session persists everything—the complete, immutable log of the agent’s work—so the model can always look back without losing detail. Think of the context window as working memory, and the Session as the full audit trail.
The Session: A Persistent Log Beyond the Context Window
Managed Agents handle this by maintaining the Session as an independent, persistent context object that exists outsidethe model's context window. The Harness can fetch slices of the event stream on demand via
getEvents(), enabling it to "rewind" to any point in time and re-read the context that led there.Multiple Brains, Multiple Hands
Decoupling unlocks new scaling capabilities. In the old coupled design, the Harness lived inside the container, so each agent session had to wait for the container to be fully provisioned before reasoning could begin. After decoupling, the reasoning process can start beforethe execution container is ready.
The result? A dramatic reduction in latency. The time-to-first-token (TTFT) improved by approximately 60% at the median (p50) and by over 90% at the 95th percentile (p95).
