Omnigent · chapter 1 of 4

A model turn that reads stored evidence and moves a card is a function call with a token bill.

The fleet’s orchestrator is one durable conversation per card. It wakes on events and shepherds the card from spec to ship. On August 29 I read the fleet’s own telemetry to find out what that cost, and the answer was 54% of all tokens over the prior seven days, 20.9 billion of 38.8 billion, with 63% of its turns deciding nothing. Most wakes were the conversation answering its own writes. The rest were a model reading a stored review verdict and moving a card one column, which is a function call with a token bill.

The rule that followed: code owns any transition whose evidence is already stored; the model decides only what needs judgment. This note is where that line runs.

Three seams

The first seam is the stage executor. It moves a card from reviewing to shipping when a review pass is stored, from verifying to shipping when a confirm-or-refute round stored a pass, and from fixing to shipping when a verify bound to the head commit already exists. Three moves, each on a fact in the database, and the executor cannot dispatch a worker at all. It is forbidden from importing the dispatch path. When the evidence is missing or contradicts itself, the card waits for the saga, which is the model.

One card's lane, and who moves it reviewing → shipping · stored pass fixing → shipping · head-bound verify speccing building reviewing fixing verifying shipping admission verdict verdict into shipping DISPATCH SEAM launches workers from Python; no LLM beat (replaced a ~7-minute coordinator turn) STAGE EXECUTOR moves a card on stored proof: reviewing → shipping on a stored pass, verifying → shipping, fixing → shipping on a head-bound verify; never dispatches SAGA one durable conversation per card; wakes only to decide: admission, a verdict, a block stage executor moves the card on stored proof the saga decides unmarked arrows: the lane's order
Fig. 01 — One card, three owners. The saga is a durable conversation that wakes only to decide — admission, a verdict, a block. The stage executor moves the card on stored proof, never dispatching. The dispatch seam launches workers from Python with no LLM beat, where a coordinator turn used to take about seven minutes.

Fig. 01 · pinch or scroll to zoom · drag to pan

The second seam is dispatch. A coordinator model used to wake every few minutes, read the board, and decide to launch the worker the board already implied, a turn that took about 7 minutes at the median. The launch is now Python: the same admission checks, the same worktree and branch, no model. The coordinator kind is retired. A triage heartbeat still runs as a model turn, because triage is judgment.

The third seam is routing. Which model builds a hard card, which reviews a docs change, at what effort, used to be a pile of hard-coded picks. It is now rules in priority order that forward a card to a target group, and a table of job by difficulty that names the harness, the tier, and the effort. Every dispatch returns a decision object that names the rule that made it, so an audit reads the rule, not the prompt. The floors on review of sensitive paths are in the table, not in a prompt, so no card can talk its way past them. The table moves: the casting note describes August 28, when Fable specced and Sonnet built; by the capture below, a week-old revision had moved speccing to Codex and taken Fable off every unconditional path, with the reason recorded in the table’s own history. A routing change is a saved revision with a sentence, not a prompt edit.

Fig. 02 — Routing as a table. Five rules forward a card to a target group; the matrix names the model and effort for each job at each difficulty; the counts are the last seven days. — live board, main at bf1ee19, September 12, 2026

Fig. 02 · pinch or scroll to zoom · drag to pan

What it did to the bill

The three changes on August 29 and 30 were narrow. Stop the saga waking on its own writes, which was 552 wakes in three days at 98% no-op. Give the runner a composite dispatch call and lean card reads, so a wake that must happen stops paying a 74 KB brief and a 71 KB message to return about 200 bytes. Hold quietly between events instead of polling. The executor followed over the next week, and the saga’s remaining job is the one a model should have: admit, judge, block.

By the fleet’s own usage rollup, orchestration was 22% of the day’s notional spend on August 29, 9% on September 11, and 3% on September 12, a day the board merged 246 cards. Those are notional API-rate dollars on subscription seats, useful for ranking roles against each other and never a bill. Where the day’s spend went instead: 46% to implement and 38% to review, which is where it should go.

Batching is the same rule for shipping

The ship gate is the executor’s idea applied to merging. A gate run is candidate prep, a repo-wide collect-only sweep, then the smoke floor, 150 to 175 seconds when measured, and until September 12 every PR ran its own. The batched gate takes the shipping-stage PRs together and runs its two phases side by side. In the fleet’s gate table, runs and distinct candidates were equal every day of the prior week, one run per PR. From 17:00 on September 12 it was 31 runs over 12 candidates, then 29 over 9, 24 over 9, 28 over 9, about three PRs a run. The gate’s own median went from 55 to 38 seconds. Nothing about that needed a model either.

Fig. 03 — The console I actually run it from: 14 of 20 slots in flight, 11 blocked, 14 that need me, on a phone. — live board, main at bf1ee19, September 12, 2026, hostnames blurred

Fig. 03 · pinch or scroll to zoom · drag to pan

What the model still decides

The saga still decides admission, because whether a card is ready is a judgment about its spec. It still decides what a verdict means when the reviewer and the verifier disagree, and it still decides to block. Triage is a model turn. The executor never invents an edge; where the stored evidence is stale, malformed, or missing, the card waits, and a custodian files a card about the wait.

The limit is the one the rule states. The executor only knows the evidence the fleet stores, so a review pass stored against the wrong head, or a verify that skipped a lens, moves a card it should not. That is why the pass itself has to be earned, which is the next note. And the count I still owe is the after-window of saga wakes per card, which the fleet records and I have not yet read.

Underneath

The August 29 token read and the wake counts are from the fleet’s telemetry, attributed by session role; the design that proposed the changes survived a three-reviewer pass that refuted its first draft’s effect sizes, and its second draft is the one I quote. The daily spend shares are the fleet’s own usage-by-role rollup, read on September 12, 2026. The gate counts are its gate-run table, same read. The executor’s three moves, the retired coordinator, and the routing table are the fleet’s own code and its routing page as captured that day. The “function call with a token bill” framing is mine. Anthropic’s guide to building agents draws the same line: workflows are “systems where LLMs and tools are orchestrated through predefined code paths,” agents are systems where “LLMs dynamically direct their own processes,” and its advice is to find “the simplest solution possible.” HumanLayer’s 12-factor agents states it as a factor: own your control flow. Anthropic’s write-up of its own multi-agent research system puts multi-agent runs at about 15 times the tokens of a chat, which is the bill this note is about.

This project

This project, in order

Start

Tell me what’s stuck

I’ll tell you in about a day whether I’m the right person. The first conversation is fit, not a free architecture review.