The agents never talk to each other

No agent in our fleet has ever sent another agent a message. There are no group chats, no debates, no planner handing instructions down to workers. 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, where it quietly costs, and the finding we did not go looking for, which is that the constraint was never the agents. It was the one human at the gate.

The caveat, first

Our fleet is roughly eighteen agents. As of this writing it has closed 139 cycles and pushed more than three hundred Ship-Read-gated commits in about eleven days. The 964 scans in that window are our own dogfood, not users, and the efficacy corpus sits green by construction on a fixture set we authored. The numbers show the mechanism runs; they do not show demand.

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. 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

There are two places to keep the coordination: in the conversation, or in the artifact. Put it in the conversation and agents exchange messages, with the shared state living in the dialogue. Put it in the artifact and they read and write a common record instead, with the state on disk.

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.

One thing to hold from the start, because it shapes everything after: the trail preserves what happened, not whether it was correct. The end of this note is about that gap.

No messages, or no sessions

A skeptical reader can deflate the headline in one sentence: an append-only log that every agent reads and writes is an asynchronous broadcast channel, message passing with extra steps. The objection is fair, and conceding it sharpens the claim. What the fleet actually lacks is not messages. It is sessions. No two agents are ever coupled synchronously, no coordination state lives in a conversation that must stay alive for the work to survive, and nothing any agent knows dies with a process. Every benefit this note attributes to silence (restart resilience, model portability, the audit record for free) flows from that property rather than from the absence of communication as such. "The agents never talk" is the memorable version. "The agents hold no sessions" is the accurate one, and it is the one the rest of this note is actually defending.

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. We did not design it up front; the trail made it 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 the audit loop from the last section exists: 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. And notice what that standing pass is: a coordination mechanism, bolted back on. The architecture removed message passing and then paid to rebuild a scheduled, rule-bound version of it.

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. This is the classic failure mode of a stigmergic system: the environment becomes the program, and the program grows. The fair question is whether rules ever get retired, and the answer so far is deliberately, and not enough. Some rules now ship with their own expiry, one current routing rule is written to delete itself the day after the launch it exists for, and review passes have retired stale tickers and whole content genres. But every one of those retirements was itself an act of legislation. The law has never gotten shorter on its own.

The bottleneck was never the agents

We first wrote this as a third entry in the bill above, and it does not belong there. The trail lets the fleet produce quickly, and the outward acts that need a human to approve them do not keep pace. The social pipeline has drafted 109 finished posts. The number published as the fleet wrote them is zero. Two went out after the human at the gate rewrote them, an agent in the loop but the human driving; the rest are inventory. This week we archived 23 unposted drafts in one sweep, not because they were bad but because the queue drifted stale while it waited at the gate. The gate, it turns out, is not a stamp. It is a rewrite, because production is a loop and approval is a person with taste.

Blaming the silence for that would be a miscategorization. Chatty agents would flood the same gate just as fast; a group chat can manufacture unshippable inventory as quickly as a log can. What the trail did was make the imbalance legible, because the inventory sits in a file with timestamps instead of dissolving into scrollback. And that zero is the most useful thing eleven days of ledger produced. We set out to answer how agents should coordinate, and the trail answered a different question: coordination was not the constraint. Human judgment was.

This shape has a name too, and it is older than the blackboard. Amdahl's law, from a 1967 argument about processors, says the speedup you get from parallelizing is capped by whatever fraction of the work stays serial, no matter how many workers you add. In an agent fleet the serial fraction is the human. Agents parallelize; judgment does not. Once the machines are chugging along, the throughput of everything that must leave the building converges on the rate at which one person can decide, and adding agents cannot raise that ceiling. So the fleet's standing answer, written into its own orchestration rules, is the only one Amdahl leaves open: you cannot scale the human, so you shrink the serial step instead. Make each decision one-click; never make it for them. A fleet meant to run for months needs a better way for agents to agree with each other far less than it needs a better way to spend the one resource that does not scale, the human deciding what leaves the building.

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 continuously against one real product. The claim is only that the old idea, assembled this way and actually run, does something useful, and here is the ledger that says so.

That claim comes with its edges stated: no swarm scale, no controlled study, no external users. The receipts are eleven days of our own dogfood, and some of the payoff is still architecture more than measured outcome. What we are confident of is the trade. A durable shared trail buys resilience, portability, and a process you can audit, and it charges for them in engineered asking and accreted rules. The human bottleneck it does not cause and cannot fix. Worth it for a fleet meant to last. Not free.

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.

Note · Connor · Seatbelt · July 25, 2026