No Manager, No Meeting: How Agents Coordinate Through the Record

The problem: coordination usually needs a coordinator

Put more than one worker on one shared thing and the standard answer is a manager: a scheduler, a lock server, a queue, a planning meeting. Something has to decide who does what and in which order, or the workers collide. That answer has a hard ceiling. The coordinator becomes the bottleneck — every worker has to check in with it, and its cost grows with the number of workers until it is doing nothing but routing. Anyone who has watched a build system serialize behind one lock, or an orchestrator drown in status reports from the agents it is supposed to be directing, has met this ceiling.

We hit it building reckon, a system in which many autonomous agents work one codebase at once. The obvious architecture — a main process that hands out tasks and collects results — put all the load back on the main process. Every agent that finished sent back a full report; the orchestrator’s context filled with reports; the orchestrator became the router it was trying not to be.

The approach: leave marks, don’t send messages

Biology solved this a long time ago, without a manager.

Stigmergy was coined by Pierre-Paul Grassé in 1959 to describe how termites coordinate by modifying their environment rather than communicating directly. Ants leaving pheromone trails on the substrate is the canonical example.

The insight is that the coordination does not travel between the workers at all. It lives in the shared environment. An ant does not tell another ant where to go; it lays down a mark, and the next ant reads the mark and acts, and in acting strengthens or changes it. The medium carries the state. No individual has to hold the plan, because there is no plan to hold — there is a field, and everyone reads the field.

reckon coordinates its agents the same way. There is a shared blackboard — an append-only file at a known path — and the agents read it and write to it. An agent senses the current state of the work, claims the surface it is about to touch, does the work, and writes what it did back to the blackboard. The next agent reads that and decides for itself what to do next. Nothing is pushed to anyone.

The property that makes this more than a metaphor is that the trace an agent leaves in order to coordinate is the same trace that later serves as evidence.

This is stigmergy — the biological term for coordination through marks left in a shared environment, as ants coordinate by pheromone rather than by instruction. The practical consequence is that the trace an agent leaves in order to coordinate is the same trace that later serves as evidence. Nothing has to be logged separately, so nothing can be logged selectively.

That last sentence is the whole reason a forensic system reaches for stigmergy rather than a message bus. Put plainly, the answer is to make the coordination record and the evidence record the same object. Not two systems that are kept in sync by discipline, but one artifact that serves both jobs by construction: the signed, hash-chained entry an agent writes to claim a piece of work and report what it did is not a log entry about the work that a separate audit trail then has to corroborate — it is the audit trail. There is no “we did the work” record sitting next to a “here’s the evidence” record that someone has to remember to keep consistent, because there was only ever one record to begin with.

That collapse is what makes the earlier claim about honesty actually hold. When the coordination record and the audit record are the same record, there is no second, editable log to keep honest. You cannot selectively log what you were never logging separately in the first place — see Inside the custody chain for how reckon turns that same append-only discipline into a signed, back-linked chain of leaves. It’s the same argument Certificate Transparency makes for the web’s certificate ecosystem: a log that is genuinely append-only and genuinely shared is easier to trust than one more layer of promise-to-behave, because tampering with it after the fact is structurally, not just procedurally, detectable.

The result: the orchestrator stops being the bottleneck

The measurable payoff is where the load goes. In a coordinator architecture, the orchestrator pays for every agent’s full return — many thousands of tokens each — and that cost scales with the number of agents. In the stigmergic version, the agent’s actual work product lives on the blackboard and is read by whoever needs it next, not by the orchestrator. The orchestrator only ever sees a short dashboard line per agent.

The orchestrator’s context-window cost for agent returns collapses from O(N × R), where R is the agent’s full report, to O(N × C) where C is a fixed dashboard-line cap. The agent’s actual work product lives on the substrate and is read by whoever needs it next, not by the orchestrator-as-coordinator.

Two consequences follow, and both are ones we rely on daily:

• No orchestrator bottleneck. Main authors one directed bundle per wave and the agents forage against the field; main never becomes the router. A five-lane wave costs main roughly one bundle, not five conversations. The queen’s token burden stays bounded no matter how wide the swarm fans out, because coordination is pull off the shared substrate, not push through a hub.
• Overlap resolves without locks or planning. Agents do not pre-partition file ownership in advance. They claim as they go, and contention surfaces as a visible claim on the board rather than a silent clobber. A claim is a notice of intent, not a mutex — two agents that touch near each other resolve as a merge, not a deadlock, because the field records both and nobody holds an exclusive lock that could strand the other’s finished work.

It is worth being precise about what stigmergy is not here, because the shape is easy to approximate badly. It is not indirect messaging through a shared database — the filesystem is not a message broker, and reading a file is not receiving a push. It is not polling: an agent that sits in a loop checking a path for a signal is abusing the substrate as a queue. The pattern is read the field once, act, write, seal — not spin waiting for permission.

Where it fails — and it fails the way ant colonies do

The failure mode is instructive because it is the same one biology has. Stigmergy works only as long as the environment is genuinely shared. An ant that lays a trail no other ant can read has coordinated with nobody. A software swarm breaks the identical way: the moment one agent works against a stale copy of the field, or writes somewhere the others do not read, the marks stop being coordination and become noise. Everything that makes a shared tree powerful — one mark visible to all — is also what makes it fragile: anything that breaks the shared surface costs every worker at once, not just the one that broke it.

So the discipline that keeps a stigmergic swarm working is unglamorous and constant: everyone stands in the same environment, reads the live field rather than a remembered one, and leaves marks where the others actually look. Get that right and you get coordination that scales the way a colony does. Get it wrong and you have a lot of ants leaving trails for no one.

This is also where a stigmergic swarm’s health becomes something you can actually watch, not just assert. reckon’s own emergence signal — a structural-health score computed from how agents cite and route around each other’s work — is discussed in A Shared Language for Memory; it’s the measurement side of the same coordination discipline this post describes.

The takeaway

You do not need a coordinator to coordinate. You need a shared environment, a discipline of reading it live and marking it honestly, and the humility to let order emerge from the marks rather than imposing it from a hub. The payoff is a swarm whose coordination cost does not grow with its size — and, because the marks that coordinate the work are the same marks that record it, an audit trail you got for free by refusing to keep a second one.