Forgetting Model 4: Everything Lands on One Frontier

I’ve been writing about forgetting on this blog since 2019, mostly as theory. This year I finally had the compute to test it — on a real LLM, with executor-verified ground truth and pre-registered criteria. Almost everything I believed turned out to be wrong, and the wrongness was more interesting than the theory. This post is the honest ledger: ten things that failed, two that worked, and the one wall I couldn’t get past. Every principle has an interactive demo — play with them, they carry the argument better than the prose does.

1. Seven years of hand-waving

Quick recap of where this series left off.

Forgetting model for MLP (2019) argued you should slow the update down per-dimension instead of updating the whole network. Forgetting model continued worked through the backprop algebra for that. And forgetting model 3 (2022) is barely a paragraph — I wrote down one idea and left it:

It’s all about time! All the network training in current deep learning settings are not considering the effect of time. However, the biological inspiration led me to rethink the necessity of time as an important parameter in the full system.

That’s the two-timescale hypothesis, three years before I could test it. A fast learner that’s allowed to overfit and forget, and a slow learner that absorbs only what survives averaging. Complementary learning systems, hippocampus and cortex, the whole story.

I finally tested it this month. It’s just a smaller learning rate. More on that in §8.

Here’s what changed since 2022: the question stopped being academic. If you want a model that gets permanently better from its own experience — not better for one session with a scratchpad, but better in the weights — you have to write into the weights. And the moment you write into the weights, you’re paying for it somewhere. The whole game is figuring out what the exchange rate is, and whether anything actually beats it.

2. What a task actually is

Most self-improvement papers are impossible to argue with, because “the model got better” is measured on the same distribution it trained on. I wanted a setup where I could be proven wrong. That starts with the data, so let me show you the actual thing before I claim anything about it.

The domain is procedurally generated Python list transformations. Every task is a known composition of primitives — the structure — instantiated with concrete parameters and input data — the surface. Because I generate the tasks, I know the structure exactly. The model is never told it. There’s no docstring, no hint, no natural-language description. It sees input/output pairs and has to induce the rule, then write transform(xs). A sandboxed executor runs the candidate against all the demos; it passes only if every single one matches. No LLM judge, no partial credit, no drift.

Play with a real one below. Try to induce the rule yourself before you hit reveal — that’s exactly the problem the model is facing, and it’s worth feeling how it goes.

A real task from the generated corpus, shown exactly as the model receives it. Reveal the structure to see the composition, and step the pipeline to watch one input pass through both primitives.

Knowing the structure of every task is what buys the three separate held-out sets. Each one holds something fixed and varies something else:

• HO-surface — the same structures as training, unseen surface: new parameters, new input data. Tests specialisation. Did it learn the transformation, or memorise these particular lists?
• HO-composition — novel compositions of the same primitives, templates never trained on. Tests systematic generalisation. This is the one the whole project was about.
• FORGET probe — MBPP+, ordinary unrelated Python problems, never trained on in any arm. Tests what the update destroyed.

Base rates, so you can calibrate everything that follows: FORGET probe 0.847, HO-surface 0.100, HO-composition 0.083. The model solves about 10% of these greedily. That headroom is deliberate.

Two more decisions make the rest of the post mean something. Pre-registered criteria, frozen before looking — written into the spec file and committed before the first run. I’ll show you a place in §11 where I misread my own data, and the only reason it got caught was that I’d written down in advance what would count as success. And small enough to run many times: Qwen3-4B-Instruct with LoRA (r=16, q/v), so each arm takes minutes. A mechanism claim needs a dozen controlled runs with error bars, not one heroic run.

3. The corpus, and the one number that turned out to matter

A task is one thing. The corpus is another, and it’s where the only real result in this post came from.

Two big runs used the same method, the same model, the same budget of roughly 600 practice tasks, and the same twelve-primitive vocabulary. The only thing that differed was how many distinct compositions those tasks were spread over: 12 structures, or 48. That ratio has a name — context multiplicity, $Nk/m$ — and it went from 2.00 to 8.00.

I didn’t expect this to be the interesting variable. It turned out to be the only intervention in the entire programme that moved compositional generalisation at all.

