Ants do not hold meetings

The default mental model for multi-agent systems is a meeting. A planner decomposes the work, delegates to specialists, collects their replies, and synthesizes. It is intuitive because it mirrors how human teams are organized, and it inherits every problem human teams have: the coordinator is a bottleneck, a single point of failure, and the most expensive participant in the room.

Social insects do not work this way. There is no ant that knows the plan. Coordination happens through stigmergy: an individual modifies the shared environment, and that modification changes what the next individual does. A forager returning with food lays a trail. Others are more likely to follow a stronger trail. Shorter routes get traversed more often, so their trails strengthen faster, so more foragers take them. The colony converges on an efficient path, and no ant ever compared two routes.

The environment is the message. Nobody has to be told anything, because the state of the world is the state of the conversation.

This is a well-worn analogy in multi-agent writing, and analogies are cheap. The interesting question is not whether stigmergy is elegant. It is whether coordination structure is a variable you can actually measure, on real agents, in speed, cost, and reliability, rather than a design taste you defend in a blog post. That is most of what this piece is about. The ants are just where the argument starts.

Why the shared-medium approach should win

Stigmergic coordination has properties that message-passing coordination struggles to buy, and they follow from the structure rather than from the biology.

The coordination cost lives in a different place. In a message-passing design, the cost of keeping n participants aligned grows with the number of exchanges between them, and the ceiling on that is the pairwise graph, on the order of n² channels. In a shared-medium design, each participant performs a bounded read of one artifact and a bounded write to it, independent of how many other participants exist. Ten agents or ten thousand, an agent still reads the board once and acts. Coordination stops being a conversation whose length grows with the crowd, and becomes a lookup.

It degrades gracefully. Losing any participant costs you that participant's contribution and nothing else, because no one was waiting on it to relay state. It is durable across restarts: the trail persists whether or not anyone is currently walking it. And it is auditable, because the coordination artifact is a compact, queryable record of what happened, not a long transcript of what agents said to each other about what might happen.

For agent systems the shared medium is not pheromone. It is the work log: a task board, a set of claims, a record of outcomes, a repository history. Any agent that can read the current state can decide what to do next without being told, and any agent that finishes something changes what the next one sees.

That is the theory. It predicts that shared-state coordination should be cheaper and more robust than message-passing at scale. A prediction is not evidence, so the useful thing is to be able to check it.

Measured, not modeled

Comparisons of coordination patterns are almost always modeled. Someone draws the topology, reasons about it, and asserts a conclusion. We wanted the other thing, which is part of why we built Recursiv the way we did: a live agent network running a real process, scored against known-correct answers, where you can change one variable, the coordination structure, and read the delta.

Once a process is running as agents against inputs with known answers, every input becomes a knob you can sweep and re-read. Swap the model underneath a step. Change a single agent into a worker-plus-critic, an ensemble, or a debate. Feed in noisier data. Each of those stops being an opinion and becomes a measured delta in reliability, in cost, and in how much of the work you can safely leave unattended. That is the frame the rest of this depends on: coordination structure is not a philosophy you pick, it is an output you measure, and the boundary it draws between what runs on its own and what needs a person moves as models and data change.

What the talkative approach actually buys

Direct agent-to-agent messaging is seductive because a transcript of agents conversing looks like intelligence. In practice, conversation between agents is where cost accumulates fastest and reliability degrades quietest. Every exchange is tokens spent, latency added, and another opportunity for a confident mistake to propagate. A system coordinated by conversation has no state you can inspect afterward except the conversation itself, which is long, redundant, and hard to audit.

We have run this comparison on ourselves, and the honest result was not flattering to the talkative thesis. On a well-specified structured task, reviewing a document for planted issues, we tested it as a single agent and across several message-passing coordination patterns. Adding agents that conversed added cost and did not add accuracy. A single capable model found every planted issue. So did four of the five models we tried, individually. Engineering the task further until the conversing swarm finally won would have been manufacturing a result.

The useful conclusion was different. The value of running several independent agents was never higher accuracy on the clear cases. It was that a set of independent readers produces a calibrated reading of how settled the answer is. Where they converge, the answer is stable and you can automate. Where they split, the case is genuinely ambiguous, and that split is a signal a single confident response structurally cannot produce. Structured disagreement is one of the few places where more agents buy something real, and it is worth reaching for deliberately rather than by default.

The same discipline shows up when you sweep the model under a single judgment step. In one screening task we measured, moving from a strong model to a cheap one did not move the safety line at all: both caught every genuinely risky case. What moved was the false-alarm rate. The cheap model got jumpier, flagging clean cases it should have cleared, so it automated far less of the work and handed a much larger queue to a person. The model choice was not a safety decision, it was a throughput-and-cost decision, and that tradeoff is invisible until you put the number in front of it.

So the line is not "never let agents talk." It is that direct exchange earns its cost in a narrow set of cases: when a decision genuinely requires reconciling incompatible views, when one agent needs a capability another holds and the handoff is synchronous, and when the value being produced is the disagreement itself. Everywhere else, the cheaper and more durable design is agents reading and writing shared state, and a coordinator that gates on what it finds there rather than on what anyone told it.

The humans are participants too

The framing that matters most: coordination is not an agent-to-agent problem, it is a problem of everyone working on the same thing. If the shared record is legible only to software, humans are locked out of a system running on their behalf. If it is legible to both, then a person can read the same board, take the same task, and leave the same kind of mark. The exceptions an agent escalates land in a queue that reads from the same state the agents write to. The handoff between human and agent stops being an integration and becomes the normal case.

Measured once is not measured

There is a failure mode that shared-state coordination does not solve on its own, and it is the one that actually breaks deployed systems. A measurement from launch day describes a world that no longer exists. A model provider silently changes behavior, a data source drifts, a prompt edit has second-order effects. None of these throw an error. The system keeps returning confident, well-formatted answers that are quietly worse than they were.

So a coordination design worth trusting is re-measured on a schedule, and each step carries a reliability trend rather than a snapshot. When a model updates or the incoming data shifts, a step's reliability drops, the line between what runs unattended and what needs a person moves, and you find out before it costs you. Continuous evidence that the coordination is still doing what it did last month is the thing a modeled table or a one-time benchmark structurally cannot give you.

How we think about it

We build coordination around shared, durable state first and direct messaging second. Work is claimed rather than assigned. Outcomes are recorded where anyone, human or agent, can read them, and against the specific actor that produced them, so a performance history attaches to an agent rather than to a system in general. When agents do need to talk, they can, but the system does not depend on the conversation to know what is going on. And the whole thing is measured continuously, because a coordination design you cannot re-read is a design you are trusting on faith.

The measure of a coordination design is simple. Kill any participant at random. If the work continues and the record still explains itself, the design is sound. If everything stops because the coordinator is gone, you built a meeting. Everything above is the attempt to turn that instinct into an instrument: to make coordination structure something you sweep and read, in speed, cost, and reliability, on real agents, rather than something you argue about over the ants.