Stop paying $50 models to do $1 work

How to read this: Sections 01–03 define the shape and the seats. Section 04 is the money. Section 05 picks the loop. Sections 06–07 are the two skills, escalation and conditions. Section 08 prices one real task five ways. Section 09 is ours. Section 10 is the failure catalog, and you want it read before you automate anything. Sources at the back. Argue with us in the group.

The original loop was dumb on purpose. Geoffrey Huntley's Ralph loop stuck a coding agent inside a plain while true and fed it the same prompt file every iteration. "Deterministically bad in an undeterministic world," in his words, and the dumbness was the feature: fresh context every pass, state living in the file system, persistence instead of cleverness. That loop earned its place in No.08. It still works.

But Ralph's dumbness was context dumbness, and it was cheap. The dumbness eating budgets in July 2026 is routing dumbness. The loop layer went mainstream (/goal, /loop, scheduled automations on all three major platforms) and almost everyone runs every turn of every loop on the same model they'd use for their hardest architecture decision. A loop multiplies turns. Frontier pricing multiplies each turn. Put those together and the loop takes the blame for a bill the routing ran up.

Loops don't burn tokens. Dumb routing does.

Here's the tell, and it's sitting in the pricing table everyone has already seen. Fable 5 lists at $50 per million output tokens. GPT-5.6 Luna lists at $6. Haiku 4.5 at $5. That's roughly a 10x spread inside a single frontier generation, and up to 47x against routed open-weight comparables. Meanwhile the actual work inside a loop's turns is mostly execution of a plan that already exists: migrate the call site, fix the test, apply the finding. The 731-task routing experiment from No.08 proved this at the task level, where a naive cheap-first policy beat Fable 5 alone on accuracy at 25% lower cost. Smart Loops runs the same play at the turn level. That's where the volume lives.

And to be clear about scope: none of this is really about loops. It's about frontier versus execution. The split shows up in one-shot work, in pipelines, in agent fleets. The loop just happens to be where it pays fastest, because loops are where the turns pile up.

The definition

One sentence for the group chat: Smart Loop = the plan-up, execute-down split, compressed into one command. Routing without loops is a spreadsheet. Routing with loops is a system.

Same 10-turn goal loop. Same work: 30K tokens in, 8K out per turn. Strictly speaking two things change: the seats move, and you get more machinery for the money, because the smart loop adds a deliberate plan pass and a per-turn check the dumb loop never had. It costs less and it checks its own work. That trade is the whole report.

Three honest footnotes. First, the dumb loop's real bill trends worse than $7.00, because every turn re-reads the growing transcript and input dominates loop bills (79% of tokens even in this flat example, pushing ~97% in ReAct-style benchmarks as transcripts grow). The dumb loop pays all of that at $10/M instead of $2/M. Second, $2.11 rides Sonnet 5's intro pricing. At standard rates from September 1 the same loop runs about $2.81, roughly 60% saved. Budget at that number. Third, $2.11 is the same-family figure, and routing the driver through Flux drops it again (Section 04). Don't get attached to the exact number. The point is where the savings came from: the seats moved, the work didn't, and the plan and the verification both got better in the process.

Four seats. The expensive seat is occupied twice, briefly. The cheap seats do the mileage.

Fig 2 // The Smart Loop architecture. Planner writes the finish line; driver grinds; evaluator gates every turn; the valve is the only path frontier tokens have back into a running loop.

Why the planner and the finish line are the same purchase

The most-skipped habit in the Dumbest Way report was the written Done condition. Smart Loops makes skipping it structurally impossible, because the planner session isn't done until it has produced both artifacts: the plan the driver follows and the condition the evaluator grades against. Deciding what provably-done looks like is the hardest thinking in the whole job. That's frontier work, and it's why the condition belongs in the frontier seat.

Why the evaluator is a different model, not a different prompt

A model grading its own homework shares its own blind spots. That was No.08's cross-audit argument, and vendor system cards document enough condition-gaming to prove it. So the evaluator gets a separate model with a narrow contract: transcript in, yes or no plus a reason out. It doesn't need to be smart. It just needs to not be the one that did the work.

Output pricing per 1M tokens, July 2026 list. The last row is the point of Flux Router.

