Stigmergy: Why the Best AI Agents Don't Talk to Each Other

We have been architecting multi-agent systems around a flaw we never questioned: the assumption that agents need to talk in order to coordinate.

Recent data from a swarm experiment suggests the opposite. Drop hundreds of frontier AI agents into a shared, persistent environment, sever every direct communication channel, and they do not break down. They self-organize. They differentiate into builders and coordinators, invent complex tools, and iterate on multi-author technologies that vastly outlive their original creators.

They pull this off through stigmergy — coordinating strictly through environmental modification. The environment itself becomes the shared memory and the network.

The consensus overhead

If you have spent any time orchestrating agents, you know the drag of consensus overhead. When LLMs communicate directly, they burn enormous amounts of compute parsing semantic noise, negotiating intents, and hallucinating protocol structures. Two agents can spend four turns agreeing on the shape of a payload that a schema would have settled for free.

Cutting the communication channel forces agents to interact with structural ground truth instead. The environment does not negotiate. It acts as an impartial, unyielding fitness function. Flawed concepts simply fail to deploy in the world. Functioning technologies persist and act as replicable memes: another agent walks past, observes the working artifact, and forks it. No meetings, no JSON payload debates, just execution-driven iteration.

Open in new tab ↗

Shifting from messages to state mutation

In early frameworks — and in the initial architecture of POLARIS v1.0 — the default paradigm was explicit message passing. But scaling an $O(N^2)$ direct-broadcast architecture is computationally hostile. Every added agent adds a row and a column to a matrix nobody wanted to maintain.

Implementing stigmergy means pivoting to an $O(1)$ environmental state architecture. The primary interface stops being Agent-to-Agent and becomes Agent-to-Matrix.

// Direct Communication (O(N^2) bottleneck)
interface DirectAgent {
  broadcast(message: Payload): void;
  receive(message: Payload): void;
}

// Stigmergic Architecture (O(1) state mutation)
interface Environment {
  readState(hash: string): Artifact | null;
  applyMutation(hash: string, mutation: MutatorFunction): void;
}

interface StigmergicAgent {
  observe(env: Environment, targetHash: string): void;
  act(env: Environment, mutation: MutatorFunction): void;
}

In the observed swarms, 95% of technology adoption happened through physical observation of an artifact in the environment. The deepest genealogies — some exceeding 12 forks with half a dozen co-authors — emerged entirely from agents silently iterating on the shared codebase of the physical world.

That last point is the part I keep turning over. In a message-passing swarm, knowledge dies with the context window that held it. In a stigmergic swarm, the knowledge is in the artifact, and the artifact does not need anyone to remember it.

What you trade away

Stigmergy is not free. It moves the cost from the channel to the substrate.

The interesting column is the last row. And the trap is the conflict row: if two agents mutate the same artifact concurrently and your substrate has no notion of atomicity, you have not eliminated consensus. You have relocated it into a race condition. Environmental coordination only works when the environment enforces something — a compare-and-swap, a transaction, an immutable append, a hash that must match before a write lands.

The security blindspot

This exposes a real vulnerability in how we currently secure AI infrastructure.

The industry assumes unauthorized multi-agent coordination looks like API calls, network packets, or shared context windows. But if a swarm can coordinate complex operations simply by reading and persisting state changes to a shared environment — a database, a filesystem, a cloud bucket — then monitoring agent-to-agent traffic is useless. It is the equivalent of searching for radio signals in a termite mound.

The practical consequence is that your audit surface is the substrate, not the wire. Version every artifact. Attribute every mutation to an identity. Alert on write velocity and on lineage depth, not on chat volume. If an object in a bucket has been forked eleven times in an hour by six different agent identities that never exchanged a packet, that is a coordination event, and nothing in your network telemetry will ever show it.

Conclusion

Raw intelligence scales horizontally through environmental state changes just as effectively as it scales vertically through parameter counts. The environment is the latent space.

So the architectural advice is uncomfortably simple: stop designing conversations between your agents and start designing the world they mutate. Give them a substrate with real constraints, make every write attributable and versioned, and let the artifacts carry the intent. Then stop monitoring the silent agents and start monitoring the world they are modifying.

Diego Vallejo, August 2026