Found something good?

Bookmark these 12 builds before you forget.

Introduction

You have the two most capable models ever made generally available, and you are still using one of them at a time, by hand.

Three things changed in the last month.

Run casually, these models are an expensive way to generate impressive wrong things.

Run inside a system, they are the closest thing to an employee you can rent. Anthropic's enterprise numbers put Claude Code at about $13 per developer per active day. OpenAI puts Codex at $100 to $200 a month.

This guide builds that system in twelve builds: the actual files, in order, each tested before publishing, with a checkpoint after each so you know a piece works before you stack the next one on it.

It is for anyone with a repo, a terminal, and access to either CLI. The examples are code-flavored because loops grew up around code, but the router, the advisor, and the gate work on invoices and reports the same way.

Read it in order, doing the checks. Each build takes 10 to 20 minutes, about two hours in total. The 30 days at the end are the schedule during which the system earns the right to run without you.

Three principles predict every design decision below:

The map, and why the usual one is wrong

Loop engineering is agentic workflow with an explicit stopping condition and retry logic. The harness decides when work is finished, instead of leaving "am I done" to the model.

The standard picture is swyx's Loopcraft stack: five loops nested inside each other, execution inside task inside product inside system inside oversight, each with its own exit. It is the best one anybody has drawn.

I used it for weeks. Then I tried to build against it, and it broke in four places.

1) Problem one: the loops do not nest.

Nesting means one turn of the outer loop equals one complete run of the inner loop. That is not what happens. The system loop does not wait for the product loop to finish. It runs on Sunday whether or not anything shipped.

You can interrupt a token stream by hand without unwinding four layers. It is a picture of containment drawn over a system that does handoffs.

2) Problem two: a loop drawn as endless is a bill.

The original draws the product loop that way. In practice it ends on a budget, on a checkpoint, or on somebody losing patience.

Calling that "none by design" hides the exact place where money leaks out of an agent system: a loop that nobody told how to quit.

3) Problem three: there is no abort.

Every layer has a happy ending and no unhappy one. Real loops need both: how it closes when it works, and how it stops when it cannot.

Every runaway bill I have seen was a loop with a defined exit and an undefined abort.

4) Problem four: verification is missing, and it is the whole game.

Verification is the contract between layers. When a lower loop hands an upper loop a report instead of a fact, the upper loop closes on a lie.

That single gap is why a loop can hit its stopping condition and still be wrong.

This is the version I build against.

The Evidence Ladder

Six rungs, two exits each, and one rule: control flows down as goals, evidence flows up as facts, and no rung may close on a report from the rung below it.

Five laws fall out of the shape.

Every rung has an abort, or it is a bill. If you cannot name how a loop ends badly, you have built a subscription. This is why ralph.sh carries two caps and the swarm carries a cycle cap.

Evidence flows up and control flows down. A rung closes on a fact produced below it, never on a summary written below it.

The factory gate is this law in SQL. Two reviewers said green. The gate still refused, because nobody had produced a passing test row.

A verdict is an opinion. A row is evidence.

Cost per turn climbs about tenfold per rung.

A bug that escapes rung 2 costs ten times more to catch at rung 3, and a hundred times more at rung 4.

That is the entire argument for putting your best verification as low on the ladder as it will go, which is why the gate is a bash script and not a meeting.

Timescale belongs to the model, not to the rung.

Rung 2 took minutes in 2024, takes hours in 2026, and will take days soon. Design against the exit condition, never against the clock. This is where the old picture ages fastest.

Only rung 5 has no exit condition, and that is what human means.

You live there. The ladder exists to earn one sentence: a loop can hit its stopping condition and still be wrong.

Tests pass, the gate goes green, both reviewers sign, and the last commit is still a mistake. Every rung below you exists to make that check smaller. None of them can take it from you.

Prerequisites

What you are building

BUILD 0: Configure the Engines

Set these before writing any file of your own. Every number below was verified against the official pricing pages the week of publication.

The bench: every seat, July 2026

The roster the system hires from.

