Claude for Long-Horizon Tasks — Lance Martin, Anthropic

Lance Martin, a Member of Technical Staff at Anthropic, discusses the evolution of Claude models and the architectural shifts required to enable reliable and secure long-horizon tasks. He highlights how the task horizon of Claude models has dramatically increased, from 10-20 minutes with Opus 3 (suitable for chat/autocomplete) to hours with synchronous coding agents like Claude Code, and now to significantly longer periods with Managed Agents. This increase in capability has driven the evolution of API surfaces, from the basic Messages API to the Agent SDK, and finally to the Managed Agents API which packages both the harness and deployment infrastructure.

Martin introduces four core themes underpinning this new generation of asynchronous agents:

1. Decoupling the Brain from the Hands

Initially, Anthropic’s agent harnesses placed the brain (the harness) and hands (the execution sandbox) in the same container. This architecture posed two critical problems: loss of session if the container died, and security risks from placing credentials within the agent’s environment, especially for long-running tasks. The solution adopted for Managed Agents involves a decoupled architecture where:

• The harness (brain) is a stateless process.
• It communicates with a session, an append-only event log that ensures reliability and persistence.
• Hands are separate, ephemeral containers (sandboxes) where work is executed.
• Credentials are stored in a separate vault, never directly exposed to the sandbox.

This decoupling makes agents more reliable, as the session state is preserved even if a sandbox or harness fails, and more secure. An interesting byproduct is that the session acts as an immutable, persistent external context object, allowing the model to interrogate past context without destructive compaction, thus improving context management for long-horizon tasks, akin to recursive language models.

2. Using Verifiers

Traditional methods often involve models grading their own work within the same context, which can lead to confabulation and unreliable self-assessment. Martin advocates for separating verification into a separate context window using independent verifier models. This loops paradigm works as follows:

• A build agent/context performs the primary task.
• A verifier agent/context, tuned specifically for critical verification, evaluates the build agent’s output against a predefined goal or rubric.
• The process continues in a loop until the verifier confirms the outcome is achieved.

This approach encodes steering signals into the environment, allowing the model to self-correct based on feedback from the verifier rather than direct human intervention. This has shown to yield very strong results, particularly with high-capacity models, as demonstrated in benchmarks like Parameter Golf.

3. Self-Learning (Memory Systems)

Drawing an analogy to human memory (short-term hippocampal memory and long-term cortical memory consolidated during dreaming), Martin explains how Claude agents employ similar principles for self-learning:

• In-band Memory Writing: Agents are given memory tools (e.g., access to write to a file system/memory directory). Newer, higher-capacity models (e.g., Claude 4.6 vs. Sonnet 3.5) demonstrate significant improvements in writing strategic and generalizable memories during task execution. They are better at abstracting lessons for future use rather than just logging specific facts.

• Dreaming (Offline Memory Consolidation): Since in-band memory writing can be locally optimal or even incorrect, an offline or out-of-band dreaming process is used to consolidate and correct memories. Martin illustrates this with a Pokémon example where Claude consistently falls into a trapdoor due to an incorrect in-band memory. The dreaming process reviews past sessions and memory traces to identify and correct these errors, enabling successful task completion. The key insight is to let the model manage its own memory structure on general substrates (like file systems or databases) rather than imposing a prescriptive memory schema.

4. Evolving Agent Harnesses: Org-level, Proactive, and Multiplayer

The final theme addresses the shift from single-player agents (like local Claude Code instances) to multiplayer, organizational-level harnesses. Claude Tag, often mistakenly viewed as just a Slack bot, exemplifies this shift. Its significance lies in being an org-level harness with:

• Its own identity and access to organizational context, not tied to individual user credentials.
• Benefits: Deduplicating findings, facilitating internal research, and providing a level playing field for all employees by offering a pre-configured, capable harness from day one.

Future trends for asynchronous agents include: harnesses operating across organizations, agents becoming increasingly proactive (steering themselves and alerting users based on organizational context), and multiplayer user experiences where a single harness can be steered concurrently by many different individuals.

In essence, building robust long-horizon agents requires not just powerful models but also sophisticated architecture (decoupling), self-correction mechanisms (verifiers), advanced memory management (in-band and dreaming), and a shift towards collaborative, organizational-level deployments.

• Tags:
• AI Agents
• Feature
• Anthropic
• Claude
• Memory Management
• Long-Horizon Tasks
• Agent Architecture
• Managed Agents
• Decoupling Brain Hands
• Self-Verification
• Verifiers
• Self-Learning Agents
• In-Band Memory
• Dreaming Process
• Organizational AI
• Proactive Agents
• Multiplayer Agents