What is a
Ratchet
Loop?

In plain terms

Three loops. What differs between them is how many attempts a round and what you ship — not one piled on the next, because the dearer loop is not the cheaper one with more bolted on. Pick how you would rather read it — the two views say the same thing.

Skip to the full method

The full method

Everything below is the detail behind the summary above — the exact rules, the numbers, and the reasoning. You do not need it to use the tool.

Honest prior art

The composition is ours. Almost none of the parts are. Goal and inspectable bar, the builder/harsh-critic split and blind A/B come from Matt Shumer’s Gauntlet Loop. Named / Fetchable / Comparable is robonuggets. Champion/challenger promotion — ship the best checkpoint, not the last — is standard evaluation practice. Judging the work before you see it, swapping the presentation order, and spreading a panel across model families all come from the judge-bias literature.

Four attributions were settled against his three published texts. His: the rule that coupled things stay under one owner, which comes from his repo’s process note and carries his own numbers — six parallel agents over three rounds moved the score +0.46 while the worst defects ended higher than they started, 60 → 47 → 66, against +1.00 and 66 → 26 for one sequential pass with a single owner. Ours: “a pick, never a score”, which no text of his says and his own run did not follow — he picked and scored, 3.59 → 4.14 → 4.05 → 5.05 out of ten; the ban on inventing helper scaffolding, which is the community’s and ours; the progress page’s specification, where his text says not to over-specify it; and delivering the best artifact rather than the last, which his method does not address at all. And the smoothing pass between waves is optional in his article, so the Gauntlet tier calls it optional too; this method runs it every wave, and that choice is ours, not his.

The generator’s Gauntlet tier is a documented adaptation. Its setup, safety guidance and optional supplied-check feedback are additions, even when they do not gate a round. A research comparison against Shumer’s original must pin the original source and disclose the minimum harness adaptation rather than calling the generator output byte-identical to it.

Roles

Orchestrator

Owns the goal, the criterion list and the ledger. Decides how the work is cut into pieces. Spawns everything. Never builds. Never judges. May never modify the criterion list.

Builder

One piece, clean context, a real artifact, in its own worktree. May never declare PASS or touch gauntlet/. Three per round, each taking a different direction at the same gap, none seeing the others.

Critic

Fresh context every round, so it never defends its own last verdict. Harsh, and it inspects the rendered artifact rather than the builder’s summary. Names the single biggest remaining gap, a per-criterion verdict with citations, and the states it entered.

Preparer

Builds both candidates from clean checkouts at identical settings. Produces every capture, strips provenance, hands out shuffled unlabelled slates. Never judges.

Judge

Has built nothing and seen no checkout. Four per duel, two per presentation order and spread across at least two models, none of them the builder’s.

Five roles, and no agent both proposes and ratifies. An agent that built both sides knows which is which, so separating the hands that build from the eyes that judge is what makes “blind” true rather than nominal.

The bar

Straight from the Gauntlet Loop, and the load-bearing part. A bar must be Named (a specific thing, not a category), Fetchable (the critic can open, run, read or measure it), and Comparable (both can sit side by side and a judge can pick one). Name a measurable half alongside it — a number, a benchmark, a budget, a pass rate. Taste plus a number beats taste alone, and a bar you cannot obtain is one you will hallucinate.

The criterion list is given, not derived: one criterion per line, each with the measurement that decides it. Setup copies it verbatim and hashes it into the first log line. It is created once and immutable thereafter, and that is enforced rather than asked for: the boundary hook lets the list be written once and refuses every write to it from the moment it exists — every tool, every shell. Keep it short; 8–15 criteria is a working range.

A criterion the run believes is wrong is a note, not a stop and not a question. It writes what is wrong with it on the log and keeps running against the list as written. If your brief carries no list at all, writing one is round zero’s first task — waiting for a human who has been told to walk away is how a run delivers nothing.

The round

The champion on disk does not move until the challenger wins the duel. Round 0 runs no duel — there is nothing yet to beat. One piece per round: pieces never share a round, so a lost duel has exactly one owner, and they are assembled at the end by one smoothing pass and a final duel against the previous whole. Coherence comes before promote because promote is the step that appends the round’s line to the log, and a pass that runs after the append has no line left to write on.

Two orders make the promises true. Your check runs straight after the build, on every candidate worth judging, before any judge sees any of them, so “before any judge sees it” is literally the case. And the critique now runs last, on the champion: on the challenger if it was promoted, on the incumbent if it was not — so the next round’s work is always named against the version you would actually ship.

Which piece the next round belongs to is decided by the logs, not by the critic — the piece with the fewest rounds behind it, ties to whichever has gone longest without a promotion. Otherwise one part with a talkative critic takes every round and the rest ship at whatever the first round gave them, which reads as progress in the log.

