I build alone, and I can't hold every open thread in my head. So I built a fleet of AI agents that keeps the work moving without me watching it. My job is to make the judgment calls and review what shipped. The hard part turned out to be my attention, so most of the design is about spending it well.
The problem
Running one coding agent is easy. Running many at once is a different job. Each agent keeps running into questions that only I can answer: which design to pick, what to name something, whether to break an API now or later. If every one of those interrupts me, I'm a full-time babysitter for the agents, and running them stops being worth it.
The shape of the fleet
I started on July 11, 2026, with a decision queue made of plain files in a git repo. It has since moved to a database behind a small CLI called fleet.
- The orchestrator plans. A session takes the next work item, maps the code with read-only recon agents, and writes a blueprint for each piece of work.
- Builders work in parallel. Each builder owns its own set of files, so no two agents ever edit the same file at the same time.
- One integrator wires it together. A single agent does the shared wiring and runs the full test suite.
- Reviewers attack the work. A separate agent checks each delivery against its blueprint and looks for what the builder missed.
- Tests run off my machine. Full test suites freeze my workstation, so they run on always-on test machines in my homelab cluster.
- Everything ships by pull request. Agents merge their own PRs and write a ship-log entry for each one. The ship log is what I actually read.
When an agent hits a real judgment call, it doesn't guess. It banks a decision: it writes down the question, the context, its recommendation, and the alternatives. Then I rule on decisions in batches.
In about fifteen weeks, the orchestration repo reached about 10,600 commits. I ruled about 2,700 decisions myself, and agents ruled about 900 more from patterns I had already set.
What broke, and what I changed
Defaults that shipped before I saw them. At first, agents could take a "vetoable default." They picked an answer, kept going, and I could overrule it later. On July 28, I overruled one: a context-token ceiling in myelin, my agent runtime. By then it was already written and merged, so the code had to change. A default that has already shipped can't really be reviewed. So I changed the rule. Banking a decision now stops the work that raised it until I rule. Other work keeps moving.
Too many decisions. Once banking stopped work, agents banked everything. Some of it wasn't a decision at all. A broken tool is a bug, and a question that depends on a number nobody has measured is a measurement task. So the test became one sentence: is there more than one defensible end state? If not, the agent files a work item and keeps going. Now a check refuses to bank anything that fails it.
Decisions faster than I could rule. The fleet could produce questions faster than I could answer them. So rulings became batch sessions: an agent groups the open decisions and gives me multiple-choice questions, with a recommendation first and the cost of reversing each choice. Later I added a pass that drafts rulings for any decision that one of my standing patterns, drawn from past rulings, already answers. Every draft gets an adversarial review before it's filed, and I can reopen any of them.
What I learned
- When an agent guesses, I end up reviewing its guess later. When it asks and moves on to other work, nothing waits on me except the question.
- Spending my attention carefully mattered more than making the agents faster.
- Rules I only wrote down got broken. Rules enforced by a hook or a check held. The check that refuses non-decisions is one example.