Five ways multi-agent coding breaks at context handoffs

The handoff boundary where clean context drops critical state

When I examine the architecture of modern agent harnesses, the most fragile seam is the delegation boundary. Rather than executing within a continuous, unbroken session, subagents in modern harnesses operate inside isolated contexts. Systems like Cursor and Claude Code treat this isolation as a feature: in Cursor, subagents start with a clean context, requiring the parent agent to pack all relevant background into the dispatch prompt. The subagent then executes autonomously and returns a final message containing its results. Similarly, Claude Code subagents receive only their own dedicated system prompt alongside basic environment details, explicitly omitting the main Claude Code system prompt. They execute side tasks entirely in their own context and hand back only a summary.

This architecture creates a structural filter. Anthropic notes that a research subagent may churn through tens of thousands of tokens during its execution loop, only to condense its entire operational narrative into a summary of 1,000 to 2,000 tokens for the coordinator.

In the flow diagram above, look closely at how state narrows between execution stages. The main agent explores and decides, compresses its state into a prompt summary, and delegates. The subagent operates strictly from that summary, and its final response is compressed once more before merging back into the parent plan. Every traversal across that boundary drops intermediate reasoning.

In the video explainer above, observe the visual progression from clean starts to context drift. Notice how copying the initial task fails to capture the multi-turn conversations and tool invocations that actually shape runtime interpretation, demonstrating why the clean-context boundary acts as a lossy compression bottleneck rather than a clean abstraction layer.

When a coordinator condenses an operational trace into a brief markdown dispatch, subtle decisions evaporate. In codebases where directory structures, local build caveats, and framework idiosyncrasies are uncovered across dozens of terminal turns, a clean-context dispatch strips away the exact nuances the subagent needs to interpret its objective correctly. The subagent receives the explicit goal, but none of the hard-won implicit constraints discovered during previous turns.

Split-and-merge blindness and conflicting implicit decisions

The operational failure that drains the most engineering time in multi-agent architectures is split-and-merge blindness. Cognition characterizes the pattern of splitting work across parallel subagents and aggregating their results as tempting but very fragile. The fundamental breakdown is concurrency-related: actions carry implicit decisions, and conflicting decisions produce broken software.

When a coordinator splits an implementation across parallel subagents, each worker operates in an informational silo. Even when parallel subagents share the initial task context, they cannot observe each other's execution traces. In practice, this means Worker A might refactor a core data model to use immutability while Worker B simultaneously introduces in-place mutations across consumer endpoints. Both implementations compile cleanly within their local subagent contexts, but they cannot co-exist in the target repository.

This failure mode is exacerbated by a fundamental mismatch in task characteristics. As Anthropic notes, most coding tasks offer far fewer truly parallelizable subtasks than open-ended research. Software modules are tightly coupled by type systems, state management, and shared runtime lifecycles. When a coordinator attempts to parallelize tasks that have hidden interdependencies, coordination overhead spikes dramatically. Anthropic's data highlights the steep token cost: while single agents consume approximately 4 times more tokens than standard chats, multi-agent configurations consume about 15 times more tokens.

In the failure points diagram above, trace the divergence path from the main context down to the merged output. When vague task boundaries are written into the delegation prompt, each subagent fills the vacuum with its own local assumptions. Anthropic observed that short coordinator instructions frequently cause subagents to misread tasks, duplicate each other's searches, or leave critical gaps in the implementation. Without continuous mutual visibility, parallel agents inevitably drift, generating work that must either be laboriously reconciled by the coordinator or discarded entirely. I explore the physical realities of code environments over generative context in The Codebase Is an Environment, Not an Autoregressive Window.

The compaction trap of discarding multi-turn tool traces

Delegating work to a clean-context subagent mechanically mirrors session-level context compaction. Anthropic defines compaction as summarizing an in-flight conversation near the context limit and restarting a new context window around that summary. In both paradigms, thousands of tokens of rich tool interactions, command outputs, and exploratory back-and-forth are crushed into a brief narrative abstract.