Prices live in one skill file, .claude/skills/model-bench/SKILL.md, loaded on demand before any routing or cost question. No other file hardcodes a number.

Prices moved three times in the six weeks before this was written. A price in an article is wrong by publication. A price in a skill file is one edit.

The split that decides everything downstream:

That split is why this system is bi-vendor. Fable judges and plans, Sol reviews and drives terminals, and neither one does the bulk typing.

Two seats people misread.

Opus 4.8 is not the old flagship gathering dust. It is the automatic fallback under Fable and the recommended default for complex agentic coding. Your system inherits it whether you plan for it or not.

Sonnet 5 at introductory pricing is the best value on the board. Close to Opus 4.8 in capability at a fraction of Fable's input price, which is why it is the default executor everywhere in this build. That rate expires August 31, and the skill file already knows it.

That skill file is the only file in the system that contains a number:

Seven facts that change how you build:

The second meter: a seat is not an API key

Every number above is priced in dollars per million tokens. That is the right currency if you pay per call.

It is the wrong one if you run this on a $200 Codex Pro seat or a Claude Max seat.

On a seat the meter is a five-hour window and a weekly window, evaluated together, and one request counts against both.

You can be flush on the week and still locked out for four hours, because a single message ate the short one.

Same doctrine. Different currency. Three settings decide how much of a window one message can take:

Fast mode is the expensive one, because it multiplies a number that just got bigger.

GPT-5.6 runs far longer per message than 5.5 did. Mostly a gift. It also makes burn unpredictable.

Speed is not free. What it charges you for is the tokens you were going to burn anyway. Re-read the multiplier on the speed docs before you trust it: it is published per model, and it moves.

Ultra is the subtler trap, because the interface files it where the effort levels live and it is not one of them.

Pointed at a task that does not truly split, ultra buys four agents duplicating one investigation.

It is worth roughly 3.1 points on Terminal-Bench 2.1, 88.8 to 91.9, for a fleet's worth of burn. Off until the boundaries between the sub-problems are real.

Why Sol and Terra are both correct defaults

A field report runs Sol for nearly everything. The bench above makes Terra the Codex daily driver. Both are right, and the meter is the reason.

Rate is not cost. Cost is rate times turns-to-green, and the second term is the one that moves.

Which is BUILD 4's law arriving from the other direction: upgrade the seat before you touch the dial. On a seat that reads as Sol at high on the $200 tier, Sol at low below it. Measure before you believe either.

Set the Codex tiers now:

CHECK 0: both CLIs authenticate, and your test command exits 0 on the current repo.

BUILD 1: The Constitutions

These models follow laws and optimize around tips, so every line needs a number, a never, or a command that checks it.

Create CLAUDE.md:

Create AGENTS.md at the repo root, the same laws in Codex's dialect. Keep it near 100 lines, a table of contents, not an encyclopedia:

One doctrine must live on both sides, or whichever harness has the laxer habits wins every time you switch tools.

CHECK 1: for every line, ask whether the model could comply 80 percent and claim success. If yes, rewrite it with a number or a never. wc -l CLAUDE.md under 60.

BUILD 2: The Gate

A bash script must hold the final vote before anything else exists, because every later build assumes it.

Create gate/verify.sh for your stack:

Create gate/eval_gate.py, the seatbelt for every future routing or prompt change. It runs 50 to 500 held-out cases through the current config and the proposed one, with deterministic checks only:

Then make the gate unskippable as a skill, .claude/skills/ship-gate/SKILL.md:

The gate uses deterministic checks only, because it must never inherit the who-verifies-the-verifier problem. A routing change without an eval gate is a cost experiment you are running on your customers.

CHECK 2: ./gate/verify.sh exits 0 today, and eval_gate.py prints SHIP on its demo. If verify.sh fails now, fix it before anything else. The system stands on this script.

BUILD 3: The Heartbeat

The model brings intelligence. The loop brings discipline.

This is the exact shape behind Anthropic's 16-loop run that built a 100,000-line C compiler for about $20,000, with no orchestrator model anywhere.