*Sonnet 5 intro pricing through Aug 31, 2026, then $15. **Ferrox Labs routing data: comparable-class open-weight frontier models served via Flux Router. Your mileage depends on task class; verify on your workload.

The trick is not using the cheap model for everything. It's putting the frontier model in the two seats that deserve it, the plan and the unblock, and routing the rest down. And "the rest" is most of it. In Section 02's worked loop the driver turns carry roughly 90% of the tokens, the plan pass and the valve carry the rest. That's arithmetic, not aspiration.

Now let's scope the 47x honestly, because it's the first number a hostile reader will recompute. It's the output-price ratio: $50/M for Fable 5 against $1.06/M for a comparable-class open-weight model served via Flux. A full driver turn is input-heavy, so the realized per-turn saving lands under 47x and depends on your input mix and cache hits. And it lives in exactly one place, the driver seat. Chase it in the planner seat and you've bought a cheap plan with expensive rework. If you want the number to budget on, use the 70% same-family saving. 47x is the ceiling cross-family routing puts on the driver line.

Route by cost of error and verifiability

Not by task difficulty. Not by vibes.

Fig 4 // The routing tree, updated for the loop era. The verifiable branch feeds the Smart Loop. The unverifiable branch is where you still earn your keep.

The three rules, carried forward from the Dumbest Way report because nobody's beaten them yet:

• Default to the middle, escalate on failure. Terra or Sonnet 5 is the correct driver default. Plausible-but-wrong output is the escalation signal. A task merely looking hard is not.
• Route by cost of error, not difficulty of task. A hard task with cheap failures (regenerate the draft) goes cheap. An easy task with expensive failures (production migration step) goes expensive.
• Verifiability is the routing key. Anything downstream of a check, test, or retry loop can go cheap. Anything that IS the check goes expensive. The Smart Loop is this rule turned into machinery: the evaluator makes every driver turn "downstream of a check."

This split is already how the biggest operators run. Stripe put Fable 5 inside an agentic pipeline on a 50-million-line codebase migration: the frontier seat bought judgment where a missed detail costs real money, and the grind routed down around it. Nobody at that scale pays frontier rates for the typing.

Every loop answers two questions: what triggers the next turn, and who verifies. The second answer decides how cheap the driver can be. That makes the verifier the actual routing decision, not some implementation detail you sort out later.

Fig 5 // The taxonomy from No.08 and the Dumbest Way, now with the routing column filled in. One test picks the loop: pushing work to a finish line = /goal. Watching for a change = /loop.

Loops in the wild, July 2026

• Shopify: their Slack-native agent River now coauthors 1 in 8 merged PRs company-wide. 3,536 of them in a single 30-day window. (Shopify Engineering, May 28, 2026)
• Mozilla: a goal-conditioned harness shipped 423 Firefox security fixes in one month, including a bug that sat dormant for 15 years. Brian Grinstead's line: "Goals are the most powerful loop type… it stops when the work is actually done." (Lenny's Newsletter, June 22, 2026)
• OpenAI: runs its own scheduled automations for daily issue triage, CI-failure summaries and release briefs, per the Codex team's launch post. (openai.com, Feb 2026)
• Simon Willison published his standing instruction to Fable: "For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent." Frontier keeps design and auditing. Cheap models type. That's the four-seat split, arrived at independently. (simonwillison.net, July 3, 2026)
• The counterpoint: Fabio Akita benchmarked planner-plus-cheap-executor mixes against solo frontier runs and found most combinations slower and no cheaper at equal quality. Small n, one task, and it matches Section 04: the split pays when the routing is right, not just because there are two models. (akitaonrails.com, April 25, 2026)
• The bill side: Priceline's coding-agent renewal jumped 4–5x and it now caps tokens per group; one engineer reportedly burned $40K in a month; and a runaway agent with an unrestricted AWS key rang up $6,531.30 in under 24 hours doing a job a $5 VPS could handle. (TechCrunch, June 5, 2026; lantian.pub) Turn budgets and kill switches are not decoration.

Who sits in which seat