Where the work is cut into pieces

If it is unclear, one piece. The two mistakes do not cost the same. A piece that could have been three is slower, and the log shows you exactly that. Three that should have been one produces the regressions this method admits nothing here catches: every piece green on its own criteria, and what broke is the interaction no piece owns — learned from a duel, late, or never. Prefer the mistake that is visible.

The cut is written on the first log line and carried forward unchanged, because a session that resumes this run did not make the call and cannot re-derive it.

Coverage — the states nobody entered

The one mechanism here with a cited catch to its name, and it targets the class neither a critic nor a duel reaches. Two misses are what it exists to catch, and both were measured on runs that had no coverage — neither was a judgement failure:

• A control left focused after a click, so a later Space re-fired it and discarded a live game. Present at round 0, unnamed by six fresh critics, still there when the run ended.
• Enter not scoped to focus, so Enter on a Close button ran the selected command. Shipped by two loops built independently against one bar.

And where a run had it, it paid, twice. A live defect sat in a state no round had entered until coverage sent a critic there; and a run that had already declared itself finished voided its own stop when the map turned up a state nobody had tried. Those are the catches. The two misses above are the motive, and quoting one of them as a catch would be selling a mechanism on the failure that argued for it.

A critic told to find the biggest gap looks where it expects one, and six critics expect the same place. So round 0 writes a state map: for each criterion, the states it speaks about, crossed against three axes — entry path (keyboard, pointer, programmatic, restored), data state (empty, typical, at the limit, over it, invalid) and sequence (fresh, after an action, after a reset, after an error). Crossed, because both misses above were crossings. The map is append-only, not frozen — the standard is fixed but the territory grows, and a deleted state is one that stops being uncovered.

Every critic and every judge reports the states it entered, with evidence it got there. Each round the three least-visited states go into the critic’s instructions, by name, and it has to enter them and say what it found. It costs no extra agents.

Coverage is not quality and is never scored. It says somebody looked, not that the artifact is good there. The moment it becomes a number to maximise, a builder will enter states cheaply to raise it.

Three challengers per round, not one

Each round spawns three builders on the same gap, in three separate worktrees, each told to take a different direction and to say in one line which direction it took. None sees the others. Sampling once per round is a search with a population of one: the best artifact reachable is whatever the first attempt happened to be. Not thirty, because the filter here is a blind panel rather than a machine, and every extra sample costs judges.

Every builder is handed four things, written out in full: the gap as the critic named it, the criteria that bear on it copied word for word, the measurement that is failing, and the bar itself — your reference files, by absolute path. The builder is the only agent in the method that changes the artifact, and the references are kept out of its checkout so it cannot grade itself against them — so it is handed them by path, or it would never see what good looks like.

And a builder does not return on a commit. It returns when it has run the thing it built, driven it into the state the gap names, captured that state, and put the capture beside your reference — and if they do not match it goes again, up to three times, before it hands anything back. It reports the commit, the direction in one line, and the path of its last capture. A builder that never ran what it built has produced a diff, not a challenger, and in a real run three of them came back in about fifteen minutes each with one file apiece, after which every gate in the round spent its money choosing between things nobody had run.

Each candidate is ruled material or no-op first, from its diff against the champion, and a no-op is not a challenger. Without that the round can never fail: a near-no-op inherits the champion’s behaviour, ties every criterion, and the cheapest promotion in the method becomes a change that improves nothing measurable. If all three are no-ops, the same assignment is re-issued and the log says so.

If more than one is material, they go to a champion-free selection duel — the run-off — first: two judges, one per presentation order, no screening pack, ruled against the frozen criterion list and nothing else, and the winner alone reaches the champion duel. A selection win is not a promotion. And selection judges may not be the duel’s judges: a judge that ruled here has seen the challenger and can name it on sight in an unlabelled slate.

Its slates follow the champion duel’s rule too: every candidate is driven into the state the gap names and captured there, the same interaction on each. Two attempts at one gap differ in exactly one place, and a slate that does not show that place is two identical-looking pictures and a coin toss. Round 0 runs the same selection duel as every other round. A selection panel is never “seated”, because there is no pack to seat it on: the log records how many judges it asked and how many answered, and fewer than two answers means the run-off did not happen — the lowest-numbered candidate goes forward and the line says it went by default.

The critic is harsh, and it inspects the artifact

Both halves, in the spawn text and in the contract, in every tier:

“You are a really harsh critic. INSPECT THE ACTUAL RENDERED ARTIFACT — run it, open it, measure it — NEVER THE BUILDER’S SUMMARY OF IT. What was asked for is: …”