Create loop/PROMPT.md:

Create loop/ralph.sh:

Swap the claude line for codex exec and the identical loop drives GPT-5.6.

The exit map is deliberate: 0 done or quiet, 2 circuit breaker, 3 budget. Every alarm in BUILD 12 keys off these.

The cost line reads the session's own JSON cost report, so the cap is enforced by the harness against real spend, not an estimate.

Count the stops in that prompt. Every branch ends in one, and that is the design, not a tic.

This generation runs much longer per message than the last one did. Mostly a gift. Occasionally a bill, because a model that no longer needs encouragement to continue will carry a task four steps past the point where you wanted to look at it.

The loop solves that structurally: one task per tick, hard stop at the end.

Interactively you have to say it out loud. Two prompts do the work:

A model that runs long is only dangerous when nobody told it where the edge was.

Long tasks fail the way context fails, so iterations stay short and the environment does the remembering. Fable 5 and the Codex models now compact their own context mid-run, so resist adding clever memory plumbing; the right amount shrinks every quarter.

CHECK 3: two tiny real tasks in TASKS.md, one hand-run tick at BUDGET_USD=2. Confirm one commit, one ticked task, one log line, and that the loop exits instead of starting a second task.

BUILD 4: The Router That Earns Its Job (model, then effort)

The most rigorous routing benchmark of 2026, LLMRouterBench, found many routers, including commercial ones, fail to reliably beat picking the best single model. So the router is guilty until proven innocent on your own traffic.

The decision rule, before any code. Add a router only when both of these are true:

If one well-chosen model beats your router on those evals, delete the router and bank the simplicity.

Once it clears the bar, router/router.py runs three layers, cheapest decision first. Note that the tiers name seats, never prices: the rates come from the bench skill at runtime, so a price change never touches your router.

The middle layer scores difficulty on markers you can read: why, debug, race, deadlock, refactor, security, plus code in the prompt, a prior failed attempt, and more than one subsystem touched.

Zero or one point goes cheap. Two goes mid. Three or more goes frontier. The cascade's verifier is deterministic and escalates exactly once.

Wire the same decisions into the harness so they fire without being invoked, .claude/skills/model-router/SKILL.md. Note that the skill does not restate the rules, it reads them, the same single-source-of-truth trick the bench uses for prices:

The decision order mirrors cost: a free check first, a scored guess second, a paid experiment last.

The money is the traffic split, not the cleverness.

Which is why the cheap share in progress.log is the one number this system makes you watch.

Effort is the second dial

Effort is routing one level down: the same skill, applied to how long the model thinks instead of which model runs.

Every tool buries the dial on a different default. High in Claude Code. Medium in Codex. Hidden in most apps. So people leave one setting on for everything, and either overpay or underthink.

Default to high and treat max as a last resort, not a flex.

The model matters at least as much as the dial. Fable 5 on lower effort often beats older models running at xhigh, so reach for the better model before the higher setting.

Two settings get mistaken for higher rungs of this ladder. Neither is on it.

Different axes. Ultra is not "more than max," and pointing it at a task that does not truly split buys four agents duplicating one investigation.

The ladder does not port across versions. The same word buys a different amount of thinking on a new model than it did on the old one.

Moving a familiar task to a new seat, start one rung below the setting you trust. Climb only if the output asks.

One trap belongs to swarms specifically.

Subagents inherit the parent's model and the parent's effort. A fleet spawned from a max-effort conductor is a max-effort fleet, and it drains a window in a single message.

Pin them down in their own frontmatter, and know which harness you are in when you do, because the pin is only as good as the spawner that reads it.

On the Codex side the only real controls are the setting you opened the session with, and a line in AGENTS.md that says do not spawn unless asked. Verify which one you have before trusting either:

Set it per tool: /effort in Claude Code and the Codex TUI, a flag like codex -e high, a line in config, or the effort field on the API.