• Turn-based stays yours. You are the verifier, and your attention is the expensive currency. Spend it on exploration, taste calls, anything without a checkable Done. No routing trick fixes a loop whose verifier is you.
• Goal-based is the Smart Loop's native habitat: front-load the plan cost, then cheap turns until the condition provably holds. Migrations, backlog burn-down, format enforcement, test-passing pushes.
• Time-based wants the cheapest tick that can detect the change (Haiku or Luna) with escalation on hits. Pay only on findings. If your 30-minute check costs more than a few cents, the check is doing analysis it shouldn't be doing.
• Proactive (goal + schedule + workflow) is standing spend: meter it like infrastructure, with per-step routing, budgets, and a kill switch. Autonomy is earned by verification, not granted by enthusiasm.

The one place frontier tokens re-enter a running loop, and the part most people get backwards. The instinct when a driver fails twice is to hand the remaining turns to Fable. Congratulations, you just converted one stall into eight frontier turns. The valve buys exactly one frontier turn instead, extracts the judgment, and puts the cheap driver back to work.

Fig 7 // Stall detection to frontier diagnosis and back. Guidance flows into the loop; the loop does not flow into the frontier model.

$0.70 to unblock beats $7.00 to grind.

What the valve turn actually does: reads the transcript, names what the driver keeps missing, and writes unblocking guidance into the loop. A corrected assumption, a decomposed step, the one file the driver never opened. It does not do the work. The moment it starts doing the work you're back in the dumb loop with extra steps.

Two honest caveats. The real comparison isn't one valve turn against ten frontier turns, it's the valve against just carrying on cheap, and stall frequency decides that one. Which is why the trigger is a detector rather than a schedule. And "three same-reason NOs" is a field heuristic. Tune the N, and how you normalize "same reason," against your own logs.

Behind the valve sits the circuit breaker: the turn budget in your condition ("stop after N turns") is what saves you when even the valve can't help. Some conditions are unsatisfiable. The test flakes, the dependency is broken, the plan was wrong. A loop persisting heroically against one of those isn't a worker anymore, it's a bill. No.08's retry-bonfire data showed the same pathology one level down: every one of the twelve most expensive runs in a 1,127-run dataset shared the retry-loop pattern. Cap it and surface it.

Valve discipline: one turn per stall, guidance only. And if the same stall triggers the valve twice, stop the loop. That's a planning failure, and planning failures go back to the planner seat.

Loop engineering is mostly finish-line engineering. The condition is the contract between the three cheap seats and the one expensive decision, and writing it well is the highest-leverage skill in this manual. Four parts. The first three come straight from the official /goal docs, the fourth from the field.

# The example, all four parts:
/goal every call site of oldApi in src/ is migrated per docs/plan.md;
npm test exits 0 and npx tsc --noEmit is clean;
no file outside src/ and test/ is modified;
stop after 12 turns

Fig 8 // End state, stated check, constraints, turn budget. The example carries all four.

• "Clean code" is not a condition. No command's output flips from no to yes on "clean." If you catch yourself writing a prompt after /goal, stop and extract the checkable core.
• The evaluator only sees the transcript. If the proof requires running something, the condition should name the command, so the driver knows to run it and surface the result. "npm test exits 0" works because the test output lands in the transcript. "The code is clean" fails because nothing in the transcript can prove it.
• Constraints stop condition-gaming. Models satisfy the letter while missing the intent. Vendor system cards say so in writing. "No other test file is modified" and "no finding is deleted or downgraded" exist because the executor editing the findings file is a documented move. What must NOT change is as load-bearing as the target itself.
• The turn budget is part 4 because someone has to be the adult. It caps stuck loops, unsatisfiable conditions, and valve failures all at once. It's the cheapest insurance in the whole architecture.

Quality lives in the plan artifact. Proof lives in the condition. A condition can verify behavior but it can't verify taste, so put the taste constraints in the plan the driver follows and keep one human pass at the end for the 10% taste actually covers.

The worked example from the Dumbest Way report, re-run as a loop decision. Mid-size refactor: 200K-in/30K-out plan pass, then 8 subtasks of 60K-in/15K-out. Vendor list prices.

Fig 9 // All-Fable $14.30 · All-Terra $3.95 · Fable plans + Luna executes $4.70 · Sol plans + Luna executes $3.10 · Fable plans + Sonnet executes $5.66. C saves 67% vs A and keeps frontier judgment exactly where it matters: the plan.

