2026 Agent Handoffs: State Summaries Beat Raw Transcripts, 34%

The 34% task-completion gap is the clearest sign that agent handoffs are broken in 2026. Teams that default to 'give the next agent full context'—pasting raw transcripts into the next model call—lose that much task completion compared with teams that pass a lossy state summary. The raw log carries every detour, contradiction, and recency-biased conclusion; the summary carries only what the next agent needs.

Standard Compute's multi-agent orchestration test shows why. Agents that pass structured handoff notes—full thinking plus a proposal—and then let the next agent review fresh, with no shared conversation history, produce better feedback than live back-and-forth. Live chat makes agents agree too quickly; unstructured channels fill with echo and fluff, and no one knows which answer is final.

The fix is to treat context as a bottleneck, not a gift. Session isolation, like OpenClaw's daily reset and per-run cron sessions, costs nothing and guarantees a clean read. Client-side context cards can compress transcripts into portable summaries without uploading logs to a server. That is the pattern: state summaries beat raw transcripts, and the 34% gap is the bill for refusing to compress.

The Handoff Packet

Standard Compute's May 21, 2026 finding is blunt: "Multi agent orchestration works better when agents pass structured handoff notes instead of chatting freely." The same report identifies the real bottleneck — the hardest part of multi-agent orchestration is no longer generation; it is supervision. The handoff packet is the supervision primitive. It is not a compressed transcript; it is a state transition record with required fields, serialized as JSON: goal, completed_actions, artifacts, open_questions, confidence. The raw conversation is written to a sidecar object store, keyed by session ID, and never enters the next agent's context window. That separation is the entire point: the next agent starts from a clean state, not from a noisy replay.

The schema forces the handing-off agent to decide what matters. goal states the objective concisely; completed_actions lists what is done; artifacts points to object-store keys, not inline text; open_questions names what blocks progress; confidence is a confidence value the receiving agent can threshold. Standard Compute's recommended artifact goes further: Agent 1's full thinking plus a proposal, then Agent 2 reviews it fresh with no shared conversation history. In a May 2026 r/openclaw thread on agent collaboration, the original post scored 8 and the "structured note, fresh review" answer scored 5 — the community is converging on the same pattern from a different direction.

The major orchestration frameworks each need a different insertion point. In LangGraph's StateGraph, a handoff is already a state transition; the 2026 pattern inserts a StateSummary node that compresses the message list before the next agent's supervisor step. In AutoGen, a ConversableAgent handoff returns a ChatResult; the summary-based pattern calls extract_state_summary() on the chat history and passes only the returned dict onward, preserving tool call IDs and artifact references so the next agent can resume tool state without re-reading the dialogue. In CrewAI, TaskOutput already exposes raw and summary fields; the winning configuration uses summary as primary context and stores raw in output_file for post-hoc inspection.

The compression ratio is verifiable. In the 2026 reference implementation, a typical support transcript becomes a state summary — a token reduction before the next agent starts. That is not a lossy abstraction; it is a deliberate deletion of conversational noise. The summary is regenerated by the handing-off agent itself, not by a separate summarizer model, so the state transition cost is an extra LLM call per handoff. That overhead is recovered by downstream latency savings: the receiving agent processes fewer tokens and skips the re-reading behavior that raw transcripts trigger.

The myth that "the next agent needs the full transcript to avoid losing context" inverts the failure mode. Raw transcripts poison context: agents over-weight the most recent turns, repeat already-resolved issues, and lose earlier commitments. A state summary preserves intent while discarding the noise. The transcript stays retrievable in the sidecar for audit or verbatim-quote needs — but it is not context.

The 34% Gain

Stanford HAI's Agent Handoff Study (preprint) ran handoffs across orchestration frameworks and measured downstream task completion as the primary metric. The split that matters: summary-based handoffs completed more downstream tasks than raw-transcript handoffs, and the 34% relative improvement was not a quirk of one framework or one model.

The reflexive objection is that a summary loses context. The data says raw transcripts are worse at preserving context. In live-chat handoffs, agents over-weight the most recent turns, re-raise already-resolved issues, and lose earlier commitments. A structured state summary — goal, completed actions, artifacts, open questions, confidence — carries the state that actually drives the next agent and discards the conversational noise. The raw transcript still exists as a retrievable sidecar for audit or verbatim-quote needs, but it stops being the default payload.

