Keep Drafts in the Drawer: How a Whiteboard Taught AI Teams to Collaborate — Introducing Muffin

*Part one of a three-part series on memory management for AI agents (translated and edited from zhichai.net).*

Key points

• The problem: In goal-driven reasoning tasks, single-agent and multi-agent systems often perform on par. The paper diagnoses failures not in reasoning itself, but in *inefficient exchange of key information* during agent interaction and coordination.
• Two flawed defaults of multi-agent debate: (1) synchronous turn-taking, where the whole team waits on the slowest member; (2) full-trajectory sharing, where every agent pushes its complete chain-of-thought to everyone — drowning useful signal in noise.
• Muffin's answer: asynchronous, selective sharing. Agents exchange compact "findings" rather than full reasoning traces. Results: 17/20 best and 3/20 second across 20 evaluations (4 benchmarks × 4 open-source models), +4.4 accuracy points on average over the strongest baseline (+11.8 on OlymMATH-E, +2.6 on OlymMATH-H). Step-by-step analysis: +19.2 accuracy points over multi-agent debate while using 77.4% fewer tokens.

How Muffin works: three components

1. Orchestrator (triage first)

Given a query, the orchestrator produces a routing decision — answer directly with a single agent, or spin up multi-agent collaboration. If the latter, it assigns each agent a role, mutually non-overlapping subtasks, and a collaboration protocol specifying what gets shared (critiques, warnings, findings), what stays local, and whether new findings can trigger reactive steps in other agents.

2. Shared memory buffer (the whiteboard)

The buffer is an append-only data structure: no writes conflict, no locks needed — a database design principle (event sourcing / CRDT-style immutability) imported into the AI meeting room. Each entry records the source agent, its finding, and the step number.

Retrieval is deliberately restrained: each agent reads only the latest k findings contributed by other agents — its own entries are skipped. Visibility: a finding committed by agent i at step t is seen by agent j at step t′ only if committed before j's step t′ began and within the most recent k entries. There is no global turn index: every agent proceeds immediately to its next step after finishing the previous one.

Each step emits a structured five-part output:

• SUMMARY — brief reasoning summary for this step
• SHARE_FINDING — optional finding for others (may be empty)
• LOCAL_NOTES — private notes, never shared
• ANSWER_CHOICE — current candidate answer, or "undecided"
• ANSWER_REASON — one-line justification

Private history keeps only a compact summary: h_i(t+1) = H_i(h_i(t), m_i(t), n_i(t)) — no full trajectories. The protocol explicitly instructs agents to work independently, share concise findings, verify before adopting others' findings, not to expose private chain-of-thought, and — if assigned the "critical agent" role — to challenge assumptions, contradictions, and overconfident claims.

3. Summarizer (judge, not contestant)

The summarizer sees only each agent's final message summary, agent metadata, and the original question. It is instructed not to re-solve the problem, not to introduce new hypotheses, and to treat candidate summaries as evidence rather than conclusions. This restraint pays off: on OlymMATH-Easy, adding the summarizer lifted accuracy from 44.9% to 59.2%.

The key ablation: is more context actually better?

The authors replaced selective sharing with full-trajectory sharing (entire reasoning traces pushed to all agents and the summarizer):

| Setting | Final accuracy | Token usage | |---|---|---| | Full-trajectory sharing | 87.3% | 160.6K | | Muffin (selective sharing) | 85.0% | 41.9K |

Full trajectories do carry real information — but those 2.3 points cost 3.8× the tokens. Muffin wins decisively on the quality–cost tradeoff. Three mechanisms plausibly explain why full sharing is inefficient:

1. Attention dilution — valid intermediate conclusions occupy a tiny fraction of a full draft; agents must do reading comprehension in everyone else's rambling. 2. Anchoring and conformity — seeing complete reasoning drags agents along someone else's frame, even toward wrong answers. A conclusion-only sticky note is harder to blindly follow. 3. Writing a finding is itself refinement — forcing agents to decide what merits sharing imposes compression and selection. Choice is thinking; the sticky-note format is a form of cognitive discipline.

The asynchronous bonus: wall-clock and token economics

Synchronous debate's latency is the sum of all generation plus waiting; Muffin's latency is roughly the longest single generation, since others keep reading and writing during that window. Selective sharing also keeps per-step communication cost roughly constant — a few sticky notes, not photocopied notebooks — so communication cost is decoupled from thinking cost. As agents scale up and steps deepen, Muffin's relative advantage grows.

Honest caveats

• Validation is math-only (MATH, OlymMATH-Easy, OlymMATH-Hard). Whether buffer findings can carry heterogeneous content (e.g., tool-call results) is untested.
• Fixed team size — dynamic agent-count scaling is explicitly future work; buffer density, retrieval window k, and noise control at 30 agents are open problems.
• Single-point dependency on the orchestrator — misrouting easy/hard queries hurts the whole pipeline.
• Higher variance in some settings — LLM-decided sharing introduces randomness; the authors honestly report elevated standard deviation in parts of their evaluation.

Why this matters

Muffin reframes multi-agent collaboration etiquette: separate drafts from findings, put findings on the whiteboard, keep drafts in the drawer; no queueing to speak, but speak only the essentials; a judge who never re-solves collects the answers. Notably, Muffin avoids heavier alternatives like "codeified reasoning" (forcing agents to translate thought into formal notation) — natural-language sticky notes with a light five-field format capture nearly all the collaborative benefit at far lower expression cost.

Reference: Ping-Lin Kuo, Suman Navaratnarajah, Christian Frey, Gresa Shala, Josif Grabocka. "Muffin — A Shared Memory Buffer for Asynchronous AI Agents." arXiv:2610.31355. https://arxiv.org/abs/2610.31355

*This is part one of the memory-management trilogy, covering how agent memory is communicated. Part two will cover how memory is organized, archived, and retrieved.*