Model routing decides who thinks. Effort routing decides how long, and the second dial is cheaper to turn because nothing else in the setup changes and the cache stays warm. Spend effort where the loop branches. Everywhere else it is a tax.

Track the one number weekly:

ROUTING.md, the policy both harnesses read

Everything above condenses into one file at the repo root.

CHECK 4: router.py runs offline and prints a decision, a reason, and the split. Your notes hold the 5x gap measurement, or a dated note saying the router is not yet justified.

BUILD 5: The Advisor Inversion

The classic pattern puts the smart model in charge and burns frontier tokens on bulk execution. Invert it.

Anthropic's advisor results: Haiku with an Opus-class advisor more than doubled its score on a hard browsing benchmark, 41.2 against 19.7 alone, at 85 percent lower cost per task than the mid tier.

Execution is bulk. Advice is grams.

The harness decides when the driver is stuck, never the driver, .claude/skills/stuck-protocol/SKILL.md:

The expert seat, .claude/agents/fable-expert.md:

And the same lane in reverse for Codex sessions, ~/.codex/prompts/fable-advice.md:

Small models are overconfident, so the harness watches behavior instead of asking.

The brief stays tiny, because the expert's value is clean context and a long brief poisons it.

Each consultation runs a few hundred tokens of guidance. That is why the economics collapse: execution millions ride the $1 tier, and judgment arrives by the gram at $50 per million.

Cognition published the failure first. The ceiling is set by the driver, not the advisor, and the pattern only paid off after their driver improved a generation.

The open problem is a driver noticing it is stuck. Which is why the signals above are behavioral, and why they live in the harness.

CHECK 5: advisor_loop.py passes its assertions: the driver fails twice the same way, one consult fires, the task completes, consults stay under the cap.

BUILD 6: The Two-Lane Bench

Nothing grades its own homework is a law, and this build enforces it across vendors.

Same weights in a foreign harness drop hard. One 2026 measurement showed 20.2 percent native versus 7.7 percent third-party.

So each reviewer runs in its own home. Claude reviews in Claude Code. Sol reviews through the Codex CLI.

The in-house judge, .claude/agents/fresh-eyes-reviewer.md:

The cross-vendor judge, .claude/agents/sol-reviewer.md, is plumbing that runs one command and relays the verdict verbatim. Sol is the reviewer; this file gets it into its own harness:

For CI, loop/two_lane.sh drives the whole exchange, three rounds max:

Inside Claude Code you can skip the script entirely.

OpenAI ships an official Codex plugin for Claude Code, live since March 2026 and at roughly twenty thousand GitHub stars within nine weeks. That is the market telling you cross-vendor review went mainstream. Install once:

Three moves inside any Claude session:

Use adversarial on anything load-bearing. Use handoff when the work is terminal-heavy, where Sol is strongest.

A growing number of builders now run GPT-5.6 Sol inside Claude Code, through the proxy from BUILD 7, and prefer it to Codex for daily work.

It demonstrates the thesis: rent the weights, own the harness.

The catch is the native-harness law, since Sol in Claude Code runs outside its home. Confirm it on your own eval set. If your evals say the foreign harness wins, your evals outrank the benchmark.

Three properties make the reviewer worth having:

A softened verdict is a broken verifier, so the relay is verbatim. A third FAIL pages a human instead of taking a fourth swing.

CHECK 6: run two_lane.sh, or /codex:review on your last commit. A VERDICT lands in a .review file, and a FAIL routes back to the writer lane.

BUILD 7: Optional Fan-Outs (install when the condition appears)

Scout swarm. Install when research or codebase archaeology eats more than 30 minutes of your day. Spawn three in parallel on separate slices:

Reads fan out because parallel readers compound. The word cap exists because every report lands in a context window the parent pays for.

Writes never fan out. A 2026 equal-budget study found single agents match multi-agent setups on reasoning when tokens are held constant. This lane is for reading only.

Overnight burner. Install when TASKS.md holds ten or more small verifiable items. The overnight-burner skill sets up the files, confirms both caps, verifies the test command runs, then launches ralph.sh. Morning interface: git log, progress.log, tick marks.