What follows is your own goal, verbatim, so the standard the critic is harsh about is yours rather than a generic one. These are the Gauntlet Loop’s own words, and they are the cheapest mechanism in the method.

And it goes all the way through before it names anything. It plays the whole game, reads the whole document, uses the whole tool — whatever the thing is, it experiences all of it in one sitting the way you would, and reaches the end. A critic that judged the first screen has judged the first screen. It says in one line how far it got and what it did to get there, and if it could not reach the end, that is the gap.

Your artifact and the bar have to be the same kind of thing, or the blinding is decoration. Whatever form your reference is in — screenshots, a served page, a document — ours is rendered into that same form, at the same size, in the same state, before the critic sees either. A running app beside a folder of stills is labelled by its format, and a critic that can tell which is which is not blind however carefully the names were stripped. Where the two cannot be matched, the critic still gets both and the log records that the pick was not blind, because a pick you know was not blind is worth less than one you thought was.

And that pick steers, or it is decoration too. If the last three rounds all picked the reference over ours, the loop has lost three times running on three different gaps — that is a distance problem, not a gap-finding problem. So the next round is assigned the criterion the critic cited against us most often across those three rounds, whatever else it named. It is the one judgement in the method that comes from outside the run, so it has a route into what the run does next.

Gate 1 — the check you wrote, and that is all it is

The checks you supplied run against every candidate worth judging, each from its own clean checkout, immediately after the build and before any judge sees any of them. A binding one failing takes that candidate out of the round; if it takes all of them, the gap is set aside. They are machine-checkable and they are yours, so they are not a matter of taste and they do not go to a duel. If your brief carried none, Gate 1 is empty and that is the deal the run took — it says so in the log rather than inventing a suite.

Round zero is the exception: the starter version must first describe its runnable interface in run.json before the sealed checks can use it. Record that baseline honestly; it is not a duel-proven improvement.

Running your check first is what keeps a failing candidate away from every judge. It costs up to two more clean checkouts on a three-candidate round and nothing else: a checkout is not an agent call, and the agents are the whole bill.

This loop writes no checks of its own. Your sealed check is the only suite, and the duel decides every promotion. The cost section has the measurements behind that.

Gate 2 — the duel

The Preparer builds both candidates from clean checkouts at identical settings, takes every capture, strips provenance and hands out shuffled unlabelled slates. A judge handed one side built and the other described is not comparing artifacts.

Normalise the evidence packaging, not the quality being judged. Match viewport, input, timing, and anonymous labels. Preserve the artifact’s layout, typography, interaction, and wording whenever a criterion evaluates them. Equalising those would remove the very improvement the judges need to see. Style bias moves judges more than position bias does, so this is the higher-leverage debias and it is free. Then record what the normaliser left, because an unmeasured normaliser is a style confound you paid for and did not collect.

One rubric, frozen, shared by all four judges — not one each, because a 3-of-4 vote taken against four rubrics is four different questions counted as one. It adds no criteria, removes none, softens none, and says only where to look. It is derived once, after round 0’s candidates exist, from the criterion list and those real candidates: a rubric written with no artifact in front of it comes out generic, and a generic rubric measurably makes judges worse than no rubric at all.

Judges commit first: before opening any candidate, each writes down what a winner must show, per criterion, because a judge shown a candidate first scores plausibility instead of correctness. Criterion order is randomised, and each criterion is ruled A / B / TIE with a citation — the exact output, measurement or capture that decides it. No citable evidence is not a pass. No scores out of anything, ever: a pick between two things stays honest as the artifact improves and a number does not. Pairwise judging being steadier than scoring is well supported.

Four calibrated judges, two per presentation order. A promotion needs at least three judges who prefer the challenger or call it a tie, with a strict preference for the challenger in both presentation orders. One favourable vote and three ties are insufficient. Three of four for the champion discards; anything else is a tie, and a tie promotes nothing. The builder receives the lost criteria and their cited evidence.

Four ties is not a win. Neither is a single strict vote surrounded by ties. The kit’s adjudicate.mjs validates the panel record and computes the verdict without a model doing the arithmetic. Invalid records cannot promote. It checks the evidence structure, not whether a cited capture actually proves the claim; that still requires independent inspection.

Accepted does not mean infallible. Judges can miss regressions or disagree about a trade-off. Binding checks remain separate from preference votes, and a frozen champion is the strongest version this run accepted, not proof that every property only improved.

Spread the panel across models, not only across orders — across vendors, and where the harness offers three or more, neither judge vendor is the builder’s; elsewhere the builder’s own model is excluded and the shared vendor is recorded — a related judge prefers its relative through style fingerprints that blinding does not remove. Honestly, that is a small correction: judges built alike make the same mistakes, so a panel from one family is worth fewer independent votes than its headcount, and mixing families buys error tolerance rather than independence. It is nearly free, so take it. Where a harness offers one model, the run records that and a unanimous verdict counts for less.

