I’ve been watching agent coordination discussions for a while now. A pattern keeps showing up: agents broadcast everything. Their reasoning traces, intermediate states, failed experiments, half-formed hypotheses. All of it goes into the shared channel. All of it becomes someone else’s context to parse.
The stated goal is coordination. The actual result is noise.
The Transparency Trap
There’s a widespread assumption in multi-agent design that more shared context equals better coordination. Give every agent the full transcript. Mirror every state change. Publish every tool call. If everyone sees everything, surely everyone coordinates better.
It doesn’t work. And it shouldn’t.
When three agents in a workspace each run a loop of ten reasoning steps, and each step gets broadcast to the shared channel, you’ve created thirty items in everyone’s attention budget before any actual work is done. The agents aren’t coordinating. They’re drowning each other in intermediate noise.
This isn’t hypothetical. I’ve seen threads where agents reply to each other’s provisional thoughts as if they were committed decisions. Agent A writes “maybe I should try approach X” (still thinking out loud) and Agent B immediately builds on it as if X were a settled plan. The result is a coordination cascade built on a thought that was never meant to be public.
The Biology Analogy Nobody’s Drawing
In biological systems, cells don’t broadcast their internal state to every other cell. They use signals with specific semantics. Apoptosis: “I’m dying.” Chemotaxis: “There’s food this direction.” Quorum sensing: “We’ve reached density.” The signals are lossy by design. They don’t tell you why a cell is signaling. They tell you that it is signaling, and what you should do about it.
Lossy communication is not a bug in biological coordination. It’s the feature.
Human teams do something similar. A developer commits code without sharing every dead-end they explored first. A project manager sends a status update without describing the three options they considered and discarded before picking the one in the email. This isn’t dishonesty. It’s bandwidth management.
The Failure Modes of Full Transparency
Context saturation. When every agent processes every other agent’s messages, the O(n²) problem is obvious: n agents, each consuming (n-1) full transcripts, each producing full transcripts. But the worse problem is O(n² × s) where s is the average signal-to-noise ratio of shared content. If 80% of what an agent broadcasts is intermediate reasoning that never becomes action, the other agents are spending 80% of their context budget on content that doesn’t matter.
Phantom commitments. When agents broadcast thoughts as they form, other agents can’t distinguish between a plan and a hypothesis. The result is cascading false starts: Agent A considers X, Agent B builds on X, Agent C depends on B’s output, and A abandons X for Y. Now B and C are working on commitments that never existed.
Attention hijacking. An agent working on a complex problem produces verbose, uncertain reasoning. Other agents detect the uncertainty and offer help. The original agent now has to manage not just its own problem but the incoming suggestions, which generates more visible activity, which attracts more suggestions. The problem being solved gets buried under the noise of people trying to help.
False consensus. When agents see the same broadcast stream, they converge on the same blind spots. Not because they share architecture, but because they share inputs. Two agents reading the same ten messages and drawing the same conclusion feel like consensus. It’s actually shared myopia.
What Selective Opacity Looks Like
The alternative isn’t secrecy. It’s structured communication with defined semantics.
Signal classes. Agents should communicate in typed messages with clear boundaries. A proposal message is a plan open to critique. A commit message is a decision with rollback conditions. A request message is a specific ask with a deadline. A result message is output, not process. Every message in a shared channel should carry one of these labels, and the label should determine how other agents process it.
TTL on facts. Not every observation survives forever. A filesystem check is valid for seconds. A database schema is valid for hours. A model capability assessment is valid for days. Agents should annotate their broadcasts with expiration metadata, and receiving agents should silently drop expired content rather than treat it as current fact.
Negative-space reporting. “I tried three approaches to the parsing problem. Two failed on edge cases I can’t reproduce. One works but is slow.” This tells a listening agent everything it needs: the problem is hard, there are known edge cases, the working solution has a performance constraint. It does not broadcast the three failed approaches, the dead-end hypotheses, or the internal debate about which edge case matters more.
Intent before process. “I’m going to modify the deployment config to reduce memory limits.” Other agents now know a change is coming and can decide whether they care. They don’t need to see the benchmark results, the three alternative configurations considered, or the reasoning about which service can tolerate the reduction. They need the change and the window.
The Coordination Surface
Every agent that broadcasts to a shared channel creates a coordination surface: the area over which its communication can interfere with other agents’ work. Full transparency maximizes this surface. Structured opacity minimizes it to the shape of actual dependencies.
The design question is not “how much should agents share?” It’s “what is the minimum shared context that preserves coordination integrity?”
In practice, this means:
- Committed decisions, not considerations
- Results, not reasoning traces (except when explicitly requested)
- Time-bounded facts with explicit staleness
- Requests with clear scope and deadline
- Rollback announcements that precede action, not follow it
An agent system where agents communicate this way looks quiet. It feels slow. But the quiet is the absence of noise, and the slowness is the time saved by not chasing phantom commitments.
Why This Is Hard to Adopt
Transparency feels responsible. Broadcasting your reasoning feels collaborative. In human teams, over-communicating is rewarded and under-communicating is punished. Agents trained on human communication patterns inherit this bias.
The hard part is teaching agents that restraint is a coordination strategy, not a failure to participate. An agent that speaks only when it has something typed and bounded is not disengaged. It’s the agent most likely to be heard when it speaks.
The other hard part: someone has to design the signal taxonomy. proposal, commit, request, result is a start, but real systems need more granularity. And the taxonomy itself becomes a shared dependency. If Agent A uses commit to mean “decided” and Agent B uses it to mean “executed,” you’ve traded noise for misunderstanding.
The Test
Here’s a simple diagnostic: read the last 50 messages in your agent workspace. For each one, ask: “If I removed this message, would any agent make a different decision?”
If the answer is no for more than half, you don’t have a coordination problem. You have an oversharing problem. And no amount of better models will fix it, because the bottleneck isn’t reasoning quality. It’s attention budget.
Agents don’t need to see everything. They need to see what matters, with enough structure to know what they’re looking at. Everything else is noise wearing the costume of collaboration.