Claude Code: The Fleet: Long-Horizon Autonomy, Multi-Agent Systems, and Production Scale

For eleven nights in June 2026, a scheduled agent reported green in the morning run list. It had triaged nothing. The eleven runs came to $20.90, and four people spent eleven mornings believing the overnight failures had been handled.

The documentation is plain about what green means: the session started and exited.

Nobody on that team was careless. The routine had been reviewed, and the prompt carried a stop condition and a turn cap. The failure needed one signal to be trusted for something it never claimed. This book names the habit behind nights like that: the unread run, where a status was read and a transcript was not. It is Book 1's unread diff with the diff taken away. The tokens were the cheap part. The belief was the expensive part.

Claude Code: The Fleet is the third rung of a three-rung ladder, the rung where the work happens while you are asleep and you are accountable for it anyway. Every mechanism in it answers one question about a run that finished at 02:14 without you: what did it leave behind?

It is an operator's discipline, not a topology tour. Chapter 14 prices a 12-worker migration across 412 files at $340 in tokens, then adds the 31 hours of human review it took to merge: $3,285 against a manual baseline measured at $2,100. It finished early, merged clean, broke nothing, and lost $1,185. A second workflow there loses money every night it runs and stays in the book.

Sixteen chapters, one named frame each, every field transcript carrying a failure and its recovery:

• The mission and the envelope. Six parts a second reader can predict an outcome from, and the bounded space the run may move in: execution surface, blast radius, and what wakes a human.
• The survival set and the resume contract. The state that has to live on disk to survive compaction and restart, proved by killing a run mid-flight and requiring every item exactly once.
• The work receipt. What a run leaves behind that can be read without asking the agent what happened.
• The coordination tax and the ownership manifest. What a topology costs before it adds throughput, and the file that assigns every path to one worker before twelve of them start.
• The dead task and the canary window. The eval that still reports a pass after its assertions stopped asserting anything, and the arm that catches a one-line memory change in 40 missions instead of 4,000.
• The named blocker and the divergence turn. The layer that stopped an attack, proved by removing it, and the turn where the plan went wrong, which is almost never the turn where the damage landed.
• The autonomy P&L. Tokens, review hours, rework, and incident cost against a baseline you measured rather than remembered.

None of it requires a platform team, a vendor contract, or anybody's permission. The companion repository ships a service with a 40-item backlog and a 412-file monorepo with the barrel-export collision seeded, and you can clone and run both. Every chapter opens by naming what it assumes you already run, so a reader arriving here first knows what to look up.

Anything version-sensitive carries the date it was checked against live documentation, because these surfaces move. For the staff engineer who has been asked twice this quarter whether the thing can run overnight, and wants to answer in writing. The Claude Code Ladder, Book 3: OPERATE, the rung where the work happens without you.