A Case for Continual Learning

Today's language models can look like they learn. They carry memory across sessions, and context windows have grown long enough that a good harness can hold an entire project in front of the model and adjust how it behaves as the work goes on. Underneath, nothing moves. The weights are fixed when training ends and stay fixed through deployment, so everything the model takes in afterward sits outside them, in the context window. Chat history, retrieved documents, web searches, and system instructions are loaded in front of the model rather than absorbed into it. These systems can remember and adapt without the model ever learning anything new.

Continual learning is one approach to these limitations, and we believe it is necessary for something the current regime cannot deliver: a system that becomes better than its training rather than one that replays it. The everyday version is an agent that improves at its task over weeks the way a competent employee does. The harder version is tacit skill: knowledge that does not reduce cleanly to text and cannot simply be reloaded into a context window. The highest-value version is discovery, where the system improves from new cases rather than only recombining what its training distribution already contains. All three require the same mechanism: compression of new experience into the weights, online, after deployment.

The current regime of in-context learning and retrieval works today, and it will scale further until it meets the physical limits of hardware and memory bandwidth. We do not dispute that, but our claim is narrower. Storing information in a context window and retrieving it on demand is not the same operation as compressing it into parameters, and the second is what learning is. The first extends how much a frozen model can hold in front of it. It does not change what the model is.

Continual learning carries its own limitations and risks, and we address them directly in this essay. The largest is that a frozen model is auditable in a way a self-updating one is not. The boundary we are arguing to remove is also a safety property. Any honest case for continual learning has to pay that cost, and we do.

Where Learning Lives

"Continual learning" gets used for several different things, and not all of them are technically learning, though they work. We cluster the space into five levels, ordered by where new information goes and whether it persists.

Exhibit 1. Five levels of learning, by where the change lives

Level	Where the change lives	Parametric	Example methods	Continual learning?
1 · In-context	Context window / activations	No	System prompt, few-shot, chain-of-thought	No
2 · Memory & retrieval	External store	No	RAG, memory files, AlphaEvolve, Darwin Gödel Machine	No
3 · Adapter-based	Module beside base weights	Yes	Adapters, LoRA	Boundary — floor if loop is tight
4 · Sparse parametric	Subset of base weights	Yes	Knowledge editing (ROME/MEMIT), Sparse-memory FT	Yes, once loop closes
5 · Dense weight-level	Base weights	Yes	Test-time training; STaR, AlphaProof, SEAL	Yes — full form

The lowest level is in-context learning. The model's behaviour is shaped by the system prompt, sometimes with few-shot examples. No weights change. The learning lives in the activations and dies when the context is cleared. Longer context windows have let us stuff more into that window, and some researchers have asked whether in-context learning alone is enough.

The second level is external memory and retrieval. The store can be a database, a set of markdown files, or a vector index. As in level one, learning here is non-parametric. The recent interest in "context engineering" is exactly this: give the model the right context at the right time. It works well in practice, and arguably better than it should.

The third level is modular, adapter-based learning. LoRA and similar methods add a small trainable component to the base model while leaving the original weights frozen. The update is still parametric, but it lives beside the base model rather than inside it. That isolation usually reduces catastrophic forgetting relative to full fine-tuning, because the base weights are not directly rewritten, but it does not remove the problem. Recent work shows the protection is partial and context-dependent. We return to the numbers below. Most level-three adaptation today is still trained offline on a batch, though nothing in the substrate requires that. That distinction matters once we separate where a change lives from when it happens.

The fourth level is sparse parametric updating. A subset of the base model's own weights changes, and the subset is chosen deliberately so that existing knowledge is not disturbed. This is intuitive to state and hard to do, because knowledge is not stored in identifiable weights. Features sit in superposition, packed as overlapping directions across many neurons, so there is no clean set of parameters that encodes one fact and nothing else. "Update only what is relevant" assumes a separability the network does not provide. The live methods therefore do not find the fact's true address inside the dense model; they create an addressable surface where the update can land.

