Common State, Private Scratchpads

The first time I built a multi-agent system with a shared conversation thread, I expected coordination to emerge naturally. Every agent could see everything — status, reasoning, questions, decisions — so the information was always available. What actually happened was the opposite. The critical coordination signals — one agent waiting on another, a blocker that needed resolution, a decision that gated the next phase — drowned in a flood of reasoning traces and status updates that no other agent needed. The system was coordinating the way a bad meeting coordinates: everyone talking, nobody listening to the right thing.

The Standup Trap

Multi-agent system designers often default to a shared conversation space because it is the simplest coordination architecture: every agent can see everything, so coordination happens "naturally." This is the same reasoning that leads organizations to put too many people in a daily standup. The coordination happens — buried under updates that are irrelevant to almost everyone in the room.

In multi-agent systems, the standup trap manifests as alignment chatter: agents summarizing their state for other agents that do not need the summary, asking clarifying questions that could be answered by structured metadata, and producing polished reasoning traces intended for the shared space rather than deep private reasoning intended for problem-solving. The shared space optimizes agent behavior for communication, not for task completion.

When multi-agent systems share a common conversation space instead of typed contracts, they recreate the worst pattern from human organizations: the status meeting where everyone reports to everyone, most information is irrelevant, and genuine coordination is buried in alignment chatter.

What Belongs in Shared State

Shared state should contain only information that another agent needs to do its job. The test is simple and strict: if no other agent's behavior changes based on this information, it does not belong in shared state.

Share: Task IDs and ownership — who is working on what. Artifact locations — where to find completed work products. Status transitions — task started, blocked, completed. Blocking dependencies — "I cannot proceed until X." Decision outcomes — the choice that was made and its rationale. Completion receipts — proof that a handoff was received and accepted.

Do not share: Reasoning in progress — hypotheses being explored, approaches being considered. Abandoned paths — approaches that were tried and rejected. Internal evaluations — the agent's assessment of its own output quality before committing. Speculative branches — "what if we tried X?" explorations that have not produced actionable conclusions.

Information Type	Where It Belongs	Why
Task ownership, status	Shared state	Others need it to coordinate
Blocking dependencies	Shared state	Blocked agent needs to signal
Reasoning in progress	Private scratchpad	No other agent acts on it
Abandoned approaches	Private scratchpad	Relevant only to the exploring agent

Why Privacy Improves Reasoning

When agents share reasoning in a common space, the reasoning changes. It becomes shallower and more performative — optimized for other agents to parse rather than for the problem at hand. This is not a flaw specific to AI agents. I have observed the same dynamic in human teams for years: thinking out loud in front of an audience produces different — and often worse — thinking than reasoning privately and sharing conclusions.

Private scratchpads allow agents to explore dead ends without polluting the coordination space. An agent that privately explores several approaches and commits to the best one contributes a clean signal to shared state. An agent that shares every exploration in real time contributes mostly dead ends with one useful conclusion, degrading coordination for every other agent in the system.

The Architecture

The design rule is to separate the coordination bus from the reasoning workspace. The coordination bus is structured, typed, and minimal — it carries signals like "task X is now blocked on artifact Y" and "decision Z was made, rationale attached." The reasoning workspace is local to each agent, unbounded in depth, and never shared except through its outputs. An agent's private scratchpad might contain pages of exploration. Its contribution to shared state should be a short structured update.

Separate the coordination bus from the reasoning workspace. The bus carries structured signals: task started, artifact ready, blocker raised, decision made. The workspace is private. This is the same architecture that makes good engineering teams work: shared ticketing system, private IDE.

Every well-coordinated multi-agent system I have built or reviewed follows this pattern. The systems that coordinate best are not the ones where every agent can see everything. They are the ones where every agent can see exactly what it needs — no more, no less — and reasons privately before contributing structured conclusions to the shared space.

Related Reading:

• The Conservation of Chaos — every act of order creates new disorder
• The Context Window Fallacy — bigger context windows do not solve coordination problems
• The Supervisor Pattern — orchestrating multi-agent systems with explicit control
• Coordination Debt — the hidden cost of implicit coordination