Evolution of agentic surfaces — Gagan Bhat & Isabella Kai He, Anthropic

Anthropic's Gagan Bhat and Isabella Kai He discuss how agent harnesses must evolve rapidly to keep pace with fast-improving LLMs. They introduce Claude Managed Agents, an architecture that decouples the agent's 'brain' (reasoning) from its 'hands' (tool execution) to address issues like stale assumptions, latency, and reliability. This approach enables dynamic adaptation, secure tool execution, and features like 'dreaming' for self-improving agents and 'outcomes' for goal-oriented task completion, ultimately aiming to close the gap between model capabilities and product offerings.

August 11, 2026 6 min read

Gagan Bhat and Isabella Kai He from Anthropic’s Applied AI team discuss the evolution of agentic surfaces and the critical need for harnesses to adapt swiftly to the rapid advancements in large language models. They emphasize that while models like Claude are continually improving, the static nature of many agent harnesses often becomes a limiting factor.

Evolution of Agentic Surfaces

Initially, the Messages API allowed basic token-in, token-out interactions. As task complexity grew, developers were forced to manually build a custom “agentic loop” to manage context and tool interactions, which was painstaking. This led to significant production infrastructure challenges related to hosting, scaling, session management, file system access, execution isolation, credential handling, and observability, diverting focus from product innovation.

The Claude Agent SDK emerged as the next step, packaging a built-in agentic loop, file system access, and sandboxing. While it offered primitives for session management and observability, developers still had to hand-roll aspects like credentials and hosting infrastructure.

Anthropic’s solution, Claude Managed Agents, aims to offload these infrastructural burdens entirely. It provides a “brain” (the agentic loop and Claude model) and “hands” (a just-in-time sandboxed tool execution environment), alongside managed production infrastructure for credentials, session management, observability, and hosting. This allows developers to focus solely on their product, task, context, and domain knowledge.

Engineering Principles of Claude Managed Agents

The core principle behind Claude Managed Agents is that “harnesses encode assumptions about what Claude cannot do on its own,” and these assumptions quickly become stale as models improve.

Context Anxiety Example: With Sonnet 4.5, a behavior called “context anxiety” caused the model to prematurely terminate tasks when approaching its context window limit. Anthropic’s team built context resets into the harness to compensate. However, when Opus 4.5 was released, this behavior disappeared, rendering the previous fix “pure overhead, adding things like latency and causing issues with the cache being discarded incorrectly.” This illustrated that “when the model moves and the harness doesn’t, it degrades the agent.”
Designing for Future Capabilities: An effective harness must be designed for the model capabilities of tomorrow, anticipating advancements and being agile enough to quickly iterate and capture new features.
Long-Running Agents: Modern agents are increasingly asynchronous, complex, and long-running (hours or days). This demands robust context engineering, secure sandboxing, high reliability, and the ability to parallelize workflows.

Decoupling the Brain from the Hands

A pivotal architectural decision for Claude Managed Agents is the decoupling of the agent’s “brain” (the agent loop) from its “hands” (the tool execution environment).

Initial Limitations: Initially, housing both in a single container meant the model’s reasoning was blocked until the container was fully set up, and failure in one component brought down the whole agent.
Benefits of Decoupling: This separation significantly improves reliability (e.g., a dead sandbox can be retried, a dead brain can resume from a durable session log) and reduces latency. By allowing model reasoning to start immediately while container setup runs in parallel, Anthropic measured a 60% faster time to first token at P50 and over 90% faster at P95.

Three Core Primitives

Claude Managed Agents are built around three core primitives:

Agent: Defines the agent’s specific role, including the model, prompts, tools, and skills.
Environment: The isolated container where the agent runs, which can be shared across multiple sessions.
Session: A durable, cloud-persisted resource that combines an agent and an environment, logging every interaction and enabling observability, long-running instances, and reliability.

This structure enables four distinct session states (idle, running, rescheduling, terminated) for robust error recovery. Furthermore, because all interactions are logged to a durable session log, the harness can recover discarded context by re-reading slices from the log, even if Claude prematurely removes information from its current window.

Developers retain ownership over context management and domain expertise (system prompts, skills, custom tools), while Anthropic manages the agent loop, memory, and observability infrastructure.

Demo: SRE Investigator Agent

Bhat demonstrated building an SRE Investigator agent to diagnose a latency spike. This involved:

Defining the Agent (SRE Investigator using Claude Opus 48, system prompt, and tools like Bash, Grep, Blob, and a custom MCP tool for dashboard metrics).
Configuring an Environment (SRE sandbox in Anthropic cloud, with networking limited to the MCP server for security).
Providing Evidence (uploading application logs).
Kicking off a Session to combine these elements. The agent then used its tools to grep logs, analyze metrics, identify recent deploys, and synthesize a root cause. The observability dashboard provides a detailed event trace and session logs.

Lessons Learned from the Field

Keep credentials away from the agent: Decoupling the brain from the hands, combined with “vaults,” ensures credentials are decrypted only at tool execution runtime, preventing the model from ever seeing sensitive tokens.
Latency improvements from decoupling: Parallel execution of model reasoning and container setup leads to significant latency reductions.
Session logs as memory and self-improvement: The comprehensive session logs provide deep observability. When combined with a process called “dreaming,” they enable agents to update and improve their memory over time, leading to self-improving agents.
Security for tool execution: Features like self-hosted sandboxes allow customers to run tool execution environments within their own Virtual Private Clouds (VPCs) for granular control. MCP tunnels enable agents to securely access internal MCP servers without exposing them to the public internet.

Frontier Features: Dreaming and Outcomes

Anthropic is actively developing new features to further enhance agent capabilities:

Dreaming: This periodic batch process feeds session logs and the agent’s current memory state to Claude, allowing it to extract new insights, reorganize structures, and rewrite its memory. This leads to “self-improving agents” that get smarter with each session and forms a cornerstone of a unified, organizational-scale memory system.
Outcomes: This feature allows users to define success criteria and failure cases for their agents. A separate “grader agent” runs alongside, evaluating the primary agent’s performance against the defined rubric. If the task isn’t successfully completed, the agent keeps iterating until it meets the success criteria. This pushes towards agents that understand what success means and reliably achieve complex goals.

In conclusion, Gagan and Isabella assert that harnesses have become the primary limiting factor in fully leveraging the rapidly evolving capabilities of LLMs. Claude Managed Agents, with its foundational architecture and ongoing feature development, aims to close this gap and provide a production-ready harness for frontier intelligence.