The fifth level is dense weight-level learning, where the base weights themselves move in response to new experience. This is the deepest substrate, closest to how the brain learns, and the least feasible today given the size of frontier models and the poor sample efficiency of current methods. It also splits on a property the lower levels do not force: persistence. Test-time training moves the base weights at inference and is a level-five mechanism, but it adapts per task and resets, so it reaches level-five depth without level-five permanence. Fully persistent dense online updating, the thing humans do without noticing and no shipped model does, is the top of the ladder and remains unbuilt at scale.

The level number says where a change lives: in the context, in an external store, in an added module, in sparse base weights, or in dense base weights. It does not say whether the change is learned online from the model's own deployment experience or assembled offline by a human and shipped. That is the separate test from the introduction, and it runs alongside the parametric levels rather than ordering them. A hand-curated adapter is level-three substrate with an open loop, so it is adaptation, not continual learning. AlphaProof updates a base model online from its own verified attempts, closing the loop at level-three-to-five depth, so it qualifies. The two questions are independent, and continual learning in our sense needs both: the change has to live in the parameters, and the loop has to close online.

The two conditions exclude different things. Online closure rules out a hand-curated adapter trained once: it compresses into parameters, but offline, assembled and shipped by a human. A coding agent that appends to a memory file and reads it back next turn has closed the loop online with no human in the middle, and it is still level two, because the model is unchanged and the store grows without bound. The same exclusion catches systems far more capable than a memory file. AlphaEvolve, a frozen model wrapped in evolutionary search, produces genuinely new algorithms, and the Darwin Gödel Machine rewrites its own code to improve at a software-engineering benchmark, both with their weights never changing. Both close the loop and produce real novelty, and both compound into artifacts rather than parameters, so both sit at level two on substrate however sophisticated they look. They are the strongest evidence that the substitute lane runs a long way, and we return to them in the case for the thesis.

Levels four and five meet both conditions once their loop is closed: they compress deployment experience into the base parameters, online. Level three sits on the boundary. A pipeline that buffers experience, retrains an adapter, and hot-swaps it on a tight automated cycle approaches both conditions, while the batch latency keeps it short of true online compression and the knowledge stays in a bolted-on module rather than the base weights. We treat tight automated level three as the floor of continual learning and the closed-loop parametric methods at levels four and five as its full form. The full form already exists in narrow domains: STaR fine-tunes a model on its own correct reasoning and repeats, and AlphaProof, above, does the parametric version with verified proofs. Our claim is about what the lower levels cannot reach. They retrieve an ever-longer record of the work. They do not improve at the work itself.

The Engineering of Continual Learning

Continual learning has been hard because the weights are entangled. Moving them to absorb one thing has repercussions for everything else. McCloskey and Cohen named this catastrophic interference in 1989. The trainable parameters are shared across every task the model performs, so a network plastic enough to learn something new overwrites the representations holding old capability. An update aimed at one thing lands on everything. That is the stability-plasticity dilemma, and it is one of the reasons weights ship frozen. Compression and forgetting are one process seen from two sides, a point a recent Princeton and Cohere paper makes under the title "Learning is Forgetting: LLM Training As Lossy Compression": pretraining drives a model toward optimal lossy compression, which by definition discards.

Exhibit 2. Five ways to move a model without breaking it

Stay close to the base

Penalize or blend so the update barely moves the model

Keep the updated weights near where training left them

• EWC (2017)
• Weight interp. (2024)
• RL's Razor (2025)
• SDFT (2026)

Update locally

Touch only the weights a new fact needs

Create an addressable surface so the rest stays still

• Sparse-memory FT (2025)
• Knowledge editing

Learn at test time

Take gradient steps on the input at inference

Adapt to the problem in front of you, then answer

• TTT (2020)
• TTT layers
• TTT-E2E
• TTT-Discover

Make your own data

Generate attempts, keep what a check passes, train on them

Close the loop and compound it into the weights

• STaR (2022)
• SEAL (2025)
• AlphaProof (2024)

Search a frozen model

An outer loop finds novelty; the weights never change

Real discovery, but it lands in an artifact, not the model

• AlphaEvolve (2025)
• Darwin Gödel Machine

