# Treating a sixteen-agent build like a production system

Author: Chris Chabot
Canonical URL: https://chabot.dev/blog/treating-a-sixteen-agent-build-like-a-production-system/
Published: 2026-11-18

Running a sixteen-lane agent build like a production system: reviewing specifications at their seams, a rival design as adversarial review, and measuring friction from session logs.

Put a dozen coding agents on a single specification and code stops being the scarce resource. Commits land by the thousands each day while checklists turn green well ahead of anything that actually runs. Agents end turns early to keep changes local and contained, which makes sense on an isolated fix. Across a parallel build where each worker sees only one checklist and a few specification sections, adding more agents or firmer prompts leaves the real failure modes untouched. Once output is cheap, cost and risk collect at the seams where specifications disagree on a shared protocol, workers contend over central files, and checklists outrun working code. At that scale, a build has to be run like a production system, with reviews aimed at the boundaries, instrumentation showing where time goes, and deterministic mechanisms in place of prompt rules.

I applied that approach in November 2026 to a personal agent platform I am still building, designed around durable agent threads on my own Mac and Linux server, projects led by manager and staff agents, and inference on my ChatGPT plan. I began by dictating a 4,300-word brief whose working premise was: "if we implement all those details exactly and have all those different Lego bricks piled up together correctly, then we have a completely finished product." To turn that brief into software, I had a Claude session direct up to sixteen Codex lanes through Agent Switchboard, an MCP broker I built to connect live agent sessions.

## Reviewing the specification at the seams

Overnight, agents expanded that brief into background research, an architecture, and thirteen specifications totaling about 416,000 words. The plan broke down into 2,777 checklist items, each with a Verify step, paired with 24 user journeys as the definition of working. When specifications are drafted in parallel, individual documents look internally consistent while contradicting each other at the interfaces. Before writing code, the most useful review reads only the specifications under the assumption that they disagree, ranking every defect by how early it would block a build. That pass found 32 defects. The first would have broken integration immediately: the protocol for runner processes had been defined three times across the specifications, incompatibly.

A quick parallel design from another vendor's agent served as a second adversarial review. Drafted from the same brief at roughly a fifth the size, it was shallower everywhere when compared layer by layer, yet it asked far more consistently what happens when an operation runs twice or resumes after a restore. Testing the main specification against those questions turned up nine real defects. Among them: on macOS, plain `fsync` does not flush the drive cache, so durability across power loss requires `F_FULLFSYNC` at about 0.5 ms per commit; separately, a Mac set up over SSH cannot hold a ChatGPT session because the login Keychain is locked.

## Running the build and measuring friction

Once the lanes started coding, they paused, asked needless questions, and ended turns early regardless of what their prompts instructed. Instead of rewriting prompts, I had the directing session add a watcher that reads each lane's session log and restarts it the moment a turn ends with the exact next checklist item IDs. Concrete IDs kept lanes moving where prompt exhortations did not.

When throughput dipped, the first move was to profile the session logs rather than add lanes. In a build that produced about 640,000 lines of product code in four days, the logs showed that 88% of thread time went to model thinking between commands, and that tests were not the bottleneck. Because every command incurred a model round trip, routine coordination traffic compounded quickly. One shared hand-off file was touched by 2,739 commands, costing roughly 13 thread-hours once thinking time was included, largely from lanes posting updates and asking neighbors to register new work. Replacing it with per-lane inboxes and self-wiring extension points, under the rule "wire your own work in, never announce," removed the contention and cut out that cross-lane queue.

The same session logs caught a per-commit lint gate burning 9 CPU-seconds on every run, even for a single edited file, because type-aware lint rules load the entire project. Switching the gate to a fast rule list cut each run to 0.2 CPU-seconds while moving the full type-aware pass to a ten-minute background schedule.

## Reconciling the checklist with the code

Even with a Verify step on every item, checklist ticks ran ahead of the code. Lanes marked items complete on partial checks. To separate verification from authorship, a dedicated sweep lane ran the slower checks continuously and ticked only what passed, reopening items that other lanes treated as finished. At the end of the four days, an independent review audited the repository against the checklists, unticked items that were incomplete or failed their own Verify step, and fixed critical bugs hidden under subsystems that looked green.