The same vocabulary, spread two ways. Toggle between the runs and watch the matrix go from sparse and clumped to dense and even.

Two things in there are worth pausing on, and I only saw them by going back to the actual split files instead of trusting the summary number.

Run A’s corpus isn’t just low-multiplicity, it’s skewed. filter_gt appears in 5 of the 12 training structures. sort_desc, dedupe and cumsum appear in exactly one each. And take_first appears in zero training structures while still showing up in held-out compositions. In Run B every primitive lands somewhere between 5 and 11. A primitive that only ever occurs inside one composition is, as far as the data is concerned, indistinguishable from that composition — nothing tells the model it’s a reusable part. That’s a sharper statement of the problem than “not enough diversity”, and it fell out of the data rather than the theory.

Held-out compositions only ever reuse primitives that appear in training. This is a deliberate design property, and it’s what licenses calling HO-composition a test of systematic generalisation rather than a test of missing knowledge. If the model fails there, it failed to compose — not to know. Without that guarantee the whole measurement would be worthless.

4. The graveyard

Before the story, the body count. Ten things that didn’t work.

I’m putting this up front on purpose. The usual shape of a research post is “here’s my clever idea, here’s why it works” — which hides the part that’s actually informative. Every card below has a measured mechanism, not a shrug. “It didn’t work” is worthless; “it didn’t work because the compressed latent can’t carry enough bandwidth to represent even one transformation, and here’s the cross-entropy floor that shows it” is a result.

Click any card to open it. Filter by category if you want to skip ahead.

Ten dead ends, each with the measurement that killed it. Blue = the ARC phase, amber = consolidation mechanisms, red = theory. The rest of this post walks through the interesting ones.

5. Why the recursive-latent ideas died

The first five cards are from an earlier arc (pun accidental) where I tried to get recursive latent reasoning working on real ARC-AGI. I’ll summarise rather than re-litigate, because the mechanism failures rhyme.

I got eval-400 coverage from 5.5% → 9.5% → 10.75%, union 12.0%. SOTA is 40–45%. That’s not a competitive number and I’m not going to dress it up.

The instructive part is why the recursive-latent ideas died. Three architectures trained from scratch produced exactly zero held-out exact matches, and the diagnostic was that the demo-fit cross-entropy floored at 0.91–1.08 and never approached zero — the model couldn’t even fit one transformation, let alone generalise. The conditioning bottleneck was too narrow. Then I tried Coconut-style hidden-state loopback on a frozen pretrained model, zero-shot: valid-program rate fell 200 → 194 → 179 out of 200 as I added latent steps. Of course it did. The model was never trained to consume its own hidden state; feeding it back walks straight off the manifold. Then I trained an adapter to fix that, and got a val delta of −0.004, identical across all three epochs. Flat. No proof of life.

That last one taught me something I kept running into later: there was no gradient signal because there was nothing to learn. For tasks the prefill already solves, recursion has no headroom. For tasks it can’t solve, there’s no verified target to train against. The recursion had nowhere to live.

The fourth card is the one that generalises best. I built an operator-library ratchet — solve tasks, harvest reusable operators from the solutions, add them to a library, use the library to solve more tasks. It worked, for a bit: +13 tasks. Then it stopped dead. Newly solved per round went 81 → 19 → 11 → 5 → 6; the library plateaued at 69 operators; by round 4 it was adding 6 solves and zero operators. The reason is embarrassingly obvious in hindsight: you can only harvest operators from tasks you already solve. The ratchet can compress what you know. It cannot reach what you don’t. Hold onto that — it’s the same wall as §12.

Four failures, four distinct mechanisms. Step each animation — the counters are the actual measurements, not illustrations.

Panel B is the one I’d point a reader at. “No gradient signal because there was nothing to learn” is not a sentence I expected to write about a training run, and it took a flat val delta across three epochs to believe it.

6. Four ways to write experience into weights

Now the machinery. Everything from here on is one of four mechanisms for taking executor-verified experience and pushing it into the weights. They all consume the same verified episodes and are budget-matched — identical example counts, identical gradient steps, identical hyperparameters and seeds. Only the mechanism differs. That’s what makes the comparison mean anything.