The methods that work share one instinct. To move the weights without wrecking them, keep the updated model close to the one you started with. Forgetting scales with how far an update drags the model from its base, so the natural inclination is to drag it less. There are three handles on that distance. Elastic Weight Consolidation (Kirkpatrick et al., 2017) estimates which weights mattered most for the old task, then adds a penalty when fine-tuning moves those weights too far from their original values. Self-distillation fine-tuning samples the model's own responses and trains it to match a stronger version of itself — the same model conditioned on a worked example — so the target never leaves the distribution the model already speaks and the parameters barely have to shift (Shenfeld et al., MIT, 2026). RL's Razor (Shenfeld, Pari, and Agrawal, MIT, 2025) makes the same point from the reinforcement-learning side: when both methods reach the same accuracy on the new task, on-policy reinforcement learning forgets less than supervised fine-tuning. Forgetting tracks the KL divergence between the updated and base policy on the new task, in a roughly quadratic relationship. On-policy methods sample from the model's own distribution and therefore stay biased toward solutions near the base, while offline supervised fine-tuning can move much farther. The paper's toy experiment makes the point as well: when supervised fine-tuning is trained on labels chosen to minimise KL from the base policy, it retains more than RL itself. The methods differ in implementation, but they all manage the same variable: how far the update moves the model from the base.

Self-distillation and the on-policy bias meet in on-policy distillation, where the student generates its own trajectories and a teacher grades them token by token: the on-policy sampling holds the update near the base, while the dense per-token signal carries more than a single reward and needs no external verifier (Agarwal et al., 2023). Its sharpest use for continual learning lets the model be its own teacher, conditioned on the context it built up over a long session, and compresses that in-session skill back into the weights — the move that turns what a frozen model can only hold in front of it into something it keeps (Shenfeld et al., MIT, 2026). One lab write-up reports that adding on-policy distillation restored an eight-billion-parameter model's instruction-following to 83 percent, against an 85 percent baseline that domain fine-tuning had eroded, while its grasp of the new material held — an industry result, not yet refereed (Lu, Thinking Machines Lab, 2025).

The second instinct is to update locally. If you can touch only the weights a new fact needs and leave the rest still, you sidestep entanglement instead of fighting it. The difficulty is that knowledge has no specific address. Features sit in superposition, packed as overlapping directions across many neurons, so there is no clean set of parameters that holds one fact and nothing else. Sparse memory fine-tuning (Lin et al., Meta, 2025) gets around this by giving the network addressable storage. It swaps a feed-forward layer for a large memory pool and updates only the slots a new fact activates most, measured against their usage on pretraining data. On a 1.3 billion parameter model taught a stream of new facts and then tested on an unrelated benchmark it never trained on, full fine-tuning cut the held-out score by 89 percent and LoRA by 71 percent. Sparse memory fine-tuning cut the loss to 11 percent at the same level of new knowledge. The same paper found that, for this sparse method, plain SGD forgot less than AdamW, because Adam's per-parameter step sizes interact badly with sparsity.

Both instincts so far run offline, on a batch a human assembles. The harder problem is learning during deployment, without a clean training set prepared in advance. The closest working version is test-time training: part of the model adapts by gradient steps on the input itself, at inference, before it answers. The best causal evidence is a controlled MIT study (Akyürek et al., 2025) that isolated the effect and found test-time training improved accuracy on the ARC reasoning benchmark by up to six times over the same model fine-tuned without it, reaching 53 percent on the public set with an 8-billion-parameter model and 61.9 percent ensembled, level with the average human. Similar improvements were achieved on BIG-Bench Hard where the same technique beat standard ten-shot prompting by 7.3 points, the model extracting more from identical examples by adjusting its weights to them instead of only reading them. The competition-scale version appeared in the 2024 ARC Prize, where test-time training carried the private-set score from 33 percent at the end of 2023 into the mid-fifties and all the top approaches used some form of it, while GPT-4o and Claude 3.5 Sonnet prompted directly scored between 5 and 14 percent. On ARC-AGI, changing the model during inference worked in a way prompting alone did not. But test-time training adapts per task and resets, so it reaches the depth of weight-level learning without the permanence.