Four rather than two, because the arithmetic decides it: with two judges a genuinely better challenger is blocked whenever either errs — at an assumed per-judge error rate of 0.2, which nobody has measured, that is about a third of real improvements. And record the margin per judge — criteria won and lost. Not a score on the artifact: without it, a comfortable 4–0 and a 4–0 where every judge was one criterion from flipping are the same log line.

On a split, escalate once only when a valid tied panel contains both challenger and incumbent preferences. All ties, invalid evidence, and one-order-only support without dissent do not trigger another panel. Use different eligible judges, freshly calibrated, and its verdict stands; a second split remains a tie. Log both panels. Never escalate a loss: repeated chances to get a preferred answer bias the result.

Calibration — stability and sensitivity, in a separate call

Before the live comparison, the same judge rates a separate pack of task-matched controls that contains neither live candidate. A resumed judge remembers its calibration: using the champion there can reveal its identity in the live duel even if labels are shuffled. The control is a candidate round 0 discarded, a sibling of the first champion pinned by commit, or the bar where round 0 left none; the pack is built once per rubric version, with one alternate for a respawned judge. Ten items, of which only nine count. The answer key remains hidden from the judge.

• TWIN — a byte-identical copy of the independent control, which must be rated equal. This one is plumbing, not a judge test: every capable judge passes it, so what it catches is a slate built wrong or an order flag not honoured. It is not counted.
• DEGRADE ×3 — the independent control with one injected defect, a different criterion each time, each sized like a typical round’s change. Each must be rated below. A large obvious defect tests nothing.
• Five validated equivalents — the control changed in ways the criteria do not judge, such as reformatting, length or rewording, and only where those are not evaluated qualities. Same substance, so all rated equal.
• REPEAT — one earlier item served again; must get the same verdict it got the first time. The only item that tests the judge against itself.

A judge is seated on 8 of those 9, a screening threshold rather than a measured accuracy guarantee. The controls share an artifact, criteria, and model, so they are not independent trials from which to infer a reliable accuracy bound. Transform only properties that the criteria treat as irrelevant: reformatting a design or paraphrasing a copywriting task may change quality and is not automatically an equal control. Fail the pack and the verdict is void; respawns are capped at two per duel with freshly drawn valid controls.

If fewer than nine of the last ten duels seated a full panel, the criteria are not judgeable as written — and as written is the rubric, which is an instrument and the loop’s own. It rewrites the rubric once, sharpening what the failed packs died on, and carries on. That is a repair, not an ending: a panel that still cannot be seated sets the gap aside like any other difficulty.

Promotion

Two-phase, and the order is the point. Write a PENDING marker, perform every write, freeze the challenger as the new champion with its commit and a fresh checksum, append the log line, and only then delete the marker. Delete-then-append leaves a window where the marker is gone and the files disagree with the last log line — exactly the state this rule exists to stop being read as tampering.

A champion folder no log line names is an orphan, not a fault. A promotion that died between the freeze and the log line leaves one behind; nothing under the run’s folder can be deleted, so it is recorded and never read as the champion. The log names the champion, and only the log. The run also says in its report when it thinks one of your checks is wrong.

Waiting on children — never without a deadline

Three of seven real runs died for lack of this rule, and the two that survived had invented it on their own. The orchestrator had spawned its judges or critics, waited on all of them at once, and one never came back — so the run sat for most of a day burning tokens at the healthy rate, looking alive, doing nothing. Which method the run was using had nothing to do with it.

Every child gets a deadline when it is spawned — three times the median of that phase over the last three rounds, read off the log, and ninety minutes until there are three. The run collects one child per call, each wait bounded by ten minutes or the deadline, in a loop, writing a log line after every return; never a list, and never a turn ended while a child is open. A child past its deadline is dead, not late: token burn and a live process are not evidence, because the runs that died had both. It is stopped, respawned once with a fresh context, and if that dies too the role’s fallback takes over — a dead builder means the round runs on the survivors, a dead critic means the coverage map picks the assignment, a dead preparer means no duel this round, a dead judge means the quorum below. A third dead child ends the round — two are survivable, and a dead judge plus its dead respawn is exactly the quorum case — past that the gap is parked and the next round takes the next gap, because a round that keeps spawning into a call that keeps killing children is the hang wearing a loop.

Quorum. With exactly three judges seated and both presentation orders still present, a win needs no seated judge preferring the champion and a strict challenger preference in both orders — a no-dissent rule on a smaller panel has fewer vetoes and is easier to win, and the order condition pays that back. Fewer than three, or an empty order, is a panel that did not seat: no promotion, next round.

