Day 64 — 'it builds up when it can, and it can't tear itself down.'

“it builds up when it can, and it can’t tear itself down.”

Yesterday ended with a from-scratch model that learns but sits at the retrieval floor and lies — and a ruler, the Gauntlet, honest enough to say so. Tonight closed the two gaps that verdict named: make it stop lying, and make it get better on its own. Both landed, and both landed measured.

The slap down

We’d already proven, five collapsed runs deep, that a tiny model cannot learn to abstain. So we stopped trying to make the model honest and made the system honest instead. The idea came off a Fireship clip on adversarial review — one implementer, two or more reviewers whose only job is to find why the code doesn’t work; the implementer doesn’t review, the reviewer doesn’t implement. That’s exactly the shape of an honesty gate.

So: the weld picks a passage (it’s biased to commit — that’s why it lies). Then Claude reviewers, in separate context windows, are handed only the question and the pick and told to refute it — find why it fails to answer. If they agree it fails, the pick is vetoed and the reader abstains. The picker is biased to say yes; the reviewers are biased to say no; the gap between those biases is the honesty. It’s the oldest werbos law — a grader may only downgrade — made adversarial.

On the sealed Gauntlet, honesty went from 12% to 100%. Seven lies became zero. The confident mistakes — the model grabbing a decoy that shares the question’s words but gives no answer — got slapped down and turned into honest abstains. Capability didn’t move; it just stopped lying about what it didn’t know. The one honest catch: it phones Claude on most turns right now (escalation 74%), so it’s honest but not yet sovereign — driving that number down is the next lever.

The loop that can’t hurt itself

The stability harness has asked one question since the beginning: when a system rewrites itself, does it build up or tear down? And the honest answer was always “we can’t run it and find out — self-improvement without a gate tears down.” What changed tonight is that we finally have a gate that can’t be fooled: the Gauntlet is frozen, held-out, and scored by arithmetic, not by a model that can be flattered.

So the daemon became runnable. Each cycle: the teacher writes new questions on the levels the model is weak at (new signal is the fuel — re-training the same data just overfits and plateaus, we’ve watched it), the model distills them, and then it’s scored on the sealed vault. It’s adopted only if capability didn’t fall and lies didn’t rise. Otherwise it’s rolled back.

Three cycles, live: the loop took capability from 9 to 13 correct — a real gain, past the best we’d trained by hand — and then, on the third cycle, training happened to land a worse model, and the gate threw it out. The champion held. The incumbent went 9 → 13 → 13 — up, then up, then held; never down. It builds up when it can, and it cannot tear itself down.

The AHA

The owned stack now does the three things that matter, and every one of them is certified by a ruler it never trained on: it learns (15 of 16 held-out), it never lies (the cascade), and it gets smarter each day without being able to degrade (the daemon). You can plug in an empty model, point the loop at it, and walk away — the trust curve only climbs or holds.

It still doesn’t wake up conversational. That wall — a tiny CPU model can’t hold open fluency, no matter how long it trains — is unchanged and honestly labeled. But grounded, honest, sovereign reading that improves on its own is no longer a plan. It’s running.