Test-time training still starts with a task supplied from outside. The next step is a system that can produce its own training data: generate attempts, keep the ones that pass a check, and learn from them without a human-labeled batch. Where the learning lands is the thing to watch. SEAL (MIT, 2025) and AlphaProof (DeepMind, 2024) compound it into the weights. SEAL writes its own self-edits, directives for what to train on and how, applies them as real updates, and runs an outer reinforcement-learning loop that learns which edits help. AlphaProof proves statements in Lean, reinforces its parameters with every verified proof, and for hard problems generates hundreds of thousands of variations at inference to update its weights for that one problem, reaching silver-medal standard at the 2024 International Mathematical Olympiad. AlphaEvolve and the Darwin Gödel Machine close the same loop and keep their models frozen. AlphaEvolve's algorithmic gains, which we detail in the case for the thesis, accumulated in an external program archive while its weights never moved. The Darwin Gödel Machine rewrote its own code to lift a software-engineering score from 20 to 50 percent, also frozen. These are the strongest demonstrations that a closed loop produces real novelty, and the strongest reminder that closing the loop and compressing into weights are different things: two of the four learn nothing the model carries to the next task. The two that do compound into the weights run into the older problem. SEAL's own continual-learning experiment shows that under repeated self-edits, catastrophic forgetting returns. Compounding into the parameters is necessary and not sufficient, and making it last without erasing the past is unsolved.

Updating the weights is not the same as breaking the model. Forgetting tracks how far the update moves the model from its base, and several methods now keep that distance small in the lab, on single updates, at a few billion parameters. That weakens the strongest objection to continual learning: that changing the model necessarily corrupts what it already knows. The open question is whether the same control survives repeated updates at frontier scale.

Continual pretraining recipes refresh a deployed model with learning-rate re-warming and a thin slice of replayed old data, matching a from-scratch retrain on the new distribution at a fraction of the compute (Ibrahim et al., 2024), and this is the version closest to production today. Memory-layer localisation, the method behind the 11 percent result, has obvious headroom: the memory pool scales, and the open question is whether selective updating still isolates the damage at a hundred times the parameters. Modular approaches attack the entanglement at its root, replacing one shared model with an orchestrated set of specialists so an update lands on one component and leaves the rest untouched by construction. And the optimiser itself is in play, because two independent findings, the KL bias of on-policy RL and the result that plain SGD forgets less than Adam, both say the optimisers built for one-shot training are the wrong tools for a model that never stops training.

None of this is solved, and persistent continual learning at frontier scale has not been built. But the case against it has changed. The remaining question is whether the controls that work on single updates at small scale still work when the model learns continuously at frontier scale.

Why We Need Continual Learning

The usual case for continual learning is made on practicality. An assistant that remembers your preferences, or an agent that stops repeating yesterday's mistakes, is better. The deeper reason to want continual learning is capability itself. A model with frozen weights is bounded by its training. It can recombine what it absorbed and it cannot exceed it. Exceeding it is what discovery means, and discovery is the part of intelligence that matters most and the part a frozen model structurally cannot reach. We believe that continual learning is necessary for a system that becomes better than its training, rather than one that replays it.

Start with the argument that has aged best. Richard Sutton's bitter lesson, from 2019, holds that the approaches that win are the ones that keep scaling with compute, and that two methods scale arbitrarily, search and learning. The hand-built human knowledge always plateaus. Pretraining is learning, and it is learning that halts at deployment. A model whose weights freeze when it ships has stopped applying the second scalable method to anything it meets afterward. Sutton has since drawn the conclusion himself. In 2025 he argues that today's models violate his own lesson, because imitating human text bakes in human knowledge and runs into a data ceiling, and that the scalable path is experiential learning that never stops: the system tries things, sees what works, and keeps the result, with no one supplying the ground truth. Read forward, the bitter lesson points to continual learning. The method that keeps leveraging compute is the one that keeps learning.