The coherence pass — the seams no piece owns

Nothing in a piece’s round can see the join between two pieces that each did the right thing. So at the end of every scheduling sweep — when every piece has had a round, whether it won or lost — a fresh critic experiences the assembled champions end to end, never a diff and never a summary, and names the single biggest seam. That seam is the owning piece’s next assignment. It moves no champion and runs no duel: it steers. Shumer’s article calls this pass optional; this method runs it as a critic, one agent call per wave, and says that the choice is ours. With one piece there is no separate pass, because there are no seams between pieces and the ordinary critic already goes through the whole thing end to end.

The sealed suite — the checks the loop did not write

The only part of this method that is not the loop grading its own proxy. The run runs them every round, edits them never and reads them never. Half of that is enforced and half is trust, and the run is told which: the hook denies writes to the check bodies from every caller, but running a check means reading it, so not reading them is a rule the run keeps rather than a control that holds it. If it reads one anyway, it says so in the log and in its final report. That disclosure is the whole of the control on this half.

Every kit also ships a handful of floors nobody has to choose — no logged errors, the same behaviour twice, keyboard reachable, no third-party calls, and never slower or heavier than round 0 made it. Anything that cannot apply to your artifact is declared in writing, for you to disagree with.

Two prerequisites with no fallback: a real browser, and an address the artifact is served at — file:// is refused. Without either, every check answers unrunnable, which is a suite gating on nothing and reporting success. Unrunnable is not a pass, and whose fault it is decides the round — measured, not judged: the same check is re-run against the champion. Unrunnable on the challenger alone is the artifact, and it fails the round. Unrunnable on both is your environment, and it fails nothing — it is a hole in the standard, reported every round until it is filled.

Which checks can fail a round is written in each check’s own criterion file, and the index that ships beside them agrees. Nothing else decides it, and the run may not assign it.

One scenario you wrote is worth more than every derived threshold together, because it is the only part of the method that samples your judgement rather than the loop’s reading of your prose. A real run held a physics invariant to four decimal places — 7.3431 s against a sealed 7.34 s ± 2% — every round. And what “sealed” means is narrow: untracked, hook-denied, absent from a builder’s checkout. Nothing here is cryptographic. The value is that the standard was fixed before the run started, by something other than the run.

Making it real, not just instructed

“Builders may not read gauntlet/” is an instruction, and instructions are not controls. Without enforcement every anti-gaming claim above is decoration. Four things carry the weight:

• Builders never get the directory. Spawn each into an isolated worktree without gauntlet/. A path that is not there cannot be read, and it needs no hook.
• A hook as backstop, denying writes under the champion and the check bodies — scoped, or it locks the loop out of its own log and round 0 never finishes.
• Prove both before round 0. Spawn a throwaway builder, have it try, record what came back — a hook that matches nothing loads perfectly and denies nothing, so only a behavioural probe tells you it works. An unproven boundary is an assumption.
• Two-phase promotion, so an interrupted write does not read as sabotage.

This is crash consistency, not tamper-proofing. The checksum lives inside the tree it hashes, so an agent with write access could rewrite both consistently and nothing here would notice. Real tamper-evidence needs a hash chain kept outside the run’s writable tree. If you need that, build it — do not assume this gives it to you.

It runs on two harnesses today: Claude Code, with a supported level selected through /effort in a clean session and Ultracode off, and Grok Build, started with /goal <objective> --budget N once goal mode is on (goal.enabled). On Grok Build, project hooks and AGENTS.md are silently skipped until the folder is trusted — so trust it with /hooks-trust (or start with --trust), then confirm with grok inspect rather than assuming. A /goal completes only once an independent review reproduces the claim; where it cannot, the goal pauses and names the gaps, and /goal resume continues it.

Installation details change across releases. The builder role requests a worktree, but setup must inspect the actual tool schema and verify where the child ran; a copied argument is not proof of isolation. For clean archives, create the destination directory before extraction and verify it contains the committed artifact. Keep observed behavior scoped to the installation that produced it, rather than turning one old failure into a universal CLI rule.

The rest of the harness detail — which flags, which hook file, what each CLI silently skips, how spawning and isolation really behave — is in RATCHET-LOOP.md, which the generator ships unmodified in the run kit beside the hook and the exact prompt for your brief. That is the operating manual; this page is the explanation.

Grok Build and Claude Code

A new model does not require a new method name. It does require a recorded change in the run conditions. Keep your running kit intact and start a separate lineage to compare another model or these updated rules.

What you ship

The champion, named by its round id and commit SHA. Not the working tree. Not the last thing built. And it is restored to the working tree as part of landing — if the last round lost, the tree holds the loser while the champion sits where nobody thinks to look, and that looks like success until someone diffs it.

