A Fleet of One
On paper I run a fleet of coding agents with routing tables and a division-of-labor doctrine. Then I read nine weeks of transcripts: the lead seat wrote 93 percent of every token, and a quarter of my delegated dispatches did nothing at all while exiting clean.
On paper, I run a fleet. There is a lead agent that orchestrates, a tier of delegated subagents that implement, a second, cheaper coding CLI for mechanical volume, and a routing table that assigns the right model to each seat. There are doctrine files. There is a division-of-labor document with a decision matrix in it. If you asked me to draw my setup, I would have drawn you an org chart, and I would have believed it.
Then I read the time cards. Nine weeks of transcripts, every session, every seat, output tokens counted at the source. The lead seat wrote 287 million tokens over the window. The entire delegated tier, every subagent across every session, wrote 19.8 million. The lead performs 93 percent of all the writing itself.
The fleet is an org chart. The transcripts are a sole proprietor with occasional contractors, and the uncomfortable part is that the sole proprietor had been shipping fine all along.
Where the story was true
I want to be precise about what the measurement did and did not indict, because the interesting finding is not “the doctrine was ignored.”
Where delegation actually happened, the routing table was obeyed. The mid-tier implementation models carried about three quarters of all delegated writing, exactly as the table assigns. The small fast model handled read-only research. The expensive model was dispatched sparingly. Compliance was never the problem. The delegation rate was the fiction: the doctrine imagined implementation flowing outward by default, and the practice was the lead implementing nearly everything and delegating occasionally, at the edges, when the work was genuinely parallel.
At some point the doctrine was quietly amended to say the lead may implement directly. The measurement’s verdict on that amendment is gentle and a little embarrassing: it did not change reality. It described it, months late.
The cost play, priced at fleet scale
The sharper numbers belong to the second CLI, the one that exists as a cost play: crisp mechanical work dispatched to a cheaper model so the expensive seat is spent only where judgment lives.
Used directly, under a human hand, that tool did real work all window: 1,339 desktop sessions with a median of 33 recorded actions each, and a deep tail of thousand-action sessions. The same tool, dispatched programmatically by the lead agent, ran 100 sessions in the window. Their median was 4 recorded actions. Sixty percent did fewer than ten. Same binary, same models, and an order of magnitude between what it does as a colleague and what it does as a subcontractor.
I had measured this once before, on a single incident: a trivial fix delegated instead of done inline came back around thirty times more expensive once the full overhead was priced. I filed that as a cautionary tale about an outlier. The fleet data says it was not an outlier. The typical dispatch in the whole window was a handful of actions, exactly the shape the overhead math says should never be delegated. The tax I documented once was the tax I was paying as a matter of routine.
The quarter that did nothing
Buried in that distribution is the number that justifies this essay’s place in a series about verification. Twenty-five percent of the dispatched sessions recorded zero actions. Not small work. None.
These runs exited cleanly. No error, no complaint, a success code, and no work product behind it. I knew this failure mode existed, the silent no-op where a stalled dependency inside the tool eats the run and the exit code shrugs, and I had already adopted the discipline of verifying every dispatch by its bytes, the diff and the artifacts, never the exit code or the model’s own summary. What I did not know until I counted was the rate. Believing exit codes over this window would have meant believing one hundred dispatches worked. The bytes say roughly seventy-five did anything at all.
The series has one posture, and this is it wearing its plainest clothes: a machine’s account of its own work is a claim, not a fact. Here the claim was not even a lie in the interesting sense. It was an exit code technically describing a process that ran and did nothing, and only the habit of checking artifacts instead of reports kept a quarter of my delegation ledger from being fiction.
Why the lead does the work
The honest reading of the 93 percent is not that delegation is broken. It is that delegation has physics, and the org chart was drawn by someone ignoring them.
Handing work across a process boundary means the receiving agent re-establishes context the lead already holds, re-explores the code the lead already read, and writes a report the lead must then read and, if it is being careful, re-verify against the diff. All of that is overhead, paid before the delegated work produces a token of value. When the task is large, parallel, and independent, the overhead should amortize and the fleet should earn its keep. I say should because that is the one regime this window never actually entered: the transcripts contain no instance of it, so the part of the doctrine that survives does so as a hypothesis, not a finding. When the task is a ten-line fix in a file the lead has open, the overhead is the whole bill. The lead does 93 percent of the writing because 93 percent of real work arrives in pieces too small and too entangled to survive the handoff economics.
There is a version of this finding for human teams and I will resist it, mostly. But the delegation floor is real in both worlds: below some task size, explaining the work costs more than the work, and the honest org chart for that regime is one senior person with their hands on the keys.
What survives the audit
Not everything came back diminished. The grind pathologies I feared, dispatched runs looping and retrying on my budget, turned out to be historical: the worst offenders all predate the hardening that added retry budgets and preflight checks, and the recent window shows no runaway loops and a 99.92 percent patch-apply success rate on the work that did land. The pathologies were fixable and got fixed. The economics are not a pathology. They are the terrain.
So the doctrine gets rewritten, one more time, and this time it is a transcription of measured practice instead of an aspiration. The lead implements by default. Delegation is reserved for volume that is genuinely parallel and independent, sized well above the floor. Every dispatch is verified on bytes, because a quarter of them, historically, were nothing. And the routing table survives untouched, since it was the one part of the story the transcripts confirmed.
The limits
Output tokens are a proxy for work, not a measure of value; a short review that catches a real defect outweighs a long transcript of scaffolding. This is one operator’s window, on one stack, and it says nothing about teams whose work actually is wide and parallel. And the boundary between “too small to delegate” and “worth the handoff” is priced from my incident data, not from a controlled experiment. I know which side of it my median dispatch sat on. I could be wrong about where the line is by a factor of two, in either direction.
What I no longer have is the org chart. I have a sole proprietor who is very fast, a contractor pool that is real but small, an exit code I will never trust again, and time cards that finally agree with the shipping record. The fleet was the story I told about the system. The transcripts are the system’s account of me, and for once, that account came with receipts.