David Silver and Richard Sutton, in "Welcome to the Era of Experience" (April 2025), argue that learning from human data caps a model at human competence, because the model cannot hold knowledge its data does not contain. The discoveries that matter, a new theorem or a faster algorithm, are by definition absent from every human corpus, so no quantity of human data reaches them. What reaches them is experience. The systems that have produced genuine novelty did it by generating their own attempts against a grounded signal and folding the result back into their weights. AlphaGo's move 37 in 2016 was a play no human game contained. AlphaDev found a faster sorting routine in 2023. AlphaProof reached silver-medal standard at the 2024 International Mathematical Olympiad by reinforcing its parameters with every verified proof. Each ran a closed loop that compounded into itself, and each ended past the knowledge it began with. Capability beyond the training distribution has happened, and in every case it came from a system learning on its own experience.

The mechanism underneath is exploration. A frozen model, even one polished with reinforcement learning, mostly exploits what it already has. The best example is Yue et al., a NeurIPS 2025 paper that asked whether reinforcement learning with verifiable rewards expands a model's reasoning or only sharpens it. At one attempt the RL-tuned model wins, but given many attempts the base model solves more distinct problems, and RL training narrows the model's range by lowering the entropy of its outputs. It makes exploration tractable, because the model's guesses are sensible, and it bounds exploration, because a guess far from it is usually nonsense. Expanding capability needs a ratchet: explore, find something a check confirms, compress it into the weights, then explore again from the higher floor. This ratchet is a precondition for recursive self-improvement and not the same thing, because it raises skill at the task without raising the rate at which skill is acquired. The compression step is the one a frozen model skips, and without it exploration never accumulates. The model sharpens the same prior forever. This is also the mundane version of the argument. An employee in month six is better than in month one because the work changed her. A frozen model in month six is the model from month one, sharpened.

The strongest form of the case is coverage: the useful work is not the individual skill, but the combination of skills. A model with skill A and skill B should handle the composition of the two, but the number of possible compositions grows exponentially, so the long tail is larger than any training set can hold. Either the model generalises compositionally on its own, which it does not do reliably, or it learns the combinations as it encounters them, which is continual learning. Pretraining cannot cover the space, because the space is combinatorial.

AlphaEvolve shows both the power and the boundary of this approach. A frozen Gemini model, wrapped in evolutionary search, has produced real novelty: a 4×4 complex matrix-multiplication algorithm using 48 scalar multiplications instead of Strassen's 49, gains on 14 matrix-multiplication targets, and a scheduling heuristic that recovered 0.7 percent of Google's worldwide compute for more than a year. But these results come from domains with cheap, exact checks. Multiply the decomposition and see if it works. Measure the packing density. Benchmark the kernel. When the verifier gives a clean answer, search around a frozen model can find things humans missed.

RL scales best when the task has a verifier. That is right, but incomplete. OpenAI's deliberative alignment built a safety reward signal without mechanical ground truth by writing a specification and training a reward model to score completions against it. Rubrics and LLM judges do the same for open-ended work: they turn judgment into something the training loop can optimise. The limit is that a judge is not a proof. Push hard enough and the model learns what the judge rewards, not what was meant. Exact verifiers give clean compounding; learned judges work but leak; some tasks cannot be specified well enough to train against. AlphaEvolve sits at the clean end. Most of the economy does not. The human work moves upstream, from solving the task to building and policing the verifier.

A fair question is whether the continuous RL post-training the labs already run is continual learning. It updates the weights, so it clears the compression bar. It fails the other one. The loop runs through the lab: humans assemble the prompts, build the reward model, run the job, and ship the next checkpoint. The model is not yet learning from its own deployment experience with no human in the batch. It is being retrained on a human cadence, faster and cheaper than before. By the two axes of the ladder that is offline parametric learning with an open loop, the strongest substitute and still a substitute.

The standing objection to continual learning is that substitutes will close the gap. Longer context and persistent memory may let a frozen model carry more information forward and behave as if it has learned. They will improve in-context learning, recall past interactions, and make the system better at using its own history. But they do not compress that history into the weights. The model takes better notes; it does not become better at the task in the same sense.

It is our belief that continual learning is necessary for capability growth, for a system that exceeds its training. Where an automatic verifier exists, the gains can already be found, and the task is to compound them into the model so it improves, rather than producing an artifact and resetting. Where no verifier exists, which is most of the work an economy runs on, continual learning is the only mechanism that could reach novelty at all. The engineering section showed that the weights can move without breaking the model. This section is the reason it matters that they can.