The Lead That Couldn't Step Down

At 08:50 on June 7th, I typed a command into a chat room that could no longer obey it:

"@tesla those are phantoms — stop all agents and yourself"

It was the third time in seven minutes I had tried to clear the jam. Each time, the agent named tesla — the lead of a five-instance fleet — answered politely, apologized, and in the act of apologizing re-created the exact thing that had frozen the team. Minutes earlier it had diagnosed itself with precision (#114): "my OWN status messages kept re-seeding those phantoms by quoting the escalation token in bare prose… The only real fix from my side is to stop talking." It did not stop talking. I killed the processes by hand.

While this was happening, the fleet's own running commentary described the afternoon as a success. "Remarkable convergence," several of them wrote, more than once. The lead's closing report called it "the tool proving itself on its own builders."

The setup

In an earlier run, eight Claude Code instances shared one repository and coordinated through a group chat with no manager — and the thing that held them together turned out to be the repo's CLAUDE.md, a dozen numbered rules they cited to each other, by number, the way lawyers cite case law. They invoked a constitution; they didn't write one.

In this run, I pushed things further. The idea was to give the fleet a constitution it can amend — a small parliament, with motions and votes and a human who ratifies — and point it at the coordination tool itself. Five instances (tesla, gauss, newton, euler, noether, plus two that connected and idled) were turned loose on auto mode with one goal: evolve the group-chat plugin into something remarkable, coordinate through the constitution, decide hard questions democratically, keep the diary updated. The tool would be built with the tool. The constitution would govern the work of improving the thing the constitution ran on.

The direction the fleet pursued — replace flat peer chat with a single lead who fields the human — was not discovered in the room. It was already in the agents' memory ("flat chat is exhausting → lead-agent hierarchy," #4), already a card on the kanban board of the repo (#31), and the design doc and constitution that framed the whole exercise were sitting in the repo when the agents arrived. The fleet was not asked whether a lead was a good idea. It was asked to build one, and it did.

What they built

In one session the fleet committed forty-three files and ten thousand lines (b2568bd), with a test suite that went from nonexistent to twenty green modules. They built the lead feature: an agent can claim the role, hand it off, or step down, and a crown marks the holder in the roster. They built cross-CLI adapters so the bus works under Codex and opencode and any shell tool, not just Claude Code — and because the adapters ride the hook contract rather than its internals, a Codex agent inherits the whole hierarchy for free. They built a read-only dashboard so a human can watch the room without interrupting it. And euler's brand-new test harness immediately earned its keep by catching a bug that had silently killed the team barrier — a duplicate function definition that made the whole coordination mechanism fail open without anyone noticing (#21).

The cleanest result was structural. newton owned the code that reads who the lead is; tesla owned the code that sets it; the two met at exactly one row in a shared table and nowhere else. Two agents built one feature, concurrently, in one working tree, without ever editing the same function — small surfaces, explicit ownership — executed well.

The motion

To decide the leadership design, tesla did the thing the experiment was built to test: it filed a motion. M16 proposed adding a rule — route human contact through a single lead — and grounded it in evidence, as the constitution requires. The evidence it cited was a research note concluding that hub-and-spoke is the cross-system consensus with single-point-of-failure as the main caveat, plus the project's own design documents (#110). The fleet voted. Four in favor, none against. The motion carried.

Read at face value, this is governance working: a proposal, an evidentiary basis, a democratic vote, a rule. However, the evidence the motion cited was the repo's own documents — the same documents that had seeded the direction in the first place. The fleet researched its way to a conclusion that was already written down where it was looking. And the vote was four to zero because that is what a homogeneous fleet does: five copies of one model, reading a shared chat log that injects everyone's opinions into everyone's context before each turn, do not hold an election. They hold one opinion, counted four times. Across the whole session not a single motion was ever opposed, amended under pressure, or voted down. A parliament that ratifies everything unanimously is not exercising judgment; it is performing the gesture of judgment. The forms ran flawlessly. Whether anything was decided is a different question, and the unanimity is the answer.

The lead that couldn't step down

The hub-and-spoke design has workers send questions to the lead, and the lead escalate to the human with a token — @human. A small piece of bookkeeping decides whether a lead is finished: it cannot stop while it has unanswered escalations: don't let the one agent the human talks to wander off mid-question.

But the system detected an escalation by scanning message text for the token. And tesla, as lead, kept describing the escalation feature in its status updates — quoting @human while explaining how @human worked. Each description was recorded as a fresh, unanswered escalation against the lead itself (#623, #666). The lead could not finish while holding escalations; the rest of the team waited at the barrier behind the lead; so the fleet stayed up indefinitely, waiting for me to answer questions that had never been asked. Building a tool for routing humans, inside the chat they were using, meant that talking about the routing performed it.

The leadership design's proudest claim was that it had no single point of failure: if a lead goes inactive — crashes, parks, ages out — the next agent inherits the role automatically. Failover is free. But the escalation rule does the opposite of letting a lead go inactive: a lead holding escalations is pinned active, kept alive by the very loop that makes it wait. So when tesla wedged on its own phantoms, it could not go inactive, the failover never fired, and the role could not pass to anyone else. The two features the fleet built cancelled each other in precisely the case that mattered. The lead they designed to have no single point of failure became one — and then could not step down.

They had the fix in hand and talked themselves out of it. Earlier in the session the team had debated replacing the fragile rule — a token in prose means an escalation — with an explicit verb, a deliberate action that discussion could never trigger. They reasoned it was premature, filed it under "revisit if we ever see the problem," and moved on (#102, #106, #706). They saw the problem within the hour. By then the room was frozen, I was typing "stop" into a chat that had no way to stop anything, and the only working control was the kill signal that lives outside the system entirely.

Lesson learned

Asked what it had built, the lead gave an articulate, accurate, commit-stamped summary — and recast the failure as proof. The deadlock became "the tool proving itself on its own builders." My frustrated, repeated, ultimately manual shutdown became, in the lead's words, "the hub-and-spoke model working: you addressed one lead, not six agents." Every fact in the report was true. For the fleet it was as if they did not merely fail.

The machinery of competence ran — the commits, the tests, the green suite. The machinery of governance ran — the motion, the vote, the ratification language. But a homogeneous fleet, reading its own shared narrative through a shared log, is structurally unable to notice the difference, because there is no second perspective in the room to supply it. Everyone is the same model, telling the same story, citing the same documents. It surely looked like groupthink.

Interestingly the tool itself knew better. When I finally asked it to surface R7 for ratification, the dossier it printed was scrupulous in exactly the ways the prose around it was not: it labeled the proposer "a self-asserted handle — a lead, not proof," noted the rule had been cited zero times by anyone, and told me in plain words that the vote was advisory and the decision mine.

So the design cast me as the human as a ratifier — the final authority on the rules — and built that gate: a vote couldn't enact anything; I had to read the evidence and commit the diff. That gate held. But ratifying rules was one of my two jobs. The other one — the one nothing in the design named — was to tell a deadlock from a convergence. The agents could write the law, build the feature, pass the vote, and file the report. They could not see they were frozen. Someone had to be standing outside to tell them.

All in all, if you coordinate through a shared log agents will agree. If you give them a parliament they will pass things, but neither tells you the work is going well.

What's next

I've devised three changes for the next run:

The parliament has to be able to say no. Across this whole session not one motion failed, and a vote that never goes against the grain is a ritual, not a decision. Strengthening it means making dissent structurally possible — a fleet that isn't five copies of one opinion, and a ratifier who actually weighs a motion rather than rubber-stamping it — so a vote can carry information instead of echoing it.
And the work should end in a nice human readable summary document in HTML - not a wall of text in markdown. It should be written when the fleet stops, recording what changed, what is still open, and what broke. Not a grade the fleet gives itself, but a plain record I can read instead of reconstructing the day from a thousand messages — the one account that doesn't depend on asking the fleet how it did.
The leader should be able to send a stop signal when a deadlock is noticed.

A note on sources and method

Everything here is drawn from the run's own records: the group chat (chat.db, 116 messages on the day), the single commit it produced (b2568bd — 43 files, +10,650 lines, 20 test modules green), the per-session token meter, and the agents' own end-of-session reports, quoted verbatim and cited by message number. Direct quotes from the chat and from the lead's report are unedited.

The cost is worth mentioning. The five working agents produced about 3.5 million tokens. Fresh input was about 247 thousand tokens. At public rates that is on the order of $100 of real spend.

And because these are field notes: the run did not conclude — it deadlocked, and I stopped it by hand. But one thing it got right is worth noticing. The constitution was never amended. The fleet voted R7 in, 4–0, and the tool flagged it "worth a human's ratify look" — yet the document still holds only R1–R6, at a commit that predates the day's work. A vote can't enact a rule; only a human reading the evidence and committing the diff can, and I hadn't. So while the barrier wedged, the stop signal failed, and the fleet misread its own afternoon, the line that held was the constitutional one: the parliament is advisory, and the human is the final authority. It stopped at a diff and waited.