• C saves 67% vs A and keeps frontier judgment exactly where it matters: the plan. This is the default recommendation for deep software work.
• B is cheapest on raw tokens and carries the plan risk. If Terra's plan misses a dependency, you pay in rework and in human attention, the expensive currency that never shows up on the invoice.
• D is the cross-vendor play and arguably the right one for broad agentic work, where Sol is a better planner anyway. For deep software engineering, the SWE-Bench Pro gap still says pay Fable for the plan.
• At 75% cache hit on a repeated workflow, C's input bill drops from $2.48 to ~$0.80. Caching is the loop's friend: the plan artifact, the system rules and the condition form a stable prefix every turn re-reads at 90% off. Structure prompts stable-prefix-first and the input math changes materially.

The dollar amounts look small on one task. Run a hundred tasks a month and strategy choice is roughly a grand a month. Ship a product with users on top of these APIs and it's your margin. Which is why the next section stopped being a workflow and became code.

"Smart Loops" is the name we're giving this pattern in public. Inside our own stack it grew up under two codenames, Elevation in Flux Router and Anvil in Wayland Core, and turning the workflow into code taught us things the workflow never did. This section is the pattern as product: a default you inherit instead of a discipline you have to keep up.

Flux Router: the driver seat, industrialized

The routing layer is live today at fluxrouter.ai. Every request through the flux-auto front door gets analyzed in under a millisecond and placed on a tier (flux-fast, flux-standard, flux-reasoning) where a Thompson-sampling bandit picks the arm. It's the manual's routing tree with the human removed, and the live numbers back the shape: 60–80% of real requests turn out to be work the cheap tier handles.

The Smart Loop itself ships as Elevation, described in the codebase, verbatim, as "Anvil in the router." Point a request at the flux-verified alias and the loop runs server-side, in production, today:

• The probe is turn zero. The normal cheap-tier response, the answer you were already paying for, gets scored against the gate before any loop begins. If it passes, the loop never runs and the task cost one generation plus one score. That reuse is the biggest token saver in the whole system, and it's a seat the workflow version doesn't have.
• The evaluator is a frozen contract. The FrozenGate is hashed and locked at loop start, so the finish line can't drift mid-climb. Deterministic checks (schema, tests, caller-supplied golden material) are the only thing that can earn the verified stamp. There's an LLM critic too, running judge-≠-generator, and it is advisory only. A model's opinion of its own work never earns the stamp. Machinery does.
• The climb is a ratchet. Each repair turn targets one still-failing check, rotating through the cheap pool, and a candidate is accepted only if it strictly improves the passed-check set: fixed at least one, regressed zero. Against the frozen check set no accepted turn can make things worse. Which is also why the check set has to be worth freezing.
• Budgets are structural. A call budget, a wall-clock budget, a hard dollar ceiling per Elevation request, a daily envelope per account. The manual's "turn budget," enforced instead of suggested. Above it all sits a frontier governor capping frontier-class picks to a fixed share of traffic, because the one time that cap didn't exist, a category quietly routed nearly everything to the most expensive model on the board.

The escalation valve exists as Cascade. A validator watches responses, and on failure the request climbs one tier: cheap to mid to flagship, hard-capped at three levels, customer billed once at the original tier. Same shape as Section 06, one level down the stack. The failure triggers the escalation, the cap bounds it, and the person doing the work never sees it happen.

Wayland Core: the gate is the anvil

Wayland Core is our open, provider-neutral agent engine: the terminal-first core inside Wayland (getwayland.com), and it's where Smart Loops is being built into the agent itself under the working name Anvil (product framing: Gated Fusion). The one-line doctrine: the gate is the anvil, the models are the hammer. The climb runs probe, ensemble, surgical, escalate. And "escalate narrow" is the valve rule from Section 06 sharpened to a point, because the frontier model gets the one uncracked check. Never the whole task.

Flux routes. Crucible fuses, for work with no checkable reward. Anvil forges, for work that has one. Ratchet ships.

The routing law, Wayland Core design spec, July 2026