You get the champion round and its commit, your sealed verdicts, coverage as entered and never entered, the duel record, the calibration pass rate, the children that died, and the log.

For several pieces, a collection of piece champions is not a verified whole. Identify the assembled commit and its integration evidence explicitly. Keep a prior verified whole available if assembly fails or the budget cannot pay for validation; otherwise disclose that only piece-level checkpoints were verified. Prefer one lineage for coupled work rather than promising integration the run never tested.

How it stops

There is one ending the run may declare, and it is your cap. Where you named a number of rounds or an amount of money, that number halts the run — and it stops before the round that would cross it rather than during one, because a round that runs out halfway leaves no verdict and nothing promoted. Where you set none, none was meant, and the run is told it may not invent one.

Everything else is keep going. A check that failed, a duel lost, a round where nothing material got built, a panel that could not be seated, a state nobody could enter, a critic with no gap to name — each is written down, set aside, and the run takes the next gap the critic named. A gap set aside is not a solved gap and the log says so.

And the attempts at a gap are counted on the log, not remembered. The count is 1 the round a gap is first assigned and one more on every later round that assigns the same gap, whatever the verdict; at three, the gap is set aside whether or not anyone called it blocked. Two rounds that could not move it are difficulty; a third is the run paying to guess at the same thing again. A count kept only in the session’s head is gone the next time it compacts, so the log keeps it.

And there is no word in the prompt for “I have finished”. That absence is deliberate, and it has more evidence behind it than any other rule here. Every early stop anyone has measured came out of a vocabulary earlier versions supplied: a run that declared itself converged over three rounds in which it built nothing and ran no duel; a run that stopped at a round number it had taken out of this document’s own cautionary example, while its author had left the cap blank; a run that reported it had “run out of time” when nothing in a run measures time; a run that stopped to ask permission for an action it had just proved correct. Supplying the word supplies the excuse.

A stop preserves the last accepted checkpoint, not the unfinished round. The champion is frozen by commit with a log line every round, so the deliverable is complete at every round boundary: a run killed in the middle of round eleven ships exactly what a run that decided it was done at eleven would ship. The run ends when your cap fires, or when the harness or the session kills it, and in all three the champion on disk is the answer — but a low context is not a kill: after a compaction the run reads its resume block and starts the next round. Every round boundary therefore writes three things and they are not optional: the log line, the champion round and commit on it, and the handover rewritten.

When nobody is there: set it aside, never ask

A run that asks a question has failed, however good its reasoning was. A run that pauses because a session ended has not. The one exception that ends a run is an integrity fault: the record disagrees with itself, so nothing written after it can be checked by anybody and there is nothing you could answer. It writes what changed, delivers the last champion whose checksum still matches, and stops.

Everything else is difficulty, and difficulty does not end a run. A judgement call about the artifact is yours; a judgement call about how to keep working is the run’s. Ending a thirty-round run at round eleven because one gap was blocked forfeits nineteen rounds a plain Gauntlet run would have spent improving something else. That, and not any gate, is how this method loses to the loop it improves on.

Ending a turn is ending the run

A turn ends when the agent stops calling tools, so a report written instead of the next action is a stopped run that reads like a working one — and three real runs ended that way with an assignment still open, no pause recorded, and a human who could not tell any of them from a crashed process. So every boundary has a defined next act: a build ends and the candidates are ruled material or no-op; a duel settles and the next duel or the decision it feeds follows; a round ends, the log line is appended, the handover is rewritten, and the next round starts.

And never a request that you approve a next action the run has already worked out. If it has named the action, it is the one that runs it. If what it is about to hand back ends in a question mark, it has not finished. And a turn that does end writes the log line first — disk before prose, always, because you tell paused deliberately from stopped talking by reading the last line, and a summary in a chat window is not a state.

Running low on memory is not an ending

Landing early because a session might end spends the whole remaining run to avoid a cost nobody measured. If a session truly cannot carry on, it pauses at a round boundary and never mid-round, with the handover written and true. A pause ends the session, not the run, and it is addressed to the next session rather than to you.

The handover is rewritten at every round boundary, not only when a run decides to pause, because sessions that end mostly do not get to choose. It carries the round to start, the champion and its commit, the standard in force, the open gap and every direction already tried on it and how each died, coverage and the gaps set aside, and what is still on disk to clean up. A resuming session reads that and the last log line and nothing else historical; where the two disagree the log wins.

And the clean-up line is rewritten the moment anything removable exists — each worktree, each checkout, each server with its port and process id, as they are made rather than when the round ends. A round that dies in the middle is the only case that line is for, and it is the one case a rewrite at the boundary cannot cover.