In the comparison diagram above, look at the structural equivalence between compaction and subagent dispatch. In both workflows, long histories are reduced to an abbreviated summary that either restarts the current agent or seeds a secondary worker. In both paths, intermediate execution details vanish from the active context.

The prevailing industry assumption has been that subagent isolation improves code reasoning by stripping noisy intermediate tool calls from the main thread. However, the published research does not show that isolating subagents improves code correctness over linear traces. Furthermore, there is currently no public benchmark measuring handoff information loss in coding agents. We are adopting architectures that fragment conversational traces without empirical verification that the resulting code quality exceeds continuous execution.

The most severe consequence of this compaction dynamic is the erasure of negative knowledge. When an agent explores a repository, its most valuable context is often the paths that failed: the dependency version that threw an obscure runtime exception, the configuration flag that silently crashed a test suite, or the internal API that timed out.

When this negative trace is omitted from a handoff, the receiving subagent exhibits severe context amnesia. It naively re-attempts the exact dead-end approaches the parent already eliminated. For long-running maintenance and implementation tasks, this produces endless circular tool runs. I evaluate the balance between session compression and context preservation in In-Session Context Compaction or Isolated Subagent Threads for Long-Running Coding Agents. When multi-turn tool interactions are discarded, you do not get a cleaner agent; you get an uninformed agent forced to rediscover repository ground truths from scratch.

The coordinator telephone game and runaway token multipliers

When work filters through a multi-tiered hierarchy, architectural fidelity degrades at every boundary. In an agent tree where a coordinator parses a root task, synthesizes dispatches for subagents, and reconciles their outputs, each layer acts as a subjective reinterpretation engine. Anthropic documented that short lead-agent instructions were frequently vague enough that subagents misread the task, duplicated searches already conducted by other agents, or left blatant functional gaps. When delegating without an explicit objective, output format, tool guidance, and defined task boundaries, workers fill in the missing constraints with arbitrary guesses.

This tiered communication chain creates a literal game of telephone. A specification establishing an invariant—such as strict thread safety or zero external runtime dependencies—gets paraphrased into a broad objective when dispatched to an intermediate coordinator. By the time that coordinator issues sub-prompts to specialized leaf workers, the original constraint has vanished entirely.

The operational economics of this architecture are punishing. In Anthropic's data, single autonomous agents consume approximately 4 times more tokens than standard chats, but multi-agent configurations consume about 15 times more tokens. Much of this consumption is pure coordination waste: leaf workers repeatedly scanning identical repository paths, coordinators summarizing long histories back and forth, and models generating descriptive prose instead of code diffs.

Compounding this token burn is execution latency. Anthropic notes that lead agents typically execute subagents synchronously. While synchronous batching simplifies state tracking, it transforms the coordinator into a rigid bottleneck. The parent agent stalls completely while waiting for every worker in a batch to return its summary. If one subagent misinterprets a vague prompt and enters an expansive, redundant file-search loop, the entire tree sits idle. The system consumes 15 times more tokens while stalling behind synchronous coordinators, spending capital not on accelerated delivery, but on coordinating the loss of context.

A diagnostic triage guide for subagent handoff breakdowns

Diagnosing failures in multi-agent workflows requires looking at the physical evidence left in diffs, tool traces, and terminal streams. Because subagents fail silently behind polished final summaries, operators cannot rely on the coordinator's narrative to understand why a build broke.

First Observable Symptom	Failure Type	Immediate Diagnostic Check
Disjoint diffs with duplicate helper functions or mismatched shared interfaces	Split-and-merge blindness	Inspect git diff for simultaneous edits to overlapping abstractions by concurrent workers
Worker re-executing searches or invalid package installs already discarded in the session	Context amnesia	Check the dispatch prompt payload to verify if negative execution traces were omitted
Runaway token metrics with zero file edits or long idling coordinator processes	Synchronous blocking	Inspect process traces to see if the lead agent is blocked awaiting a subagent batch
Missing edge-case handling or omitted requirements present in the initial user prompt	Telephone game degradation	Compare the leaf subagent's system prompt directly against the root coordinator's objective