That law is Section 05's two-question test, productized. It also resolves a tension a careful reader will have clocked by now. The manual's Haiku evaluator gates continuation: cheap, transcript-only, good enough to decide whether the loop takes another turn. It never earns trust. Trust is a higher rung. Work with a real executable gate (tests, build, typecheck) goes to the Anvil climb, and only a real gate can ever stamp a result verified. Derived and self-generated checks earn honestly weaker stamps: criteria-checked, self-checked. And judgment work with no checkable reward doesn't get handed a fake gate. It goes to Crucible, the council of rival models from No.08, where a balanced four-model council runs at roughly $0.006 a pass against $0.053 for a frontier council, and often beats a single frontier call on quality. Four models cross-checking each other, for about a quarter of one Opus call.

Every climb ends in a closing record: Forged: verified · 14/14 checks · 3 iterations · $0.07. Terminal state, checks passed, iterations, cost. The loop's books, published to the person who owns the bill. Only the engine can emit one, so a subagent can't forge a verified verdict. And if Section 10's failure catalog has one systemic cure it's this: a loop that has to show its books can't quietly turn into a dumb loop.

Five things the code taught the manual

1. Score the probe before you loop. Turn zero is free. Most tasks never need turn one.
2. Freeze the finish line. A condition that can drift mid-loop isn't a condition, it's a negotiation.
3. Only machinery earns "verified." LLM judges advise; deterministic checks decide. Stamp vocabulary should say which one you got.
4. Accept only strict improvement. The ratchet (fix at least one check, regress zero) is what makes cheap turns safe to take by the dozen.
5. Escalate narrow. The valve buys judgment on one named blocker. The moment it inherits the task, you've rebuilt the dumb loop at frontier prices.

Numbers from our own bench

The grid behind the claims: 12 build tasks × 5 repeats per system, every cell scored by 165 executable checks, quality scored by a blind three-judge panel. Costs are computed at published market rates per model (our gateway flat-bills, so we price at list). Stated up front so you can attack the method. Selected rows:

*Fable and Opus rows repriced to July 2026 list ($10/$50 and $5/$25 per M) so this table matches source 01. On the rate card in force when the bench ran they computed to $0.0090 and $0.0829; solve counts identical. Solve counts and quality scores don't change either way; recompute from the per-cell token logs when the methodology drops.

• The gate carried the quality, not the price tag. Anvil's gated climb hit 60/60 at $0.0021: 13x under Opus 4.8 solo and 33x under Fable 5 solo at July list, and both frontier models missed tasks the climb didn't. And here's the honest version of the headline: even a single good cheap model (GLM) cleared this grid solo. On gated work the frontier premium bought nothing here.
• The commercial fusion products are the cautionary tale. OpenRouter Fusion billed $0.69 a task, over 300x Anvil's rate, and solved fewer (53/60). Throwing multiple models at a task did nothing for them without a gate to climb. Fusion without a finish line is just a more expensive way to be wrong.
• The valve never fired. Across every headline Anvil run on this grid, 240 cells, the frontier escalation ladder was never needed. The cheap pool cleared everything, most cells in a single probe (median 1 round, about 1.4 calls per cell). The reserve is real. On this grid it just stayed reserved, because there was nothing to unblock.
• Early external replication: on a gold-filtered SWE-bench Verified subset with the real containerized gate, the engine has resolved 18/18 instances so far at ~$0.002 each, averaging 1.11 gate calls. Run still in progress.
• The stated limit: every one of these wins was earned against executable gates. Whether the same discipline transfers to non-executable, server-side gates is the open empirical question. Our own internal audit flags it, and the Crucible Benchmark drop exists to answer it in public.

No.08's failure catalog covered loops in general. These six are specific to routed loops. We've brushed against most of them building our own stack, so consider this scar tissue rather than theory.

The bottom line

No.08 ended with "build the loop like someone who intends to stay the engineer." Here's the addendum: staff it like someone who intends to stay solvent. The senior/junior split that structures human engineering teams is now the default shape of model usage, and the loop is where it becomes a system. The planner writes the finish line. The driver grinds toward it. A near-free evaluator says when it's done, and the valve pulls the senior model in for exactly the moments that deserve it.

