I spent six weeks debugging a handoff that looked perfect in the trace. The planner produced a clean, well-structured plan. The executor followed it step by step. And every handoff between them lost a little bit of truth.
Not enough to fail. Just enough to make the system slower, more expensive, and quietly wrong in ways nobody could name. I kept tuning prompts. The planner needed more detail. The executor needed clearer instructions. I upgraded the executor to a stronger model. Nothing helped, because I was diagnosing a communication problem as a reasoning problem.
The research had already named what I was hitting. Microsoft's Agent Framework training calls it context collapse — the most common failure in handoff chains, where accumulated information loss through repeated summarization degrades the signal until the receiving agent is operating on a shadow of what the sender knew. The fix isn't a better prompt. It's a different protocol for what crosses the boundary.
The Handoff Tax Nobody Itemizes
The first place the loss shows up is in the arithmetic. A 2026 paper titled "Attention Tax, Handoff Tax" models the exact trade most teams miss: decomposition reduces the burden of long contexts, but incurs a handoff tax when information is compressed or transferred between agents. The question isn't whether to decompose. It's whether the attention cost you avoid by resetting context exceeds the handoff cost you pay for the transfer.
For most of my handoffs, it didn't. The receiver wasn't information-starved because it was weak. It was information-starved because the handoff had stripped the signal before the receiver ever saw it.
The numbers from the literature are consistent. A closed-world study on two-agent LLM relays found that hand-off representation strongly affects downstream feasibility under a small decision model, with constraint checking benefiting from structured and auditable representations rather than relying on brevity alone. My handoffs were brief. They were not auditable.
The Constraint That Disappears Without Notice
The deeper failure isn't just missing data. It's binding state that stops binding.
A 2026 paper studied exactly this in controlled episodes. Upstream state gets transformed into intermediate language artifacts — summaries, plans, handoff notes — from which downstream components act. The finding is the one that should be taped to every handoff design review: semantic availability does not guarantee operational preservation. An artifact can mention an unresolved condition while changing its role from something that must be resolved before execution to something that may inform but no longer determines the next action. The information is still there. The constraint is gone.
The GitHub issue from a production LangChain planner-executor split documents the exact symptom. The planner calls web_fetch three times, finds the answer, and writes it into the handoff text. The executor, receiving only the text, calls web_fetch three more times, walks the same wrong paths, and burns the same latency again. The two sessions don't share tool call history, fetched data, or session state. The executor can't tell whether the planner's answer is verified or provisional, fresh or stale. It re-derives everything from prose that was never designed to carry operational state.
I had been verifying executor output. I had not been verifying that the executor received the constraints the planner had established.
The Three Layers of Loss
The failures compound across three layers, and each one needs a different fix.
Layer one: the handoff itself. Every compression boundary loses information. Microsoft's guidance is blunt: prevent context collapse by writing agent instructions that return full structured outputs rather than summaries, and rely on the framework's automatic context broadcast to give receiving agents complete history. The fix isn't a better summary. It's not summarizing at all when the framework can carry the full state.
Layer two: the representation. Even a full handoff can lose binding state if the representation doesn't distinguish between "this is background" and "this is a constraint." The structured output protocol pattern addresses this directly: every specialist ends a handoff with both human-readable prose and a machine-readable JSON block, so the receiving agent can parse constraints reliably. Pure prose throws away the "why." Pure JSON throws away the "why." You need both.
Layer three: the verification. The receiving agent must be able to check whether the handoff preserved what it was supposed to preserve. A schema check is necessary but nowhere near sufficient. A handoff can conform perfectly to a schema and still drop the prerequisite, the authority, or the execution consequence. The "When 'Must' Becomes 'Maybe'" paper found that restoring all four state fields — prerequisite, authority, fallback, and execution consequence — raised preservation to 100% and reduced forbidden action to zero, while downstream verification alone left artifact deactivation at 95.3%. The check caught the symptom, not the cause.
The Context Preservation Protocol
The fix isn't abandoning handoffs. It's making the coupling explicit instead of pretending it doesn't exist.
Contracts, not prompts. The A2A protocol's central abstraction is a stateful Task object that persists across whatever happens next — the delegating agent going offline, the receiving agent failing partway through, both systems disappearing and reappearing multiple times before work completes. The task carries the state, not the prompt. The receiving agent doesn't reconstruct from a summary. It reads the task's current state and continues.
Base context plus incremental deltas. Microsoft's guidance is precise: maintain base context plus incremental deltas rather than repeatedly resummarizing. Each handoff appends what changed, not a new summary of everything. The full history stays intact. The delta is what's new. The receiving agent gets both.
Structured handoff receipts. The Zenodo handoff receipt protocol specifies that on session restart, an agent must check for the most recent state file, output a [HANDOFF RECEIVED] block, and absorb context_needed and next_session.first_actions. The handoff isn't a message. It's a receipt that the receiver acknowledges and acts on.
Chain depth limits. Microsoft's own guidance recommends a maximum of three to four handoffs before consolidation, because context management becomes unwieldy beyond that. I had been chaining seven. The research says the signal decays faster than the chain grows.
Durable delegation ledgers. The deer-flow project's fix is a system-maintained ledger kept in state and re-injected into context on every model call, recording what was already delegated and its status so the lead doesn't re-delegate overlapping subtasks. The ledger survives summarization because it's state, not prose.
What Production Teams Are Running
Microsoft Agent Framework automatically synchronizes full conversation history across all participants in a handoff workflow. The built-in context broadcast is the foundation of every reliability pattern in the module — agents rely on shared history rather than manually compressed summaries, with designed recovery for handoff failures.
UNIHODL's Agent Handoff SDK calls itself a decision-continuity protocol for human-to-agent and agent-to-agent work transfer. The receiving agent gets open tabs, scroll positions, video timestamps, an AI-tagged decision thread, partial conclusions, and intended next step — not just a list of links.
AAHP v3 solves the context collapse problem by replacing verbose chat history transfer with a structured, compressed handoff state that preserves the binding constraints while dropping the noise.
ESAA-Conversational applies event sourcing to handoff across heterogeneous agents: a cold agent begins with handoff.md, state.md, decisions.md, tasks.json, and a selective context window projected deterministically from the event log.
The Trade-Off You're Accepting
Context preservation isn't free. You're accepting more infrastructure — a state store, a ledger, a receipt protocol — and you're writing more code upfront. You're designing what crosses the boundary instead of hoping the model figures it out.
You're also accepting that some handoffs will be slower. Every structured output, every receipt acknowledgment, every ledger check adds a round-trip. The research on the handoff tax is honest about this: decomposition becomes preferable only when the attention cost avoided by resetting context exceeds the handoff cost. For short tasks with small contexts, the handoff isn't worth it. For long tasks where a single agent would saturate its window, the handoff pays for itself.
And you're accepting that the boundary is the hard part. The teams I've seen win this treat the handoff as carefully as they design the agents on either side of it. The ones that lose treat it as plumbing and wonder why the water tastes wrong.
So here's my question: When your agent hands off work, does the receiver inherit the constraints the sender established — or just a summary that mentions them?
I'd love to hear where you've landed. Full context broadcast, structured deltas, a delegation ledger, or a handoff you've quietly merged back into a single agent — and what finally made you stop tuning prompts and start designing the boundary?
Top comments (0)