How does no_human save me money?
Babysitting one chat is expensive for a specific reason: the whole conversation is re-sent on every turn, so the longer the task runs the more you pay per step - and the most expensive model does every job, including the trivial ones. no_human is built the other way round.
None of this is a discount on the thinking. Every saving below comes from cutting waste - repeated context, oversized tool dumps, the top model doing clerical work - and not one of them touches the reasoning that writes or judges your code. Two of them make the output better, for the same reason they make it cheaper.
Context rot, which is 96% of every token burned
Cache reads are 95.6% of every token spent - one agent re-reading its own swelling transcript, over two million tokens per attempt. Even at a tenth the price of fresh input, they still dominated the bill. So each role holds a separate, short-lived context with only what its job needs, and a stuck run resets rather than stacking corrections onto a poisoned one. Nobody pays to re-read an hour of someone else's conversation.
Why quality improves: a reviewer that never saw the code being written cannot be talked round by the reasoning that produced it. Fresh context is what makes the review adversarial rather than agreeable - the saving and the rigour are the same design decision.
Four model tiers, assigned by consequence
Building runs on Sonnet. Planning and adversarial review run on Opus. Summarising, classifying and distilling run on Haiku. The rule is simple: a wrong answer in the cheap tier degrades a hint, never a verdict. One conversation cannot do that; four tiers can.
Why quality holds: the expensive model is not removed, it is concentrated. Your code is reviewed by the strongest tier available, on a diff, by something whose only job is to find what is wrong with it. Nothing that decides whether work ships runs on a cheap model.
LLM-as-a-judge, with the judge's own score thrown away
The reviewer must cite file and line for every claim. Those citations are checked against the tree, and the pass/fail is then recomputed deterministically from its checklist - not read off the model's own opinion.
Why quality improves: we never ask a model to rate itself out of ten, so no self-assessment can promote work. A fabricated citation is caught by the check rather than believed, and an unparseable verdict fails closed.
Caching is bought, not hoped for
A cache read prices at a tenth of fresh input, so prompts are ordered stable-prefix-first to keep it warm. Every cache read is counted in what we report - the part usually left out of a cost claim.
Why quality holds: caching changes what a token costs, never what the model is given. The prompt is identical either way.
Deterministic gates run before the expensive one
A tamper check and a reproduction gate are plain code, not prompts. They fail bad work at zero token cost, so the reviewer is only ever spent on a candidate already worth judging.
Why quality improves: these gates cannot be argued with. A test suite that shrank, or a bug fix that never reproduced the bug, is rejected before any model gets a chance to be persuaded otherwise.
Tool output is capped before it reaches the model
A search that returns 8,000 lines gets trimmed to what is useful, per tool, with a pointer to retrieve the rest. Those results would otherwise be re-sent on every later turn, at full price, forever.
Why quality improves: nothing is discarded - the rest stays one fetch away. What is removed is noise that would otherwise sit in context competing for attention with the part that mattered.
Only the tests your change touches
Runs are routed to the affected test files instead of the whole suite, so verification cost scales with the change, not with the repository.
Why quality holds: this is the one saving with a real trade-off, so it does not stand alone. Held-out tests the agent never sees run against the result, a deterministic check fails any attempt that deletes or weakens a test, and your own CI can gate the loop. Routing decides what runs first - not what counts.
Bounded loops, not hopeful ones
Hard per-attempt and per-task token budgets, a capped attempt count, and stuck detection. When it cannot finish honestly it stops and asks - it does not grind against the cap producing nothing.
Why quality holds: the cap does not lower the bar, it ends the attempt. A task that cannot be finished honestly comes back as a question with what it learned - never as a thinner change described as done.
You are not in the loop
The largest cost in the babysat version is not tokens. It is your senior engineer steering, re-explaining and disproving. That line item goes to zero until the review.
Why quality holds: their judgement still decides. It is spent on a finished diff with the evidence attached, instead of on forty turns of steering - and the merge is still theirs to make.