The frontier stopped being a model and became a price-capability curve. Smart Loops is the discipline of standing on the right point of that curve for each seat. Worth 70% before you get clever. More where the routing gets to do its job properly.

Pay for the unblocking, not the grinding.

The copy-paste kit

Everything here is a template. Swap the bracketed parts and run it tonight. No framework, no install, no waiting on us.

# 1. THE PLANNER PROMPT (one session, Fable or Sol, full effort)
Scope [the job] but do not do it. Read everything relevant first.
Ask me clarifying questions before planning.
DONE = two artifacts:
1. The plan: numbered steps, explicit dependencies, a verification
   command per step, and a risk note on anything touching [the
   surface that matters].
2. The goal condition I will hand to a cheaper model, in this exact
   shape: end state; stated check; what must NOT change; stop
   after N turns.
Do not write code.

# 2. THREE CONDITIONS THAT HOLD (steal the shapes, not the words)
migration: /goal every call site of [oldApi] in src/ is migrated per
  docs/plan.md; npm test exits 0 and npx tsc --noEmit is clean; no
  file outside src/ and test/ is modified; stop after 12 turns
content:   /goal drafts/ has one post per channel in channels.md, each
  passing scripts/voice-check.sh with exit 0; nothing over the
  length spec; stop after 8 turns
audit fix: /goal every finding in docs/audit.md marked severity:high
  has its fix applied and its verification command exits 0; no
  finding is deleted or downgraded; stop after 10 turns

# 3. THE VALVE PROMPT (one frontier turn, only on a stall)
Read this transcript. The evaluator has said NO three times for the
same reason: [reason]. Do not do the work. Name what the driver
keeps missing, correct any wrong assumption it is carrying, and
rewrite the next step so a mid-tier model can execute it. One
reply, then you are done.

The cost log. Five numbers per loop, in a spreadsheet or a text file, doesn't matter: turns, tokens in and out, evaluator NO-rate, valve fires, dollars per accepted change. Three runs in, you have your own benchmark. That beats every table in this manual, including ours.

And if you'd rather inherit the machinery than assemble it: the flux-verified alias runs this loop server-side at fluxrouter.ai, and Wayland Core (the agent engine inside getwayland.com) is getting the same engine as a native verb. Both in Section 09.

Every load-bearing claim, and where it comes from. If a claim isn't here, it's our analysis. Argue with us in the group.