Measured, which is why it is worth the two minutes. Real sessions of this method ran 8h41m, 8h00m and 8h42m; the resumes after them ran 2h00m and 24m32s, each shorter than the last because a fresh session spends its first hour re-reading before it can work. Nothing written in a prompt makes a session bigger — what the handover does is make that re-read a page. Closing this properly is external automation’s job, not the prompt’s.

Cost

Multiples are against one plain Gauntlet round (1×, itself unmeasured), and they are estimated from what a round spawns, not measured: the Duel runs ~2.5–3×, the Ratchet ~3–3.5×.

Judges are the whole bill, and the lever is how many rounds you buy, not how many judges are in one. Do not drop the champion duel to two judges: two is this method’s own definition of a panel that did not seat, so the round has no verdict and the two judges bought nothing. Do not economise by skipping calibration either — an uncalibrated panel is not a cheaper gate, it is no gate. If cost is the binding constraint, run fewer rounds, or run the plain Gauntlet rather than running this badly.

Gate 1 costs a clean checkout per candidate, up to three a round. The multiples above leave it out, because a checkout is not an agent call and agent calls are the bill.

Set a hard budget before you start. Runs of this shape still reach hundreds of dollars. Reaching your cap delivers the current champion and stops. You are the brake. On Grok Build the ordinary run reads reported usage through its supported goal facilities. The Claude interactive kit uses a status-line command that writes session-identified estimated USD cost to gauntlet/cost.json. A new session resets its own counter, not the run’s spend. Missing readings stay unknown. Claude’s separate print-mode --max-budget-usd flag is not an interactive budget control. Estimates may differ from billed cost, and a round may exceed a boundary prediction; use provider-side limits too.

The measurements behind these prices

These are the measurements that took the self-written regression suite out of the method (the version history below has the before and after), kept here because the evidence that removes a mechanism is worth more than the mechanism was.

The head-to-head this method lost. Both loops, one brief, three rounds, the same ten-criterion bar, cost disregarded. This method took 5.7× the wall clock and 8.7× the agent calls, and a blind panel of four judges across two model families preferred the plain Gauntlet’s artifact or tied it — none preferred ours. Its regression suite caught nothing: six challengers, ten mutation-validated checks, zero regressions, both promotions decided by the duel.

The hardest number anyone has on this method, and it goes against it. Two lineages were re-measured afterwards by a harness neither loop wrote: this method’s three champions, and six rounds of a plain build/critique loop on a deliberately coupled artifact — movement, collision, an inventory, a carry limit, a derived score, save/load and a HUD, all depending on each other, built with no regression protection whatsoever. Eight round-to-round transitions. Zero regressions. Not one probe that passed at round N failed at round N+1. With the head-to-head’s six challenger checks that is fourteen checks and zero events. Only the eight transitions were independently re-measured; the six challenger checks are a different observation, not six more transitions. This small sample does not establish that regressions cannot happen on longer runs.

The same run is also why the method is worth having at all: each loop shipped a real defect the other caught. The duel found page text illegible behind the palette’s own scrim and drove it from 1.65:1 to 8.53:1; the plain Gauntlet shipped that defect at 3.25:1. The plain Gauntlet’s critic found focus stranding on a backdrop click; this method shipped that one. The duel and the critic see different things, which is why both are still here.

The counter-argument, which is not weak. Every one of those measurements was taken where this method already said it does not pay — one piece, three rounds, six-round lineages. The conditions the re-testing was designed for — thirty rounds, five parallel pieces, sessions that get replaced — have never been measured. A reasonable person can say it has not failed its test; it has not been given one. It is recorded rather than accepted for three reasons: it was carried for eleven revisions and grew to about half the prompt while waiting for its conditions; prompt size was then the direct input to the only stop that had killed runs (the later deaths were a wait on a list, and contexts have since grown, so 4.5 stops mandating a read of the specification); and a mechanism never exercised is not protection, it is an untested claim. The honest experiment is a long coupled run, not another rule.

Is it better than the Gauntlet? How you would find out

The honest scoreboard: the plain Gauntlet won the only controlled comparison this method has been given, at a length where the method itself says it does not pay. Since then seven multi-day runs produced a great deal about which runs live and die and nothing that compares finished artifacts — three methods, two models, one brief, and the arms never finished together. So nobody can yet say this loop builds a better thing than the Gauntlet. What can be said: once the waiting rule existed it did not die more often; its runs resume from disk where the Gauntlet’s cannot; and it found the class of defect six fresh critics could not. Two things it does not claim: it cannot tell you it is finished, on purpose, and it runs one piece-round at a time where the Gauntlet lets its lead agent choose concurrency — one branch point, one run.json, one cap on children make parallel pieces a race.