To systematically evaluate whether a multi-agent harness is pulling its weight, run an outside check against a single-threaded baseline. Track the token overhead ratio: calculate the total tokens consumed by the multi-agent run divided by the tokens consumed by a linear, single-agent session executing the identical prompt. If that multiplier approaches Anthropic's observed 15-times mark without producing a proportional drop in human review time, handoff overhead is dominating execution. Simultaneously, audit the patch duplication rate by checking whether multiple workers generated redundant utility functions or duplicated dependency lookups. If workers repeatedly explore the same directory subtrees, the task boundaries in the delegation prompts have failed to partition the problem space.

Architecting continuous context across agent boundaries

Fixing the delegation seam requires abandoning informal narrative handoffs in favor of architectures that maintain state continuity. Modern systems implement context engineering—the deliberate control of what each agent sees—through distinct structural patterns.

In the architecture diagram above, look at how the execution paths preserve context rather than crushing it through narrative prompts. Instead of discarding history or serializing intermediate tool calls through a coordinator, state flows either through continuous execution traces or across stable, external storage anchors.

The cleanest foundation is Cognition's core principle: share context, including full agent traces rather than individual messages. Because actions carry implicit decisions, Cognition recommends a single-threaded linear agent as the simplest way to maintain continuous context. When tasks expand toward context boundaries, Cognition describes adding a compression model that summarizes action and conversation history into key details, events, and decisions, preserving critical negative paths and choices without wiping the operational slate.

When domain isolation or side investigations are genuinely necessary, frameworks provide mechanisms to bypass the clean-context bottleneck:

1. Session forking over clean slates: Rather than spinning up an empty context, Claude Code supports forks—subagents that inherit the entire conversation history instead of starting fresh. This gives the worker full access to previous tool attempts and user instructions. For shared development phases like planning, implementation, and testing, Claude Code advises keeping work inside the main conversation.
2. Filesystem-backed artifact passing: To eliminate the game of telephone, Anthropic has subagents store their generated work in external systems and pass lightweight references back to the coordinator. Writing structured outputs directly to the filesystem ensures that downstream consumers read raw artifacts rather than degraded narrative retellings. For parallel file modifications, Claude Code provides worktree isolation, giving subagents dedicated copies of the repository to prevent conflicting file edits.
3. Structured history filtering: The OpenAI Agents SDK takes the opposite default of Cursor and Claude Code: handoffs pass the entire conversation history to the receiving agent automatically. When full history would pollute the receiving model's context, developers explicitly shape the boundary using tools like input_filter, nest_handoff_history, or handoff_history_mapper to filter out intermediate tool noise while preserving the foundational execution trace:

from agents import Agent, handoff
from agents.extensions import handoff_filters

agent = Agent(name="FAQ agent")

handoff_obj = handoff(
    agent=agent,
    input_filter=handoff_filters.remove_all_tools,  # (1)!
)

By substituting structured history filters and externalized filesystem artifacts for ad-hoc prose summaries, engineering teams can eliminate the informational blind spots that plague multi-agent development. I examine the broader design landscape of session continuity in Amnesic Process Resets or Persistent Context for Autonomous Coding Agents.

Resources

• Don't Build Multi-Agents (Cognition, Walden Yan, 2025-06-12)
• How we built our multi-agent research system (Anthropic Engineering)
• Effective context engineering for AI agents (Anthropic Engineering)
• Create custom subagents (Claude Code docs)
• Handoffs (OpenAI Agents SDK for Python)
• Subagents (Cursor docs)
• Subagents (Codex docs, ChatGPT Learn)
• Multi-agent (LangChain docs)