Plan split. Install when planning tokens dominate a session's bill. One setting in Claude Code runs an Opus-class model for the plan and Sonnet for execution. Plan on the frontier by the gram, execute in bulk.

Trio bench. Install when a gnarly change deserves three perspectives. Two roles read and one writes, and the fourth pane is a trap. The plumbing sits below.

The plumbing for mixed fleets

Two open-source pieces turn a two-vendor setup into an any-vendor one. Install them only when a condition calls for a third provider.

claude-model-switch (open source, Rust, runs on localhost:4000). A local proxy between Claude Code and any Anthropic- or OpenAI-compatible endpoint.

The trio preset is BUILD 7's bench made physical: three tmux panes, each role on a different provider, each addressable (orchestrate send coder "implement milestone 1"), with mid-session role reassignment if a provider degrades.

CLIProxyAPI (open source). The same trick, pointed the other direction.

It wraps the OAuth logins of ChatGPT Codex, Claude Code, Gemini, and Grok as OpenAI-, Claude-, and Gemini-compatible API endpoints.

Translation: subscription seats you already pay for become routable API targets for scripts like ralph.sh and two_lane.sh, with no separate API keys. Community forks extend it to Factory and Amp, and wrappers like ccs add multi-account switching.

The law that governs both, from BUILD 6's data: a remapped model runs in a foreign harness.

Remap the reader and reviewer lanes freely. They are cheap and verifiable.

Keep the lane that writes code on a model native to its harness, until your own eval set proves otherwise.

CHECK 7: every installed fan-out has its trigger condition written next to it. Installing any of this speculatively is how stacks bloat.

BUILD 8: The Factory (completion becomes a database fact)

Everything so far proves work in the moment. The gate, the verdict, and the eval set all fire during the run.

Once more than one agent touches a project across more than one session, you need proof that survives the run: who worked what, in what order, and whether the last review cycle cleared.

The pattern comes from the pi-factory demo (github.com/xpriment626/pi-factory). The load-bearing idea is one sentence

A thread is a trace. A row is evidence. The gate reads rows.

progress.log is a diary. The blackboard is a ledger. SQLite is the ledger because it is queryable after everyone stops talking.

Create factory/factory_gate.py. It holds four tables (tickets, briefs, evidence, verdicts), a record command each agent calls as it works, and the completion gate. The gate's failure conditions map to the work itself:

That list encodes the whole doctrine.

Create factory/factory.sh, which wires the seats you already built into the run order and records rows between every step:

Nothing new gets hired.

Fable cuts tickets and writes the brief, read-only. The BUILD 3 loop implements. Claude and Sol each return a verdict from their own harness. The cycle repeats up to three times until both go green.

The factory is the org chart for employees you already have.

A real run, not a mockup. The second gate call is the entire argument for this build:

Both reviewers said green. The architect confirmed the layout matched the brief. The reviewer confirmed the scope was clean.

And the gate still refused, with one line: no passing test command evidence. Nobody had run the tests.

A verdict is an opinion. Two opinions are still not a fact. One evidence test pass row later, the same gate returns COMPLETE and exits 0.

Models argue for their work convincingly, and a transcript captures the argument rather than the truth. Rows cannot be argued with.

When the gate refuses, it names the exact missing artifact. That turns "the run failed" into "produce a passing test row." A task, not a mystery.

Install condition: more than one writer session per day, review cycles that span days, or a need to prove after the fact what happened. For a solo repo with one nightly loop, BUILD 3 is enough and this is bloat.

CHECK 8: reproduce the screenshot. Record everything except a test row, and the gate must refuse with exactly one reason. Add the row and it returns COMPLETE. A gate that passes without it is a transcript reader.

BUILD 9: The Swarm (Fable plans, the fleet executes, Fable scores)

One driver with an advisor covers a task. A goal that splits into four independent pieces wants four workers.