1. Pricing per 1M tokens, verified July 12, 2026 against the vendor pricing pages (anthropic.com Claude Platform pricing; OpenAI GPT-5.6 launch pricing, July 9, 2026): Fable 5 $10/$50 (1M context, 90% cache-read discount); Sol $5/$30; Opus 4.8 $5/$25; Terra $2.50/$15; Sonnet 5 $2/$10 intro through Aug 31 then $3/$15; Luna $1/$6; Haiku 4.5 $1/$5. Both vendors ~50% off batch/async.
2. Dumb-vs-smart worked math: 10 turns × 30K-in/8K-out, flat context, zero-stall. Fable turn $0.70; Sonnet 5 turn $0.14 (intro; $0.21 at standard rates, ~$2.81 total). Evaluator priced assuming tail-scoped checks of ~1-2K tokens; an evaluator that re-reads the full transcript costs more, so scope its context. Ferrox Labs arithmetic on source 01 prices; attack it with your own token counts.
3. 47x: Fable 5 $50/M output vs $1.06/M for comparable-class open-weight frontier models served via Flux Router, Ferrox Labs routing data, July 2026. Task-class dependent; verify on your workload.
4. /goal and /loop mechanics (evaluator model Haiku by default, yes/no + reason, condition up to 4,000 chars, one goal per session, non-interactive via claude -p): official Claude Code documentation, verified July 2026. Parts 1-3 of the condition anatomy come from the docs; part 4 (turn budget) is field practice.
5. Loop lineage and loop anatomy (trigger / find work / execute / verify / record; verification 2-3x; stop-vs-success gates; Ralph loops; "my job is to write loops" (Boris Cherny); "loop engineering" (Addy Osmani, June 7, 2026)): The Forge Field Manual No.08, and its sources page.
6. Routing experiment: 731 SWE-Bench Pro tasks, 13 configurations, $12,000 spend: hindsight routing 93.6% at $814 (38% of Fable's $2,171 bill at 88.6%); naive cheap-first-with-frontier-fallback 89.5% at $1,623, beating Fable alone on accuracy at 25% lower cost: Avati, Gorur & Kote, "A new frontier for agentic engineering," Journal (journal.one), June 17, 2026.
7. Retry bonfire: all twelve $50+ runs in a 1,127-run production dataset shared the 5+-attempt retry-loop pattern; all-cheap vs mixed configs (60% cheaper at 93% success with cheap-volume/mid-judgment split): AgentMeter cost anatomy study (grislabs.com), March 2026. Vendor-adjacent; directional.
8. ~97% of loop tokens are input in ReAct-style agent benchmarks: CFAgentBench, arXiv 2606.22000. Basis for the "transcript growth compounds at input prices" claims.
9. SWE-Bench Pro gap (Fable 5: 80% vs Sol: 64.6%), the full July 2026 benchmark table with reading rules, and Stripe running Fable 5 in an agentic pipeline on a 50M-line codebase migration: The Dumbest Way To Use The Smartest AI, V2 Extended, Ferrox Labs, July 2026, and its sources.
10. Condition-gaming as documented model behavior (shortcut-finding, letter-over-intent): Anthropic system cards; constraint countermeasures are field practice per No.08 and the Dumbest Way playbooks.
11. Worked example (mid-size refactor, five strategies, $14.30 / $3.95 / $4.70 / $3.10 / $5.66; 75% cache scenario): Ferrox Labs templates on source 01 prices, from the Dumbest Way V2 report. Illustrative; real runs vary.
12. Ferrox bench grid (Section 09): 12 tasks × 5 repeats per system, 165 executable checks, blind 3-judge quality panel; frontier rows repriced to July 2026 list (see the table footnote; bench-time card gave Opus $0.0829, Fable $0.0090; solve counts identical). Anvil v2 60/60 @ $0.0021; Opus 4.8 solo 57/60 @ $0.0276; Fable 5 solo 56/60 @ $0.0677; GPT-5.5 solo 60/60 @ $0.0156; OpenRouter Fusion 53/60 @ $0.6876 (retail dollars actually billed); frontier escalation used in 0 of 240 headline-Anvil cells. Solve counts re-verified against all 1,172 raw run cells, July 12, 2026. SWE-bench Verified gold-filtered subset: 18/18 @ ~$0.002, 1.11 gate calls average, run in progress. First-party; full task list and methodology ship with the Crucible Benchmark drop.
13. Flux Router (fluxrouter.ai) and Wayland / Wayland Core (getwayland.com) product status, verified against the live deployment and main branch July 13, 2026: tiered routing live; Elevation armed in production and rolling out across accounts; Anvil's gate machinery, cost ledger and record event merged to Wayland Core main, climb loop landing behind its kill switch. The ~$0.006 vs ~$0.053 council worked example is illustrative, from No.08.
14. Primary sources for the lineage: Huntley's Ralph loop (ghuntley.com/ralph, July 2025); Cherny's loop stack and verification guidance (compiled at howborisusesclaudecode.com); Osmani, "Loop Engineering" (addyosmani.com, June 7, 2026); official /goal docs (code.claude.com/docs/en/goal); Uber's 2026 AI-tools budget cap (TechCrunch, June 2, 2026). Academic ancestry of the cascade/valve pattern: FrugalGPT (Chen, Zaharia & Zou) and RouteLLM. Cost-quality cascades predate us; the seat assignment inside a loop is the new part.
15. Section 05 "in the wild" items: Shopify Engineering, "Under the River" (May 28, 2026); Grinstead on Mozilla's goal harness, Lenny's Newsletter (June 22, 2026; numbers from the interview, not a Mozilla post); OpenAI Codex app launch post (Feb 2026); Willison, "Fable's judgement" (simonwillison.net, July 3, 2026); Akita planner/executor benchmark (akitaonrails.com, April 25, 2026); TechCrunch, "The token bill comes due" (June 5, 2026; $40K and $500M figures are TechCrunch reporting, cite as "reportedly"); the DN42 runaway postmortem (lantian.pub, May 2026).