I once watched a five-agent conversation burn $150 in three rounds. The quality was fine — the agents produced a genuine, constraint-valid plan. The bill was not. Each agent was reading the full prior conversation on every turn, so every round re-ingested every earlier round, and the cost curve looked nothing like the ten messages I thought I was paying for.
That was the week I started measuring something I'd been eyeballing for months: the difference between what my agents said to each other and what they actually needed to hear.
The Default That Feels Safe
The broadcast pattern is the natural first architecture. A coordinator holds the shared context, and every step it re-sends that context to every sub-agent so each one has "complete situational awareness." It's simple to implement and it never risks an agent missing something it needed. The sarkars failure-modes repository states the root cause with painful precision: in naive multi-agent orchestration, a coordinator re-sends the full shared context to every sub-agent at every step, and total synchronization cost scales multiplicatively in the number of agents, the number of steps, and the size of the shared artifact — not additively in agent count, as engineers assume when they estimate.
That multiplicative claim is the one I'd been missing. I'd been budgeting for N agents × average message size. The actual cost was closer to N × steps × shared context size, and the shared context grows at every step.
The worked example from the same source is the cleanest illustration I've found. Three agents — researcher, analyst, writer — five coordination steps, shared context growing from 500 to 4,000 tokens. Broadcast cost: 1,500 + 3,600 + 6,000 + 8,700 + 12,000 = 31,800 tokens of synchronization alone, excluding each agent's own generation. A single-agent version of the same task, with no synchronization overhead, would need the final 4,000-token context once. That's an 87% reduction relative to the broadcast total.
And going from 3 agents to 6 doesn't double the broadcast cost. It roughly quadruples it, because both agent count and shared-context size multiply against each other.
The Math Nobody Puts on the Architecture Slide
The research has now formalized what my invoice was telling me.
The Harvard ML Systems text models total cost as work + serialization + network + context duplication + reconciliation, and defines a coordination tax κ(N) that scales quadratically (O(N²)) in unoptimized multi-agent systems where agents communicate via unconstrained broadcast channels or dense peer-to-peer messaging. Their conclusion is the one that should be on every design review slide: beyond a small concurrency threshold, adding agents increases total completion time and explodes total token consumption while decreasing overall system reliability.
The Agent Coordination Bound paper puts a number on the topology. In any all-to-all agent network, inter-agent communication channels grow as n(n−1)/2, and coordination overhead eventually dominates reasoning gain. Their model predicts an optimal fleet size of n* = f·a/c, where a is per-agent accuracy gain and c is per-link token overhead — both measurable in two benchmark runs.
That formula is the thing I wish I'd had eighteen months ago. It says the fleet size isn't a matter of taste. It's a ratio: how much accuracy each agent adds, divided by how much each communication link costs. If links are expensive and agents add little, the optimal fleet is small. Broadcast is the pattern that makes c maximal.
The AutoGen audit makes the quadratic concrete in turns rather than agents. With the default UnboundedChatCompletionContext, every message is appended to every participant's local context, so the cumulative cost is (m × T²)/2. At 10 turns, the actual cost is 5.5× the naive expectation. At 30 turns, it's 15.5×. A three-agent chat, ten turns total, costs fifteen times what you'd budget for.
And the openclaw issue report adds the agent dimension. With N agents and M rounds, total tokens scale roughly as N × M × (N × M) because each later turn re-ingests every earlier turn. At (5 agents, 3 rounds) it's expensive but tolerable. At (10, 5) it's an order of magnitude worse. At (20, 10) it's prohibitive.
The Part That Makes It Hard
I want to be honest about why this isn't just a "broadcast is wasteful, remove it" post, because the obvious fix has a real cost.
The broadcast pattern produces something a targeted pattern doesn't: emergent-information moments. In the openclaw run, one agent mentioned that a child had met another helper at a block party — a fact with no topical overlap to the agent who needed it, which changed that agent's reasoning about pickup pairings. Naive cost reduction — "only send to topically-relevant agents" — would silently kill that property and erode the very thing that makes conversational coordination valuable.
So the design question isn't "broadcast or targeted." It's "how do we keep the property at scale without every agent ingesting the full transcript every turn".
What Targeted Actually Buys You
The research on selective routing is now specific enough to plan against.
CREAC, a training-free router that maintains a meta-belief over who currently holds task-relevant knowledge, delivers each message only to agents whose state suggests they can act on it — and when its belief is too uncertain, it stops guessing and issues targeted queries to the most likely knowers rather than falling back to broadcast. On a 15-agent heterogeneous benchmark, it reduces token cost relative to planner-coupled systems by up to 65%, while outperforming both planner-coupled systems and the strongest selective-routing baseline. Human collaborators rated the CREAC-mediated teams as more trustworthy and efficient than both broadcast and silent baselines.
Slipstream attacks the message itself rather than the fan-out. It maps free-form messages onto a shared concept codebook and transmits compact mnemonic anchors instead of full natural-language payloads. The result is 82% token reduction (41.9 → 7.4 tokens average) while maintaining semantic fidelity. The paper's economics are the number that made me sit up: at GPT-4o pricing, a 50-agent deployment exchanging 1,000 messages/day costs $180,000/year in coordination tokens alone — before any productive work is performed. Their diagnosis of why syntactic compression fails is worth knowing: BPE tokenizer fragmentation means punctuation-heavy shorthand tokenizes worse than plain English words, so the compression has to happen at the semantic level, not the syntax level.
TopoDIM generates diverse interaction topologies in one shot rather than through iterative coordination, reducing total token consumption by 46.41% while improving average performance by 1.50%. E2-Explainer prunes redundant edges from communication graphs via causal inference, reducing token usage in every one of 24 optimizer-dataset combinations, with dataset-level reductions ranging from 10.6% to 44.0%, while accuracy improved in 16 combinations and stayed unchanged in one. The paper's most useful observation: reduction in communication cost is more consistent than the change in task accuracy — meaning some candidate topologies retain redundant or distracting communication whose removal can actually benefit answer quality.
S²-MAD cuts token costs by up to 94.5% without sacrificing accuracy by addressing the fact that standard multi-agent debate requires every model to read the full history of every other model's arguments — the quadratic bottleneck manifesting as a token explosion.
The Coordination Channel That Isn't Messaging
The finding that reframed my architecture came from a 1,902-run study of multi-agent coding teams. Direct messaging initially increases close to quadratically with agent count, much of it from an early round of introductions, then levels off in large teams as agents shift to broadcast. That's the expected curve.
But the study found something else: shared files can replace repeated 1-to-1 communication, cutting output tokens by about 42% at eight agents on message-heavy work. And the effect is conditional — shared files add overhead when files already carry the coordination.
The most uncomfortable finding is the one about coordinators. Naming one agent as coordinator creates no communication hub and provides no reliable improvement in success. The label doesn't change the network. The medium does.
That's the reframe. Broadcast and targeted messaging are both push channels — the sender decides who receives. A shared artifact is a pull channel — the receiver decides what to read. Push scales with the number of recipients. Pull scales with the number of readers who actually need it. If most agents don't need most messages, pull wins by construction.
What Production Actually Looks Like
The production evidence isn't all from research papers.
A measured cost deep-dive on a real multi-agent org runtime found that an earlier analysis claiming “81% of messages were broadcast” was simply false. The runtime had no broadcast mechanism — org_send's schema was to: z.string(), one recipient, the only inter-agent channel. A dashboard projection was relabeling every assistant narration block as to:'all' and appending it to the thread log as if it were mail. Real inter-agent traffic: 465 directed messages.
That correction produced the number that changed how I think about coordination cost. Inter-agent mail was 0.1% of tool-and-message context mass. The messaging wasn't the cost. The context duplication was — the same foundational prompt, environment schema, and task instructions being re-prefilled by every child agent because they don't share a unified physical memory address space.
The lesson from that report is narrow and practical: a dashboard projection is not a measurement, and the thread log conflates an agent talking to itself with an agent sending mail. I had been optimizing a channel that wasn't where the money went.
The Counterintuitive Case for Broadcast
One finding cuts against everything above, and I'd be dishonest to leave it out.
The Constitutional Evolution paper at ICML 2026 tested evolved governance constitutions against human-designed ones in a simulated society. The winning constitution minimized communication — 0.9% social actions versus 62.2% for the human baseline — and still achieved a societal stability score of 0.556, 123% higher than human-designed baselines and 223% above the vague-principles baseline. Agents following consistent, specific rules coordinated implicitly through predictable behavior, with no need to broadcast intentions.
That's the deeper trade. Broadcast exists because agents don't share a rulebook precise enough to predict each other. If the vocabulary is stable and the constraints are explicit, most coordination doesn't need to happen in messages at all. The coordination cost isn't a communication problem. It's a shared-model problem.
What I'd Tell My Past Self
Measure before you optimize. My dashboard said messaging was 17% of tokens. The real number was 0.1%. The thing I should have measured was context duplication — how many times the same artifact got re-prefilled because it was pushed to agents who didn't need it.
Then, once the measurement is real, the design rules are:
Push the delta, not the state. Every handoff should carry what changed since the last update, not the full accumulated context. The failure-mode catalogue names this directly: shared state should be re-transmitted incrementally, not in full at every synchronization point.
Push to the actor, not the audience. CREAC's 65% reduction comes from routing to agents whose state suggests they can act on the message, not agents whose topic suggests they might care. That's a higher bar for inclusion, and it's the right one.
Let the receiver pull when the read is bounded. A shared artifact with a scoped read beats a broadcast to every agent. The 42% output-token cut at eight agents is the production number, but the real win is that it decouples cost from recipient count.
Keep broadcast where emergence lives. The block-party moment is real. Don't eliminate broadcast — confine it to the rounds where cross-domain reveals actually happen, and let targeted routing handle the rest.
The Trade-Off You're Accepting
Targeted messaging buys you cost and signal-to-noise. It costs you the property that makes conversational coordination interesting.
Every routing decision is a chance to miss the non-obvious recipient. The router's false-negative rate is the price of the savings, and it's invisible — you never see the insight that didn't happen because the message didn't reach the agent who needed it. That's a harder failure to detect than an inflated bill.
You're also accepting more infrastructure: a routing layer, a meta-belief model, a scoping mechanism for shared artifacts. Each is a component that can fail, and each is a place where the coordination logic now lives instead of in the conversation.
And you're accepting that the right answer may be no messaging at all for some of your workflow. A shared artifact with a scoped read is cheaper than any message, and a stable rulebook is cheaper still. The cheapest coordination is the one that happens in the environment rather than in the transcript.
So here's my question: If you looked at your agent traffic right now, how much of it is a message someone actually needed — and how much is a full context re-sent to an agent who only needed one field?
I'd love to hear where you've landed. A semantic router in front of the crew, shared files instead of peer messages, a broadcast channel you're still defending because it caught something a router would have missed — and what finally made you measure the medium instead of the message?