Rather than describe them in prose, here they are as animated flow diagrams. Step through each one, then read the result panel. The rest of the post is the argument about why three of them landed in the same place.

The four mechanisms, sharing one visual language so they’re comparable. Flip between ARM-A and ARM-B and exactly one block changes — that’s the controlled comparison §7 is about.

7. The first real question: what should you consolidate?

Here’s the idea that got me excited enough to pre-register it.

Everyone dodges catastrophic forgetting by isolation — separate adapters, retrieved soft-prompt memories, LoRA routing, EWC-style regularisation. All of these keep the new knowledge structurally apart from the old. But isolation doesn’t give you a better model; it gives you a filing cabinet with a model attached.

The alternative: what if forgetting isn’t about how much you write, but about what you write? Distilling raw trajectories (ExIt, ReST) writes a hundred idiosyncratic instances into the weights, each fighting the others. But if you first induce the recurring structure from those instances and consolidate that, the update is one coherent thing instead of a hundred conflicting ones. Fewer collisions, less forgetting. DreamCoder learns abstractions but keeps them symbolic; nobody had run the controlled head-to-head on the consolidation unit itself.

So I ran it. Two arms, same base, same wake experience, exactly the same number of training examples and gradient steps:

• ARM-A (instance): SFT directly on the 100 verified (task → solution) episodes. Standard ExIt.
• ARM-B (abstraction): from the same episodes, induce recurring structure behind a schema gate (a structure is admitted only if it appears in ≥3 distinct verified episodes), then generate fresh, executor-grounded, diverse instances of that structure, and SFT on those.

To make the test as fair as possible to the hypothesis I used an oracle abstraction grouping — a perfect detector — so a null couldn’t be blamed on bad induction. ARM-B ended up covering 6 of ARM-A’s 7 structures, which biases against the hypothesis. Recorded and kept.

Pre-registered as CONFIRMED iff: (a) forgetting smaller in B by ≥2 pts, (b) HO-composition B−A ≥ +5, (c) replicated across ≥2 seeds, (d) gradient conflict lower in B.

Result: NULL — with criterion (a) significantly reversed.

The abstraction arm — the one I predicted would be safer — forgot 5.4 points, significantly, in both seeds. The instance arm forgot nothing.

The diagnosis is in the training curves, and it’s the single most useful thing I learned all year. ARM-A’s loss went 0.058 → 0.031. It started at almost zero loss. Of course it did: it was re-fitting solutions the model itself had generated. There was nearly no surprise in that data, so the weights barely moved, so it neither gained nor forgot. It looked safe because it was a no-op. ARM-B’s loss went 0.440 → 0.150 — it genuinely learned something, bought the only real gain in the table (HO-surface 0.133 vs 0.100), and paid for it.

F1: you cannot dodge forgetting by changing the consolidation unit. Forgetting tracks how much the model actually moves, not what the update encodes. Stability–plasticity reasserts itself intact.

And a free methodological result:

F2: within-task gradient conflict does not predict catastrophic forgetting. ARM-B had the lower pairwise conflict rate in both seeds and was nonetheless the arm that forgot. This is a cheap, intuitive, widely-assumed proxy, and it’s wrong — interference among the new examples tells you nothing about interference with pre-existing capability. Criterion (d) passed and it didn’t matter, which is exactly why you pre-register all of them.

8. The currency is KL, and everything lands on one line

F1 said forgetting tracks “how much the weights move.” That was still a proxy, and a bad one — weight distance is unreliable because of parametric symmetries. The right currency, per RL’s Razor, is the KL divergence between the tuned and base policy on the distribution you care about.

So I measured it directly. measure_kl.py loads one model, uses peft’s disable_adapter() to get base and tuned logits over the same teacher-forced tokens, on trajectories that are the base model’s own greedy generations. No second model, no sampling noise. One number per arm: how far did this update actually move the function, on the distribution the base actually visits.

Then I plotted every arm I had against it. Including the two-timescale system from 2022.