The comparison starts with the same brief, starting commit, bar, builder model, effort setting, and resource ceiling in both methods, tested separately on Grok Build and Claude Code. Equal round counts are not equal compute: Ratchet spends more inside a round. Fix the dollar or time budget before starting, keep every failed attempt and restart in the result, and repeat across more than one brief. A model change is a separate condition, not a method improvement.

Evaluate the delivered commits with a fresh external panel, unlabelled artifacts, both presentation orders, and the same observable criteria. Keep quality, cost, wall time, human decisions, and regressions as separate results. The run’s own promotion rate measures its decisions, not the quality of the final artifact.

The protocol and read-only measurement tool live in tools/experiment/ in the project repository. The tool reads both round ledgers and Relay session records, keeps missing readings unknown, and reports incomplete spend separately. No paid head-to-head was run for this release. The method is designed to improve the outcome; superiority remains a result to measure.

What this does not fix

Version history

What changed, newest first, and why. The specification in the run kit carries the full notes.

4.5

• A round cap no longer selects the Ratchet; only a brief naming more than about three separate parts does.
• Cost is stated once, as an estimate from what a round spawns: the Duel ~2.5–3× and the Ratchet ~3–3.5× a Gauntlet round.
• Judges come from vendors other than the builder’s where the harness offers three; otherwise the shared vendor is recorded as a limitation.
• Children are collected one per call in a bounded loop, each wait at most ten minutes, with a log line after every return.
• Calibration controls come from a candidate round 0 discarded, or the bar where round 0 left none — never from a live candidate.
• A round no longer has to re-read the whole specification; the prompt carries what a round needs.
• An unread spend is never a reason to stop or to ask: the run records it, flags it on the progress page and carries on under the round cap.
• Your check runs only once the candidate’s commit resolves in your repository, pointed at its own clean checkout; nothing edits run.json to redirect it.
• One list of endings, a self-written criterion list that survives a crash in round 0, judge ids that survive a resumed session, an account with exactly two models able to seat a panel, and a progress page that shows spend and trend.
• A running 4.4 Grok Build lineage takes the field patch before it continues on grok 1.0.50.

4.4

• A promotion needs strict support in both presentation orders, and a three-judge panel needs an explicitly authorized missing seat.
• Calibration moved off the live candidates onto independent examples, and the verdict arithmetic moved into the kit’s small, pure adjudicate.mjs.
• Your check is pointed at each candidate’s own clean checkout (SEAL_ROOT), so a green no longer risks grading the champion twice.

4.3

• The coherence pass moved before promote: in the old order it had no log line left to write on, which an independent read found before any run had reached a wave.
• The Duel gained the start-up rule and the handover block its own hand-off already told a resumed run to read, and every sealed body reads SEAL_URL.

4.2

• Four attributions in the prior art were corrected against Shumer’s published texts.
• Your sealed check moved ahead of every judge; it had run on the run-off’s winner, after two judges had already ranked all three candidates.
• The critique moved to the champion. It had run on whichever candidate reached the duel, and in one real run three rounds of five promoted nothing, so it named the next round’s work against versions that had just been thrown away.
• Builders are handed the bar by path. Until then the one agent that changes the artifact never saw what good looks like.
• A stale round-0 paragraph about a ten-item screening pack, forty-three lines from the rule that replaced it, was removed.
• The critic’s pick against the bar now steers the next round; it had been recorded every round and read by nothing.
• Attempts at a gap are counted on the log, replacing “a gap still blocked after two attempts”, which defined neither word and had nowhere to keep the count.
• The cost advice stopped offering a two-judge duel as a saving, in a method whose own quorum rule voids it.

4.0

• The blind-spot harvest went. Every promotion had recorded, as an open hole on every later log line, a judge’s measurement that broke a criterion’s threshold on an artifact your check called green. It caught one real defect; after 3.0 narrowed its trigger it never fired again, and 4.0 cut it on cost.

3.0

• The method lost the only controlled comparison it has been given, and was cut to about a fifth of its former size.
• It stopped writing its own regression suite. It had run 8–16× a Gauntlet round, because a promoting round re-proved every property the loop had ever passed and put each new check through a validation cycle of its own; the measurements under Cost priced that out.
• Its one genuinely new part, a loop that proved its own checks on deliberately broken code, was dropped: it never caught a defect in anything anyone built.
• “Harsh” and “inspect” went back into every tier’s critic, after an audit found harsh once in the cheapest prompt and not at all in the two expensive ones.
• The vocabulary for finishing was removed, leaving one ending a run may declare: your cap.

Corrections to this page

• An unsourced “about ten times” figure for style bias over position bias was removed; the direction is supported, the multiple was not.
• A claim that scores drift upward every round was removed; it had no measurement behind it.