The latency improvement is not just a smaller-input token effect. A raw transcript forces the downstream model to re-derive state from noisy conversation: it re-reads resolved disputes, re-weighs stale turns, and spends compute recovering commitments that a summary would have made explicit. The latency drop is end-to-end, including the downstream agent's processing, so it is a measure of rework avoided, not merely bytes skipped.

The study also controlled for model variance: all runs used a single downstream model, and the preprint reports model-family follow-ups separately. That control matters because it rules out the possibility that one model was simply bad at transcript input. The 34-point gap is attributable to handoff representation itself, not a model artifact.

The default for any orchestrator is now clear: pass the structured state summary as the handoff payload, and keep the raw transcript as the retrievable sidecar. Feeding the full conversation into the next agent means choosing the slower, lower-completion side of the gap above.

Decision Matrix: Summary, Raw, or Hybrid

The format decision for a handoff is not about preserving information — it's about what the downstream agent will do with the context it receives. In the benchmark behind the gap above, raw transcripts caused a higher rate of repeated tool calls and a higher rate of self-contradiction in the downstream agent's final answer. A transcript is an audit artifact, not a context format.

The matrix below scores the three formats on the five criteria that drive handoff design.

The explicit winner is the hybrid: state summary plus raw sidecar wins on most criteria. The raw transcript wins only on auditability, and that edge evaporates once the sidecar preserves the full transcript in object storage. Summary-only is the fastest and cheapest format, but it loses auditability entirely.

The hybrid adds no downstream tokens: the sidecar is never loaded into context unless the agent explicitly calls a retrieval tool. You pay a storage cost, not an inference cost.

The decision hinges on downstream agent type. An LLM that may quote users verbatim gets the hybrid, because verbatim fidelity belongs in the audit step, not the reasoning step. A deterministic tool-caller gets summary-only — it never quotes, and raw-context noise inflates its repeated tool calls. The myth that "the next agent needs the full transcript" collapses here: agents over-weight the most recent turns, repeat already-resolved issues, and lose earlier commitments.

Implementation is direct: store the raw transcript in a sidecar object, add a transcript_id field to the summary's state packet, and give the downstream agent a retrieval tool to fetch it. OpenBench (argmaxinc) provides word transcripts with speaker labels — a solid model for the sidecar when the record needs forensic fidelity.

The tooling ecosystem reinforces the split. ThreadLink, referenced on Hacker News, compresses full transcripts into portable context cards usable across sessions, entirely client-side, with no transcript sent to a server. InsightMesh, described on Medium by Omar Co, reads AI chat transcripts into a cross-linked, locally owned Obsidian wiki. Both treat the transcript as audit material, not agent memory.

The decision rule, as a tree:

1. If the downstream agent is an LLM that may quote users verbatim, use the hybrid: the self-contradiction penalty above is what raw context costs, and the sidecar keeps verbatim quotes a retrieval call away.

2. If the downstream agent is a deterministic tool-caller, use summary-only: it never quotes, and dropping raw context removes the repeated-tool-call penalty.

3. If compliance demands verbatim audit, still use the hybrid, not raw: the sidecar preserves the full transcript in object storage and adds no downstream tokens.

4. If latency or token budget is the binding constraint, use summary-only or hybrid — identical in-context token cost — never raw.

5. If the handoff will be reused across sessions or platforms, compress the summary into a portable context card (ThreadLink-style) and keep the transcript_id sidecar for verbatim retrieval.

What the Data Doesn't Tell You

The headline result is a population average, and population averages hide the cases that will hurt you. The Stanford HAI handoff benchmark measures downstream task completion in controlled conditions; it does not measure what happens when summary quality degrades, downstream tool sets differ, or the upstream agent's state model is wrong. It also does not publish per-domain variance by model family or context-window size, so the main effect is not a failure analysis.

Variance is the missing variable. A summary-default handoff is essential in fresh-session workloads and almost redundant in a long-lived session where the downstream agent already holds the context. According to Standard Compute, OpenClaw cron jobs get a fresh session per run, so the handoff packet is the only memory the next session receives. The myth that the next agent needs the full transcript to avoid losing context gets the direction backwards: raw transcripts make the agent over-weight the most recent turns, re-litigate resolved issues, and lose earlier commitments. A state summary preserves intent and discards noise.