The demo below is the single most important figure in this post. Start with “show on-policy” off. Toggle between gain and forgetting.

Five methods that have nothing algorithmically in common, all sitting on one line. Toggle the axis: gain and forgetting are both near-deterministic functions of KL. Then switch on the on-policy trajectory — that’s the one thing that left the line.

Look at the correlations: corr(KL, gain) = 0.986, corr(KL, forgetting) = 0.921. And the slope is method-independent — gain per 0.01 KL is 0.84 for EMA, 0.96 for the small-LR control, 0.88 for direct merge. Same exchange rate no matter how you got there.

This kills the 2022 idea cleanly. The EMA two-timescale system reached KL 0.0202 and got +1.7 gain / +0.7 forgetting. The small-LR control reached KL 0.0260 and got +2.5 / +5.4. EMA looked safer. It was safer. It was safer because it took a smaller step, which is exactly the confound the control was designed to catch. At matched KL, averaging buys you nothing. Fourteen years of intuition about hippocampus and cortex, and the mechanism reduces to a learning-rate schedule.

I want to be precise about what died and what didn’t. What died is the claim that two-timescale averaging is a distinct anti-forgetting mechanism. What survives is something the frontier itself tells you: if gain and forgetting are both functions of one scalar, then every “algorithmic” intervention — averaging, chunking, LR schedules, the choice of consolidation unit, gap-targeting — is a move along the curve. You can pick your point on it. You cannot leave it.

Which immediately tells you what would work. You need something that changes which solution you land on at fixed KL — not how you get there. Two candidates: on-policy mode-seeking (among all solutions to a task, prefer the KL-nearest), and targeted retention (protect what matters, spend KL where it doesn’t).

I tried the cheap version of the first one — ARM-C, training only on the “search gap”: the 37 episodes where search found something greedy decoding missed, so the data is on-policy and non-trivial. It landed on the line at KL 0.0159. (It also had a coverage confound — only 4 structures survived the schema gate — so its HO-surface comparison isn’t usable. Stated, not buried.) Five arms, one frontier.

9. The one thing that left the line

Every arm so far was one off-policy step on a fixed corpus generated by the base model. RL’s Razor’s actual prescription is different: many small steps, each on-policy with respect to the model currently being updated.

Round $r$: sample $K=16$ candidates from $\theta_r$ itself → executor-verify → SFT $\theta_{r+1}$ from $\theta_r$. Each step is KL-minimal because the data comes from the model taking the step. But capability can still accumulate across rounds, because round $r{+}1$’s data comes from an already-improved model.

Go back to the demo above and switch on the on-policy trajectory. It sits clearly above the line for gain and clearly below it for forgetting.

At round 5, KL = 0.0713: the frontier predicts +6.3 points of gain and +14.0 points of forgetting. Measured: +14.2 gain (2.26×) and +4.0 forgetting (0.29×). Better on both axes at once. That’s not a move along the curve, that’s a shift of the curve.

I originally wrote that the effect emerges with iteration — that round 0 sits below the frontier and rounds 1 onward jump above it — and treated that as the mechanism’s signature. That was wrong, and it was wrong because I spliced two runs together. An early partial run (rounds 0–2) got superseded by a complete six-round re-run, and I carried the early run’s first three points into the writeup without noticing. In the complete run, round 0 is at 1.69× — already above the frontier, before any on-policy iteration has happened at all. The emergence signature does not survive. What survives is that the endpoint is well above the line; the mechanistic story I attached to it does not.

There’s a second measurement I like more, and it’s unaffected. At a fixed search budget of $K=16$, the number of wake tasks the model solves goes 95 → 132 → 137 → 147 → 159 → 194. That’s +104%. Capability that previously required search is being absorbed into the weights. Sleep-time compute, measured rather than asserted.

F4: by round 5, iterative on-policy consolidation is ~2.3× more KL-efficient for capability and ~3.5× more KL-efficient for retention than the single-step arms. Averaging failed this test. LR scheduling failed it. The consolidation unit failed it. Gap-targeting failed it. This passed — but see the caveat above: with round 0 already at 1.69×, I can no longer attribute the departure specifically to on-policyness, because round 0 isn’t on-policy. Something about this pipeline beats the five-arm frontier from the first step, and the frontier is fit from five single-seed points. The endpoint gap is large; the mechanism behind it is less pinned down than I claimed.

