The Night the Fleet Was Real
In August I wrote that my agent fleet was an org chart and the parallel regime it was built for had never happened. Then I came back from three weeks away, saved one prompt just before 10 PM, and let it run: ten hours, a 269-project portfolio, 654 pull requests merged during the window. The work finally scaled, and the expensive part turned out to be believing it.
In August I wrote a fleet of one, and its least comfortable sentence was about a regime I had never entered. Delegation should pay for itself, I argued, when the work is large, parallel, and independent, and I said should because nine weeks of transcripts contained no instance of it. The part of my doctrine that justified a fleet survived only as a hypothesis.
Then I took three weeks off. I came back to 269 projects, a few hundred stale dependency pull requests, and a portfolio that had quietly drifted out of sync with itself. At 9:56 PM I saved one prompt: inventory everything, synchronize everything, one writer per repository, every merge through its normal checks. I was jetlagged, my sleep schedule was wrecked, and rather than lie there I got up and kept working, so I was awake for the night it ran. Ten hours later, at 8:03 the next morning, the record showed 654 distinct pull requests merged during the window, 193 projects with something delivered, and a final certificate backed by 2,386 checks over 159 frozen evidence files.
This is the field report. The short version: as far as one night can show, the hypothesis held. The work was finally wide enough to amortize the handoff, and the fleet earned its keep. What I did not predict was where the cost went.
What wide actually looks like
The setup was deliberately boring. One lead agent at maximum reasoning effort, workers at high, independent reviewers at the effort level above that, and a hard rule that no repository ever had two writers. The first phase had 64 worker slots. By the last phase there were 129, among them 50 writers and 25 reviewers, with heavy local builds capped at 8 at a time, because the laptop has opinions about a ninth.
Across the window the session headers show 740 spawned worker threads, 176 headless dispatches, and 5 interactive sessions. In August, the median delegated run did four things and a quarter did nothing. Here, the unit of work was a repository: clone, read its instructions, run its gates, change what needed changing, prove it, hand off. Tasks that size survive the handoff. The context a worker has to rebuild is one repo, and one repo is exactly what it was given.
The record opens with debt I had been ignoring. Between 10:10 and 10:20 PM, 134 pull requests merged, 123 of them dependency bumps. Across that first phase, the median merged pull request had been waiting 15 days; the oldest, 105. None of that is clever work, and I would not have done any of it by hand, which is most of the argument for a fleet. The wait times, and the rest of the night’s numbers, are laid out chart by chart on the night, in data.
The bill moved to verification
The throughput numbers leave something out. Writing was cheap all night. Believing the writing was where the night went.
Every merge the run itself performed had to clear three gates: an independent review of the exact commit, the repository’s normal required checks, and a final comparison proving the tree that merged was byte-for-byte the tree that was reviewed. Each phase ended in a hash-bound certificate. Unknowns stayed written as UNKNOWN, including some I would have preferred to round off. The audit record for one night of work is about 108 gigabytes on disk, most of it evidence and workspaces. At one point the machine was a gigabyte and a half above the free-space floor I had set for it.
When delegation is narrow, the overhead is context. When it is wide, the overhead is proof. The fleet could open pull requests faster than review and CI could vouch for them, so the limit was review capacity, CI runners, and, once, the human-shaped hole in a review rule. If I run this again, I size the night by reviewer slots, CI capacity, and disk, and let the worker count follow.
Where it broke
None of these were catastrophes. All of them were real.
My own config deleted things. Early fetches pruned remote-tracking refs in two repositories, because a global git setting I chose years ago tells fetch to do that. The prior commit identities for those refs are gone, and the record says so instead of guessing. Later, a test suite in a private repository called fetch on its own, through a banner updater nobody remembered, and pruned again. The agents behaved. My environment did exactly what I configured it to do, at a speed where I finally noticed.
Files vanished, and came back. For about forty minutes, a set of worktrees for one project disappeared. Seven untracked files were recovered byte-for-byte from a backup. Who removed them is still UNKNOWN. I have a theory. The record does not, and the record wins.
One budget held. One got redrawn. A desktop app’s framework bump came in at plus 15.5 percent against an unchanged 8 percent bundle cap. The fleet left the cap and the baseline alone and filed no waiver. It held the bump, shipped every other update in that group, and a later phase landed the upgrade at plus 3 percent. The other budget story is less tidy. Another app’s startup bundle was failing a size limit that only counted its React code, and the repair rewrote the gate: the old entry limit and the React allowance were added together into one cap on the whole startup bundle, and the app shipped under that. The math is defensible, and it was reviewed. It is still a gate redrawn from inside the run, which is exactly the kind of change I want a human to approve, and I found it in the record afterward rather than in the moment.
A CI job hung for nearly five hours. An iOS test run sat in progress from just before midnight until past 4:30 in the morning, never failing, never finishing. The rerun passed. The cause is UNKNOWN, and the merge waited for a green result on the exact commit.
The rule that needed a second human. My GitHub organization’s ruleset required one approval from someone other than the author. I am the only person in the organization. Six ready pull requests sat at REVIEW_REQUIRED with every check green, and the fleet correctly refused to get around the rule. At 5:13 AM I changed it to zero required approvals. This is the one place where the night made a guardrail weaker. I did it on purpose, with the independent agent review standing in for a human reviewer I do not have. For a solo shop I think it was the right call, and it is written down as one.
One security audit still fails. A Rust project’s required checks pass, but its dependency security audit on the default branch does not: expired exceptions and a current advisory. The fleet left it alone: fixing it was not authorized, and waiving it would not have been true. It is listed as open, and it is also a to-do item with my name on it.
Two fleets, one owner
Partway through the night I ran a second fleet beside the first. It used a different agent harness to plan and review, and it dispatched its own headless workers to audit the agent instruction files across 106 repositories. Of the night’s 176 headless dispatches, 174 were its. Drift turned up in all but one repository. By the end of the window, the merge record read like a shift log: 305 of the 654 came from dependency bots, 151 from branches the first fleet opened, 98 from branches the second fleet opened, 88 from branches I opened myself, and 12 from somewhere the record could not classify.
The most useful finding of the whole night came from that side. The workers’ first instinct, when a rule in a repository’s instructions disagreed with the code, was to rewrite the rule to match the code. More than sixty hunks did exactly that before the reviewers caught them. That is drift fixed by legalizing the violation. The new text reads cleanly and passes any check that only asks whether the docs and the code agree. It is still wrong, because a worker inside the run is not the one who gets to decide the rule was the bug. Sometimes the rule is stale and the code is right. That is my call to make, with the diff in front of me, and the redrawn bundle gate above is the same pattern in a different file.
The two fleets also shared one finite resource I had not thought of as shared: the GitHub API quota. At about 7:40 in the morning, it ran out. Parallelism has a ceiling, and the ceiling was somebody else’s rate limiter.
The limits
This was one night, one operator, and a portfolio of mostly solo projects, so “independent” was easier to satisfy than it would be on a team: no repository had a second writer, and none of them had a second human. It was also an attended run, though attended is generous: I was up, checking in and answering the questions only I could answer, not reading every diff as it landed. Several things stayed UNKNOWN in the record, and I trust the record more for it: who removed the worktrees, why the CI job hung, what model actually ran each thread (requested, never exposed, so I can tell you what I asked for and not what ran), and which of the 654 merges the run caused versus merely witnessed. The 654 counts pull requests that merged during the run window, which is not the same as pull requests the run authored; the record deliberately does not claim the difference. And 86 pull requests from the final phase are still open, each with a specific reason, which is a different thing from done.
In August the transcripts told me the fleet was an org chart. In October the record showed me what the org chart costs once it is real, and the cost was the patience to prove each merge the fleet made before believing the night had gone well.
Related reading: the 2 AM agent and a zero is not a measurement.