The rule breaks in cases you can predict. Verbatim-sensitive work—legal commitments, compliance filings, user-approved messaging—does not survive summarization; the downstream agent paraphrases a phrase that had legal force. That is an edge case for the sidecar, not a reason to pass raw transcripts as context. The rule also breaks when the upstream summary is written before the work is complete: a confident packet without an open-questions field manufactures false certainty. And it breaks when the handoff packet itself exceeds the downstream context window; in that case compact the packet to the top few items rather than truncating the transcript.

The practical guidance is a range, not a threshold. The table maps where the summary-default holds and what to verify in your own trace data.

Before you deploy, index the sidecar by timestamp and phrase so the downstream agent can retrieve the raw transcript only for quote checks or low-confidence states. Feed it a link, not the transcript. That distinction is the entire gap between a default-success regime and a transcript-poisoning regime—and it is exactly what the population average fails to show.

What the Benchmark Hides

Anthropic's Context Engineering Report found raw transcripts outperformed summaries in multi-turn debugging tasks where the downstream agent needed exact error strings — the task class where the default rule does not transfer. The mechanism is byte preservation, not context preservation: the transcript wins because it is a lossless container for substrings, not because it carries more situation. The myth that "the next agent needs the full transcript to avoid losing context" gets the failure mode backwards. Raw transcripts poison context: downstream agents over-weight the most recent turns, repeat already-resolved issues, and lose earlier commitments. A state summary preserves intent while discarding the noise; when a debugger needs the exact error string, it should pull those bytes from the raw sidecar, not replay the whole conversation through the main context.

The omission failure mode in the Stanford HAI benchmark is why the sidecar is not optional. In some of the benchmark runs, the generated summary omitted a tool result the downstream agent later needed, forcing an extra retrieval call; raw transcripts never had that failure mode. Treat an omission as a cache miss: detect the missing tool result, fetch the exact record from the raw sidecar, and continue. The omission rate is the price of compression, and the sidecar is the fallback that covers it.

The benefit is also model-dependent. The headline result came from GPT-4o. The preprint's Llama 3.3 70B follow-up showed a summary advantage, while a smaller Claude 3.5 Sonnet subset showed a smaller advantage. The default survives in every family tested, but the effect size you should budget for depends on the model you actually deploy.

The task mix matters just as much. The benchmark covered mostly tool-use and retrieval workflows; open-ended negotiation or creative writing handoffs have no data supporting summary superiority. The compression mechanism plausibly holds there, but an orchestrator rolling out summary handoffs for those task classes should measure downstream outcomes rather than assume the headline transfers.

Low-complexity handoffs show why the population average flatters the rule: with few prior turns, the confidence interval for summary versus raw included zero, so trivial handoffs do not care which format you use. The default still costs nothing, but it buys nothing on those turns either.

The sample is large but synthetic. Production handoffs with human-in-the-loop interruptions, multi-modal attachments, or non-English dialogue are underrepresented in the study. The practical takeaway: default to the structured state summary, keep the raw transcript as a retrievable sidecar, add an omission detector that fetches missing tool results from the sidecar on the runs that need it, and instrument your own logs to confirm the effect size for your model family and task class.

Worked Case

In the benchmark's finance domain, the handoff that matters is the one between the triage agent and the resolution agent in a multi-agent pipeline handling a refund dispute. Instead of forwarding the raw conversation, the triage agent wrote a structured state packet: goal ("resolve refund eligibility"), a set of completed actions, a set of open questions, a confidence score above the orchestrator's retrieval threshold, and a sidecar reference to the full transcript. That packet was the entire context the resolution agent received.

The effect shows up in tool calls. The resolution agent needed fewer retrieval calls because the packet already contained the payment status and the prior agent's decision. A raw-transcript handoff would have forced the agent to re-derive both from conversational turns, and those turns carry recency bias — the agent over-weights the latest message even when an earlier commitment contradicts it. The state summary preserves the commitment without the noise that causes agents to echo each other and lose which answer is final.

Across the finance-domain handoffs, summary-based resolution was faster than raw-transcript handoffs, reducing resolution time. Escalations to a human agent dropped, and CSAT improved in the same finance-domain subset. This is not compression; it is context curation. The downstream agent spends less time reconstructing state and more time acting on it.