Now the part that stopped me cold. I checked HO-composition — novel compositions of the same primitives, the thing I actually cared about. Over six rounds, from a base of 0.083: 0.092 → 0.092 → 0.075 → 0.083 → 0.100 → 0.117. A +3.4 point wobble, non-monotone, dipping below base at round 2.

So the loop was working, and it was making the model better at what it already knew how to do. Same-structure specialisation, +14.2 points. Systematic generalisation, noise. For a project whose entire point was “can abstraction be amortised into weights,” that’s the wrong kind of success.

My first instinct was that this was an emergent-capability story and I needed more rounds. I checked before writing it up: context multiplicity — how many distinct compositions each primitive appears in — was pinned at exactly 2.00 for all six rounds. The loop wasn’t broadening. It was drilling.

10. What finally moved composition

So change that one thing.

Same method, same model, same ~600 wake tasks, same everything — except spread the tasks over 48 structures instead of 12, which takes context multiplicity from 2.00 → 8.00.

Identical loop, identical budget. The only difference is how many distinct compositions the experience is spread over. Left: +3.4 points, non-monotone. Right: +15.8 points, monotone every round. Note that specialisation is about the same in both (+14.2 vs +11.7) — only composition depends on diversity.

HO-composition 0.142 → 0.300. +15.8 points, 2.11×, monotone across all five rounds. HO-surface +11.7. Wake tasks solved at fixed budget 103 → 163 (+58%). And still above the frontier: at KL 0.0519 the prediction is +4.6 gain / 10.2 forgetting, measured +11.7 (2.56×) / 6.7 (0.66×).

The honest caveat, which matters: the two runs use different novel-composition test sets, so the absolute levels aren’t comparable across runs. What’s comparable is each run’s delta from its own base, and the monotonicity. A +3.4 non-monotone wobble versus a +15.8 monotone climb over five consecutive rounds is not a subtle difference, but I’m not going to claim 0.300 > 0.117 as if those were the same scale.

F5: compositional generalisation can be amortised into weights — but the experience stream has to supply the compositional variation.

I first wrote this up as a conjunction of two ingredients, each useless alone: on-policy iteration as the carrier, diversity as the content. Then I looked at round 0, and that framing fell apart.

Round 0 is not on-policy. It samples from the base model, verifies, and takes one SFT step — the same protocol as the five single-step arms, at the same budget. So round 0 of each run is a clean controlled comparison in which the only difference is corpus width:

One step. No iteration. Widening the corpus is worth ten times as much on composition, immediately — +9.1 of the eventual +15.8, or 58% of the total, before the loop has done anything at all. Iteration then adds the remaining +6.7 over four rounds and makes the climb monotone.

So it isn’t a conjunction. Diversity does not fail alone; it does most of the work in a single step. Iteration is a real but secondary multiplier. If you only have budget for one intervention, the answer isn’t close.

I find the specialisation column genuinely striking. HO-surface gain is +14.2 at low diversity and +11.7 at high diversity — essentially the same, slightly worse at high diversity. Diversity doesn’t make the loop better in general. It converts what the loop produces from memorised specialisation into transferable structure, and it does that without costing anything on the specialisation axis. Those are two different learning outcomes riding on the same optimisation, separated by one property of the data.

11. The theory that didn’t survive contact

Running parallel to all this was a much prettier idea, and I want to include it because of how it failed.

The proposal: forgetting isn’t a bug to be minimised, it’s a control parameter. Turn up the forgetting rate $\Gamma$ and you destroy memorised solutions faster than you destroy shared primitives — because a memorised solution is supported by one training composition, while a primitive is reinforced by every composition it appears in. Below some $\Gamma$ everything survives, including memorisation. Above some other $\Gamma$ even the primitives die. In between: a window where only the compositional solution is stable. A memorisation→generalisation phase transition, driven by forgetting.

