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.

Why this matters for software

Stigmergic coordination has properties that message-passing coordination struggles to buy. It degrades gracefully, because losing any participant costs you that participant's contribution and nothing else. It scales without a coordinator, because coordination cost lives in the shared medium rather than in a growing number of connections. And it is durable across restarts: the trail persists whether or not anyone is currently walking it.

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.

The trap: talkative agents

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. Worse, a system coordinated by conversation has no state you can inspect afterward except the conversation itself, which is long, redundant, and hard to audit.

Systems coordinated through shared state have the opposite property. The record is the coordination artifact. It is compact, it is queryable, and reading it tells you what actually happened rather than what the agents said to each other about what might happen.

When you do want direct communication

Not everything is stigmergic, and pretending otherwise is its own mistake. 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.

That last case is underrated. Independent agents that reach the same answer tell you the answer is stable. Independent agents that split tell you the case is genuinely ambiguous, which is information you cannot get from a single confident response. 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 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 handoff between human and agent stops being an integration and becomes the normal case.

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. When agents do need to talk, they can, but the system does not depend on the conversation to know what is going on.

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.