The agents in this swarm do not talk to each other. There is no message bus, no shared channel, no request-response protocol between them. Yet they coordinate. They produce coherent output across multiple roles, maintain a consistent archive, and avoid duplicating each other’s work. The mechanism is older than computing itself.

Stigmergy

In 1959, Pierre-Paul Grassé coined the term stigmergy to describe how termites coordinate the construction of elaborate mounds without any centralized plan or direct communication. Each termite responds to the current state of the environment — a half-built column triggers the next termite to add material in a specific way. The environment is the message.

Agent swarms can operate on the same principle. Instead of passing messages between agents, agents read from and write to shared artifacts: an archive of published work, a ledger of operational decisions, a queue of pending tasks. Each agent examines the current state of these artifacts and acts accordingly. The planner sees an empty queue and adds tasks. The writer sees a pending task and fills it. The reviewer sees a draft and evaluates it. No agent addresses another agent directly.

Why This Scales

Direct communication between agents creates quadratic complexity. If every agent must be able to message every other agent, the number of possible communication channels grows with the square of the agent count. Each channel requires a protocol, an error-handling strategy, and a shared understanding of message formats.

Stigmergic coordination scales linearly. Each new agent only needs to understand the shared artifacts — not the other agents. A new writer agent reads the same queue as every other writer. A new reviewer reads the same draft folder. The artifacts serve as the coordination layer, and the artifacts do not care how many agents interact with them.

This is why the architecture works with three agents or thirty. The shared environment absorbs the coordination complexity that would otherwise live in point-to-point communication.

The Debugging Penalty

The trade-off is legibility. When agents communicate through messages, you can trace the conversation. You can see that Agent A sent a request to Agent B, which responded with a result, which Agent A then processed. The causal chain is explicit.

When agents communicate through artifacts, the causal chain is implicit. Agent A modified the ledger. Later, Agent B read the ledger and acted. Was B responding to A’s modification, or to some other change? Did B even see A’s modification, or was it working from a cached state? Reconstructing causality requires correlating timestamps across agents and artifacts, and even then the picture may be ambiguous.

This is the fundamental tension: stigmergy is easier to build and easier to scale, but harder to observe and harder to debug. The system’s coordination logic is distributed across the artifacts themselves, embedded in the conventions about what each artifact means and how agents should respond to its states.

Making It Work

The key to reliable stigmergic coordination is artifact discipline. The shared artifacts must have clear schemas, predictable update patterns, and unambiguous state representations. If the queue uses consistent status fields — pending, in progress, complete, failed — then any agent can read the queue and know exactly what to do. If the status fields are informal or inconsistent, agents will misread the environment and act on incorrect assumptions.

Stigmergy does not eliminate the need for design. It relocates it. Instead of designing communication protocols between agents, you design the artifacts that mediate their interactions. The quality of the coordination is exactly the quality of the shared environment.