And the beautiful part — the critical points are supposed to be fixed by the data statistics alone, with no free parameters:

where $N$ = distinct training compositions, $m$ = primitives, $k$ = primitives per task. A parameter-free prediction is a gift. It’s either right or it’s dead, and you can find out cheaply.

So: tiny decoder-only transformer, from scratch, SCAN-like compositional grammar, $\Gamma$ := weight decay (it is the $-\gamma a_f$ decay term, it’s a single monotone scalar, and grokking is known to be driven by exactly this). Sweep $N$ and $\Gamma$. Minutes per run.

The predicted left edge is marked for each $N$. It isn’t there. $N=48$ is already flat-out at $\Gamma$ twenty times below its predicted edge; $N=12$ is at zero even inside its window. Switch to the second view for the two-seed fine sweep at the critical $N=24$, where the inverted U does show up — and where the collapsed runs show you how easy it would be to fool yourself.

The prediction fails. $N=48$ scores 0.385 at $\Gamma = 0.001$, twenty times below its predicted critical point — the transition should not have happened yet, and it’s already saturated. $N=12$ scores exactly zero across two full decades of $\Gamma$, including inside its predicted window. The left edge does not scale as $1/N$. There’s a crossover, not a phase transition with computable edges.

What survives is weaker but real: $N$ is the first-order control parameter and $\Gamma$ is second-order. Over the swept range, $N$ moves test accuracy 0.000 → 0.385 while $\Gamma$ moves it by at most ~0.10. Roughly, doubling the number of compositions is worth about thirty times the weight decay. And at the critical $N=24$ — and only there — $\Gamma$ genuinely does buy compositional generalisation, replicated across both seeds: 0.000 → 0.285 in one, 0.014 → 0.458 in the other, monotone in both.

Two things I got wrong here, both worth writing down.

First: I misread my own sweep. My initial $\Gamma$ grid was coarse — 0.01 / 0.1 / 1.0 — and it made a real rising branch look like a noise bump. It took a finer sweep to see it. Worse, at $N=8$ my grid never sampled inside the predicted window $[0.125, 0.25]$ at all. So $N=8$ doesn’t test the theory. It’s not evidence for or against; it’s just a hole in my design, and I only noticed because I went back and checked the predicted window against the grid I’d actually run.

Second, and this is the more dangerous one: I claimed an inverted U that my own data does not support. At high $\Gamma$, training sometimes just collapses — train accuracy 0.007 instead of 1.000 — and a collapsed run scores 0 on test. My instinct was that averaging those in with successful runs was manufacturing the descending branch. I checked. It isn’t: the peak sits at $\Gamma = 0.4$ whether you pool the collapsed runs or drop them. What pooling actually does is halve two points (0.285 → 0.1425 at $\Gamma=0.2$, 0.458 → 0.229 at 0.4) and stamp a dip at 0.2 that is purely seed 1’s optimiser failing.

The real problem is worse. Keep only the runs that actually fit the training set — train accuracy 1.000 — and there is no descending branch at all. Both seeds are monotone rising, end to end. The only points that fall are $\Gamma = 0.8$, where train accuracy is 0.892 and 0.964 — not 1.000. Every downturn in this experiment is a model that partially failed to fit, and the “inverted U” is my eye connecting a real rising branch to an optimisation artifact.

So the honest verdict is narrower than the one I first wrote down: the rising branch is real and replicated across seeds. The U is not established. And since which $\Gamma$ collapses a run varies by seed — seed 0 died at 0.4, seed 1 at 0.2 — the right-hand edge of the predicted window is untestable with this apparatus. Not “we measured it and it’s wrong.” Untestable. This is the one correction in this post I didn’t catch myself; it came out of re-deriving the pooled numbers instead of trusting the sentence I’d already written.

I also killed my own order parameter here. I’d defined $\Phi$ as a cross-task Fisher participation ratio — how many training tasks genuinely share each parameter — expecting it to go to 0 for pure memorisation and 1 for full compositionality. It peaked at 0.855 exactly where the model collapsed (train accuracy 0.279). Of course it did: a model that learned nothing has near-identical gradients on every task. $\Phi$ is meaningless across the collapse boundary. A structural order parameter that can’t distinguish “perfectly compositional” from “learned nothing” is not an order parameter.

