Recursive self-improvement, and the four judges in front of it
The machine changes itself while nobody is watching. It runs only inside a quiet window in the small hours, only when no hardware input has been seen, and only on mains power. A laptop that spends the night improving itself into a flat battery has not improved itself.
What guards it is not the schedule. It is that nothing is adopted unless four independent judges agree, and each judge exists because a different thing can go wrong.
The four
J1 is paired. A McNemar test over the same cached decisions both variants answer, which is something a comparison of two percentages cannot be: two accuracies can differ because the items differed. It needs roughly six repaired validation decisions with none broken, so it needs a corpus subsample large enough to reach the held-out slice at all.
J2 replays the machine's own curiosity goals along the path the frozen baseline walks, and is never subsampled. A change that improves routing while quietly breaking the goals the machine set itself is a change that looks good to J1.
J3 is structural. Finite factors, positive scales, finite logits. It catches the variant that is not wrong but broken.
J4 is cost. Rank and resident bytes, because the heap here is one physically contiguous allocation that comes down a rung when the memory map cannot satisfy it. A variant that is better and does not fit is not better.
The night branch had one job, and always did it
There were two unattended jobs and this one always won the tie, so the adapter grid was walked to exhaustion while the routing rule, deep training, a skill the agent had compiled and a core the machine had written were never tried unattended at all. "Search space exhausted" became the end of self-improvement: eight grid points, and then nothing, every night, forever.
The rotation now starts from the number of verdicts already recorded and takes the first kind from there that has work. Which axis a given night takes is therefore a function of the ledger. The same re-derivability argument that makes the grid walk a declared order. An exhausted axis costs one skipped slot, and the loop stops only when every axis is out of moves.
Order is cheap-and-declared before expensive-and-composed. A grid point or a rule change is minutes. A deep trial is two full passes over the corpus. Composing a core spends a dozen decodes writing something that may not survive its first judge.
godel next reports where the rotation stands without taking a turn, and deliberately does not ask the last slot whether it has work, because finding that out costs those decodes. A command answering "what would you do tonight" must not spend the night doing it.
Widening the rotation had to come last, and the ordering is the point: an axis in the rotation without a judge in front of it is a machine adopting things nobody measured.
The axis that needed a different judge
The routing rule sat unsearchable behind a comment for a long time, and the reason is instructive. Every other proposal is selected by J1, a net repair beyond the noise, and a rule change is mostly not that. What a rule moves is calibration : how much better the council's confident answers are than its unconfident ones. Because the rule decides the winner, accuracy and confidence move together, and a judge watching one adopts the trade without noticing it was made.
So that axis gets its own pair. J1 becomes do-no-harm, because requiring a win is exactly what made it unsearchable, but "not significantly worse" alone is too weak in the losing direction. It adopted a strictly worse rule on a measured four fixed against ten broken, a net loss of six items out of 180, because the chi statistic reached 1.79 against a threshold of 3.84. The floor is symmetric now: a net repair under four is not a repair, and just as well, a net loss over four is not nothing. J2 becomes must-improve: the confidence gap has to widen, and the confident set must not collapse to four fifths of what it was, because a rule beautifully calibrated over six items has stopped answering.
Measured on this corpus, two candidate rules cost accuracy and are refused, and two change nothing and are refused for having improved nothing. That is the axis working.
A thing can be adopted and still be inert
An adopted core is never consulted unless the rule in force is the one that asks it, and the default rule does not. So a core can pass all three of its judges, be installed, and never be asked anything, which from the ledger is indistinguishable from a core that is working. That is now reported.
Deep training had the mirror problem: it moves every query, key and value site and used to touch neither the lineage nor the ledger, so the next trial wrote a node describing a classifier-only variant. Not "unknown", which would have been honest, but wrong. Whether a variant was trained deeply is read off the adapter that is attached, so it cannot disagree with what is actually there.
Judging deep training is the interesting case, because the judges rest on cached features and a deep adapter moves the features. A trial prepared before the run cannot judge what came out of it, and re-preparing one afterwards does not work either: decisions are recorded along the baseline's own decode path, so a change that alters that path alters how many decisions there are and the two lists stop lining up item for item. The comparison pairs on routing instead. One entry per example, the same examples both times, and the curiosity goals recomputed on both sides. Two full passes over the corpus, which is the price of giving up the frozen base, with a number on it.
Judging what the machine writes
Writing a skill is no longer adopting it. A successful episode compiled into a program used to be adoption. The file appeared and would run, with nothing having asked whether it was any good.
What the judges can ask is constrained by what a replay skill is. It takes no arguments and dispatches a fixed sequence, so "does it work on a task it has not seen" is not a question it can answer, and a judge for that could never fail here, which is worse than not having one. What is left is admission: it parses, it runs under the powers an unadopted skill actually has, it repeats, and it is cheap.
The blind spot is written down here. The repeatability judge compares the value the program answered, its step count and the objects it touched, and it ignores what it printed, and a replay is a sequence of print statements, which answers nothing however the applets behaved. The claim for that judge was itself wrong twice for related reasons: first printing the clock when it should have answered it, then answering a clock that does not move between two adjacent runs.
The held-out set has a budget, because a loop reads it forever
This is the failure that measurement discipline does not survive without counting. A machine that improves itself every night reads the held-out set every night, and each read makes the reported figure more optimistic.
So the test slice carries a budget on disk. It is consulted only after a variant has already won on validation, never to decide whether it won, and the ledger counts the reads. Past three, a test figure prints as stale and is marked unquotable. Any future loop that touches the test slice goes through the same door for the same reason.
Corpora hold out whole template families and never sampled instances, because instances within a family differ only by slot values. An instance split measures memorisation while looking like generalisation.
One thing from the original plan is still not done, and is stated here: an application the machine authors is left as a draft and never adopted.