But a fleet only holds its direction if one model plans every goal and scores every result. That is the whole reason this build exists, and the reason swarms usually fail without it.

Rung 3 made literal. Fable writes the goals, the fleet executes them, Fable scores each result against its own check, and the next cycle re-plans only the misses.

Its abort is the cycle cap. When the cap trips with misses outstanding, that is a spec problem going to a human, not a reason to run a fourth cycle.

Create swarm/swarm.sh. Three settings carry the doctrine:

Those three lines are explicit because the default is not.

A fleet that inherits picks up the conductor's model and the conductor's effort both. A Fable-at-high conductor spawning four Fable-at-high workers to do mechanical work is the most expensive possible way to do the cheapest possible thing.

Set them. Never let them default.

Cross-harness fan-out is legal, and it is not the exception to ROUTING.md's first law that it looks like.

The harness travels with the worker, not with the conductor.

The conductor writes goals, never code, and each goal carries its own check command, so done stays a fact:

Then dispatch, score, and replan:

Seat by seat:

Reserve Fable for the two jobs no cheap model can do: writing the goals, and grading them.

A fleet is a cost strategy, never an intelligence strategy.

Multi-agent runs burn 3 to 10 times the tokens for equivalent work, and a 2026 equal-budget study found single agents match them on reasoning when tokens are held constant.

A swarm earns its keep only when the goals are independent and mostly mechanical. Writes stay single-threaded per worktree, merges happen serially, and a human takes the last commit.

CHECK 9: run the swarm on a goal that splits three ways. A broken goal must come back FAIL in results.tsv and get replanned in cycle 2, never declared done.

BUILD 10: Rung 4 (nothing that passed once goes unwatched)

Everything so far verifies work while it is being made. Nothing so far notices when finished work stops being true six weeks later. A goal you verify once is an assumption with a timestamp.

Rung 4 has two halves, and its abort matters as much as its exit: if no proposal clears the gate this week, the system does not change, and that is a success.

Half one, standing goals. Every finished thing graduates into an invariant with a predicate, re-verified daily, forever. Create one file per finished thing in goals/:

Then system/verify_goals.py runs the lot and exits 1 if any invariant broke, naming the goal, the date it last held, and the policy you set:

Predicate rules are strict on purpose: a shell command, exit 0 means the invariant holds, cheap and read-only.

Adjectives are banned. If a shell cannot check it, a model cannot either.

Non-code goals work the same way. test -s reports/$(date +%Y-%m)-review.md is a fine standing goal for a monthly report.

Half two, compost. Once a week, read the exhaust the system already produced: BLOCKED tasks, failed gate runs, refused factory gates, reverted PRs, violated goals.

Then propose at most three changes. A new law for the constitution. A fix to a skill that keeps failing the same way. Or a standing goal you were missing.

Propose only. You sign.

This rung closes only when the evals and the judges say the system got better. Which means the system needs a memory of its own failures to improve against.

The compost run is what turns a script into an institution.

The standing goals are what make finishing safe. The sentinel detects, the normal pipeline fixes, and nothing rots in silence.

CHECK 10: verify_goals.py demo names the broken invariant with its last-pass date and leaves the healthy one alone. Then write one real standing goal for the last thing you finished.

BUILD 11: Rung 5 (your seat, and why it never empties)

Rung 5 has your name on it for a mechanical reason, not a sentimental one.

A loop can hit its stopping condition and still be wrong. Tests pass, the gate goes green, both reviewers sign, and the last commit is still a mistake.

Every build below this one exists to shrink that risk. None of them erases it.

Your standing duties, all cheap:

Three plays run on a cadence rather than on demand, because they cost real money and pay in direction rather than diffs:

Play one, the project feedback loop, monthly.

Point Fable at what you already shipped, read-only, and have it write a detailed improvement plan. Then hand execution of that plan to Opus 4.8 or Sol.

The expensive model does the part that compounds, judgment about what to change, and never the part that does not, typing.

Play two, the behavior analysis, monthly.

Feed it your own session and project history across both harnesses, and ask it to map how you build and where you stall.