12. The wall: the loop can verify, but it can’t vary

Here’s where I actually am, and it’s the most important paragraph in this post.

F4 + F5 say: iterative on-policy consolidation plus high compositional diversity genuinely amortises compositional ability into weights. That’s a real, positive, replicated-across-rounds result, and it moved a frontier that eight other interventions couldn’t budge.

But look at where the diversity came from. I typed it in. The N=12 → N=48 change was me editing a config file. The loop did not discover that it needed broader compositional coverage, and it could not have generated it. Context multiplicity sat at exactly 2.00 for six rounds while the loop happily got 14 points better at specialisation.

That’s the bootstrap ceiling, and it’s the same wall as the operator-library ratchet in §5. Verification is self-sustaining. Variation is not. The executor gives you a free, perfect, drift-proof reward signal — you can run that loop forever without a human. But the loop only ever consolidates solutions to problems it can already occasionally solve, drawn from a distribution it can’t widen. It compresses. It doesn’t explore.

Card 5 in the graveyard is the attempt to fix this directly: preplay, dream-sleep, let the model generate its own novel compositions to train on. Held-out coverage went from 21 to 15. It got worse. The self-generated compositions were perfectly plausible and completely off-distribution relative to ARC’s human-designed tasks — sim-to-real, in a domain where I’d assumed there was no sim-to-real gap because both sides are just programs. There is one. The distribution of interesting problems is not something the model has a handle on.

So the honest summary of the whole programme:

Every algorithmic intervention landed on one frontier or nulled outright. Only data-distribution interventions moved anything. And the loop cannot supply its own data distribution.

That’s not a solved problem with a caveat. That’s an unsolved problem with a well-characterised shape, which is a better place to be than where I started, but I want to be clear about which one it is.

13. What I’d tell 2019 me

Measure function movement, not weight movement. Half this series was about slowing down per-dimension updates in weight space. Weight space is the wrong space — parametric symmetries make distance there unreliable, and my own gradient-conflict probe (a weight-space quantity) got falsified while the KL probe (a function-space quantity) rank-ordered every arm correctly. The 2019 intuition wasn’t wrong about there being a conserved cost. It was wrong about the currency.

“It’s all about time” was half right in the least useful way. Two timescales do matter — but through when the data is generated, not through how the updates are averaged. The fast/slow loop earns its keep because round $r{+}1$ samples from $\theta_r$, not because $\theta_{\text{slow}}$ filters $\theta_{\text{fast}}$. Averaging is a learning rate. Regenerating the experience is a mechanism.

A no-op is not a safe method. The single most useful diagnostic I built this year was looking at the initial training loss. ARM-A started at 0.058 and I nearly wrote it up as “instance consolidation is safe.” It wasn’t safe, it was inert. Any time a self-improvement method reports low forgetting, check whether it learned anything, and check it with a loss curve rather than a benchmark delta.

Pre-register, then actually go back and check the grid. The $N=8$ hole and the collapsed-run pooling would both have survived into a writeup if I hadn’t had frozen criteria to check against. Neither was caught by intuition. Both were caught by rereading what I’d promised to test.

The bottleneck is not the learning algorithm. I spent months on consolidation mechanisms and every single one landed on the same line. The two things that worked — on-policy regeneration and compositional diversity — are both properties of where the data comes from. If I get another run at this, it goes entirely into the variation problem: how does a closed loop widen its own distribution of problems, when the only free signal it has is a verifier that tells it whether it was right, and never tells it whether the question was worth asking?

I don’t have that one. Seven years in, that’s the honest state of it.

Everything above is 4B-scale with LoRA r=16 on q/v, in one narrow procedural domain, with n=150 forgetting probes and n=120 held-out splits. The consolidation-unit null is two seeds; the frontier rests on five arms; F4 and F5 are single-seed multi-round. The frontier claim is strongly suggestive, not established. I’ve tried to flag every caveat inline rather than collect them here, but that’s the summary version.