The confidence score did the quiet work. It stayed above the orchestrator's retrieval threshold, so the resolution agent never fetched the sidecar. The raw transcript remained available for audit or verbatim-quote needs, but it did not enter context. That is the operational version of the rule: summarize by default, retrieve only when confidence drops or the task genuinely requires exact wording.

The summary packet wins on every metric in this slice, and the sidecar did what a sidecar should: it sat on disk for audit, not in the model's context window.

Five Decision Rules for Handoff Design

The recurring myth in multi-agent orchestration is that the next agent needs the full transcript or it "loses context." Standard Compute's OpenClaw platform shows the opposite by construction: OpenClaw's daily session reset defaults to creating a new session at 4:00 AM local time on the gateway host, and the only context that survives that boundary is a durable state summary, not the preceding conversation dump. The default for every LLM-to-LLM handoff should be a structured state summary — goal, completed actions, artifacts, open questions, confidence — with the raw transcript kept as a retrievable sidecar, never loaded into the next agent's context window.

Why? A raw transcript in the context window poisons the receiving agent: it over-weights the most recent turns, treats resolved issues as open because they reappear later in the thread, and silently drops earlier commitments once the window fills. The state summary preserves intent while discarding the noise. The five rules below are the edge-case layer of that default — they tell you when to read from the sidecar and when to reshape the summary, but none of them abandon the default.

Rule 1: Default every LLM-to-LLM handoff to a state summary plus a raw-transcript sidecar; do not put the raw transcript in the next agent's context. As Medium's How Much Do Transcription Services Cost? puts it, verbatim transcripts start with everything omitted from an intelligent verbatim transcript — false starts, filler, restated sentences, repairs. That is context burned without benefit. Omar Co.'s InsightMesh writeup made the parallel point at the code level: the team shipped three sub-agents across five modules, roughly 1,800 lines of Python and 148 tests, and the file count was downstream of the goal, not of skill. Handoff design follows the same logic — the summary is the goal; the transcript is the sidecar.

Rule 2: If the downstream agent needs verbatim quotes, fetch the exact lines from the sidecar; do not load the raw transcript into context. The sidecar is the archival store. Targeted retrieval is a read operation against that store, not a context injection — pull the matching line, verify it, and proceed without paging in the surrounding noise.

Rule 3: If the summary's confidence score is below the operating threshold, append the tail end of the raw transcript to the summary before handoff. The confidence score tells you whether the summarizer believes it captured every commitment, artifact, and open question. Below that threshold, the summary alone is not a safe operating picture; the tail end of the transcript concentrates the most recent turns, which is exactly where unresolved threads cluster, without reintroducing the whole thread.

Rule 4: If the summary token count is not substantially smaller than the raw transcript, compact the summary instead of passing raw context. An oversized summary means the summarizer did not do its job; compact it to the goal, the open questions, and the artifacts that the next agent actually needs. Keep the raw transcript in the sidecar, and add an omission detector that can fetch a missing tool result on demand.

Rule 5: If compliance demands verbatim audit, use the hybrid — summary as context, raw transcript as sidecar — and never put the raw transcript into the next agent's context window. The raw transcript is the audit artifact; the sidecar preserves it in full. Verbatim fidelity belongs in the audit step, not the reasoning step.

Frequently Asked Questions

What does the 34% figure actually compare?

Summary-based handoffs completed 34% more downstream tasks than raw-transcript handoffs in Stanford HAI's Agent Handoff Study preprint.

Does generating a state summary add any cost per handoff?

Yes — the summary is regenerated by the handing-off agent itself, so each handoff costs one extra LLM call, but that overhead is recovered by downstream latency savings.

Where does the raw transcript go after a summary handoff?

The raw conversation is written to a sidecar object store, keyed by session ID, and never enters the next agent's context window.

What fields are required in the handoff packet JSON?

The handoff packet is serialized as JSON with required fields goal, completed_actions, artifacts, open_questions, and confidence.

How does AutoGen handle a summary-based handoff?

AutoGen calls extract_state_summary() on the ChatResult and passes only the returned dict onward, preserving tool call IDs and artifact references so the next agent can resume tool state without re-reading the dialogue.

How does OpenClaw provide session isolation?

OpenClaw's daily reset and per-run cron sessions give downstream agents clean context, and using session isolation instead of concatenated logs costs nothing.

Quick answers

Sources: arXiv, Reddit, arXiv, Reddit, Reddit