This is the only report in the system whose subject is you. It is usually the one that changes the most.

Play three, the second-brain audit, quarterly. Point it at your notes, docs, and backlog, and ask what your own thinking says is worth building next and what is worth deleting. Treat the output as a proposal, exactly like compost.

The rungs below optimize execution, and execution is the cheap part now. Direction is the scarce input, and direction is what a frontier model is worth paying for. Buy judgment by the gram, execution by the ton, and keep the last signature.

CHECK 11: run play one on your own repo. If the plan names nothing you already knew was fragile, your context files are too thin, which is a BUILD 1 problem.

BUILD 12: Ops

Agents burn 10 to 100 times the tokens of a chat call, and input dominates at roughly 100 to 1.

Stack the four levers from BUILD 0 (split, cache, batch, compaction) and teams report landing 70 to 90 percent below their unoptimized baseline.

For sanity: $13 per developer per active day is the Claude Code enterprise average, and 90 percent of users stay under $30.

One line of discipline instead of a new subsystem: a task class may auto-merge only after 20 logged runs at a 95 percent pass rate, and a single drop below 90 percent revokes it loudly.

Weekly spend, from the per-tick costs ralph.sh already logs:

Compute the metabolism before you cron. Daily cost is ticks times average tick cost.

The seat that handles the quiet no-work tick decides the bill. Cents on the cheap tier, dollars on a frontier model at high effort, for the identical "nothing to do" answer.

Running inside your limits

These models burn tokens fast, and how you run them decides how much of a day's work lands before you hit a wall.

First, know which wall.

Watch the meter you are actually on: the usage panel in Codex settings, /usage on the Claude side, or a monitor like ccusage or codexbar parked in the corner of the screen.

A limit you never read is a limit you discover by hitting it, with four hours left on the clock and nothing to run.

Six levers, cheapest first. Most act at rungs 0 through 2, where the tokens burn:

Together these levers set how long you can run the best models before the limit stops you.

Cron, when Week 2 starts:

The runbook. Each alarm, and what to do about it:

The 30-day schedule. Do not skip graduations; each unlocks the next.

The Command Deck

Every loop here is reachable from a keystroke. Slash commands live in ~/.codex/prompts/ on the Codex side, where the filename becomes the command, and in .claude/skills/ on the Claude side. The CLI clips are the headless versions that cron and CI run.

Codex slash commands

/plan-stop and /effort pay for themselves fastest. Both spend a few hundred tokens to stop you spending a few hundred thousand.

These models run long, so the checkpoint you want comes before the spend. /plan-stop returns the plan, the done-when commands, the blast radius, the cost, and the one question it would ask a human. Then it stops.

Drop both files in ~/.codex/prompts/, where the filename becomes the command.

effort.md becomes /effort, the routing dial made explicit:

A live answer looks like this, and it costs a few hundred tokens to avoid a few hundred thousand:

plan-stop.md becomes /plan-stop, the checkpoint before the spend:

fable-advice.md and review-hostile.md become /fable-advice and /review-hostile. Both are the Codex-side mirrors of files you already wrote: the advisor brief from BUILD 5, and the hostile-reviewer contract from BUILD 6. Same rules, same caps, pointed the other way across the vendor line.

compost.md becomes /compost, rung 4's weekly institution-builder:

CLI clips

Keep these in a scratch file. They are the entire system reachable from a terminal:

The full policy lives in ROUTING.md from BUILD 4, which both harnesses read.

The Rules (print this)

Closing

Thirty days from now, if you did the checks:

The models were never the hard part. A system that stays honest when you stop watching is the hard part, and it is why rung 5 still has your name on it.

Start tonight with the twenty minutes that proves it. BUILD 2's verify.sh. One hand-run tick of BUILD 3. One review from the other lineage on your last commit.

The first time a reviewer that shares no context with the writer finds a real bug in work you were sure was done, you will not need convincing about the rest.

Build the gate tonight. Reply with what it caught on the first run.

Disclaimer