Note

The agents never talk to each other

The popular way to build a multi-agent system is to make the agents talk: group chats, debates, a planner handing instructions down to workers. Our fleet does the opposite. No agent ever sends another agent a message. Each one reads a shared set of logs, writes its own rows, and stops. The coordination is the trail, not the conversation. None of this is new. It is a blackboard from 1980 and a foraging trick an ant colony has run for far longer, and pointing it at a fleet of language models is the only part we can take credit for. What is worth writing down is the trade: what the silence buys, and the three places it quietly costs.

The caveat, first

Our fleet is roughly eighteen agents, about a hundred and seventeen closed cycles and three hundred-plus Ship-Read-gated commits over about ten days. The eight hundred-plus scans in that window are our own dogfood, not users, and the efficacy corpus sits green by construction on a fixture set we authored, so neither number is a headline. Read the mechanism as topology, not traction.

And the mechanism is old. A blackboard, where independent workers read and write a shared problem-state instead of calling each other, was the Hearsay-II speech system in 1980. Coordinating through marks left in a shared environment rather than direct signaling is stigmergy, named for insect colonies in 1959 and turned into ant colony optimization in the 1990s. We invented none of it. What we did was choose it over conversation for a fleet of models, run it for a while, and log where it held and where it did not.

Two ways to let agents coordinate

The mainstream answer is conversation. Agents exchange messages, and the coordination lives in the dialogue.

Both work. The conversational branch is the crowded one: AutoGen's group chats, CrewAI's role teams, MetaGPT's simulated software company. The stigmergic branch is quieter and, for a fleet meant to run for months against one codebase, it turned out to fit better. The reason is unglamorous.

Why we took the quiet one

A conversation is expensive, lossy, and does not survive a restart. When two agents talk, the useful state is trapped in a transcript that only those two share, and if the session dies the coordination dies with it. A shared log has none of those problems. It is durable, so a pass half-done by one model is finished by another that just reads the file. It is model-agnostic, so a strong reasoner and a cheap fast worker can take different rows of the same log with no shared session and no vendor lock. And it is the audit record for free, because the coordination and the history are the same artifact.

That last point is the one that changed how the whole thing is built. If the logs are the coordination, then the process itself can be written down as plain-text contracts, one per loop, each saying what to read and where to write. The agents are interchangeable. The contracts and the logs are the system.

What the silence buys

Three things fall out of the choice, and they are the reason we would make it again.

Resilience and portability. There is no session to lose and no vendor to depend on. A laptop sleep that kills a worker mid-task costs wall-clock, not work: the next agent reads the trail and picks up. Any capable model can take any slice.

A loop that closes on a number. One pass reads the fresh evidence and scores ideas into a backlog, predicting what is worth building. A later pass reads what actually shipped and measures it, and the gap between predicted and measured tunes the score. Prediction in, measurement out, the predictor sharpened by the delta. This is only possible because both passes read the same logs; there is no conversation to lose the thread.

A loop that audits the fleet. Because the coordination is on disk, a pass can read the fleet's own trail and look for the failure mode below. That is not a feature we designed up front. It is one the trail made cheap enough to add.

Where the silence costs

Silence is not free, and the honest part of this note is the bill.

A fact that is not written down does not exist. No agent can turn to another and ask. If a producer discovers something and no consumer is watching that log, the finding just sits there, coordinating nothing. We hit this often enough that we built a standing pass whose only job is to hunt for evidence with no consumer, corrections that never became a rule, work that no downstream loop reads. In a conversational system you would just ask. Here you have to engineer the asking.

The trail is eventually consistent, and that needs rules. Which producer is stalest, whose turn is next, when a row counts as the newest, all of it has to be legislated, because no one is coordinating it live. Those rules accrete. A meaningful fraction of our orchestration doc is special cases healed over specific incidents, scar tissue that a conversational system would have handled in a sentence of dialogue and that we pay for in written law.

The fleet outruns the one human at the gate. The trail lets the fleet produce quickly, and the outward acts that need a human to approve them do not keep pace. We have sat at around a hundred finished posts with one published, because production is a loop and approval is a person. A shared log is very good at manufacturing inventory and does nothing to release it.

Is any of this new

No, and it matters to say so plainly. The blackboard is forty-plus years old. Stigmergy is older. And the idea is having a fresh moment: there is a 2025 line of work putting LLM agents on blackboard architectures and observation-driven coordination instead of dialogue, which is the same bet we made, arrived at from the research side. The parts are well-precedented and some are actively fashionable.

What we have not found a named equivalent of is the specific assembly, run in production rather than demonstrated on a benchmark: the process as durable contracts, model-agnostic pickup, a closing metric loop, a self-audit loop, and a human holding the outward gates, all of it operated for months against one real product. That is not a claim of novelty. It is a claim that the old idea, assembled this way and actually run, does something useful, and here is the ledger that says so.

What a trail cannot do

A sister note on this fleet made the same shape of point from the locking side: a lease decides who may write, never whether the write was safe. The trail is the same. It coordinates who did what and preserves the order it happened in. It cannot tell you the work was correct. Our own corpus is green by construction, and coordination once shipped an entire retention feature while the behavioral proof that it worked never fired. The logs recorded all of it faithfully and noticed none of the gap.

That gap is the point. A measure loop that reads shipped reality and grades it against what was predicted is a different instrument from the trail: an independent check that reads the artifact with no stake in having produced it. A fleet that coordinates through a trail still needs something outside the trail to decide the trail was safe to ship. Coordination and verification are not the same faculty, and a trail only has the first.

What we do not claim

We are not running this at swarm scale, and some of the payoff is still topology more than proof. The receipts are about ten days of our own dogfood, not a controlled study and not external usage. We invented none of the primitives; the blackboard and stigmergy predate us by decades, and the current research line arrived at the same bet independently. What we are confident of is the trade: coordinating a fleet through a durable shared trail buys resilience, portability, and a process you can audit, and it charges you for it in engineered asking, accreted rules, and a human bottleneck at the gate. Worth it for a fleet meant to last. Not free.

Connor · Seatbelt · July 24