Continual Learning.

TL;DR. Continual (or lifelong) learning means a deployed model keeps absorbing new data and new tasks after training ends, instead of being frozen at its last checkpoint. The hard part is not learning the new thing — it is learning it without overwriting the old one, a failure mode called catastrophic forgetting.

A model trained once and then frozen knows only the world as it was at its last checkpoint. Continual learning — also called lifelong learning — treats training as an ongoing process: the model keeps absorbing new data, new tasks, and new user behaviour after deployment, updating its weights incrementally rather than being rebuilt from scratch. The difference is structural. A one-shot model can only improve when a team schedules a new training run; a continual model improves as a matter of course, checkpoint by checkpoint.

The central risk is catastrophic forgetting: when a network is trained on a new task, gradient updates can overwrite the weights that encoded earlier skills, so performance on old tasks collapses (McCloskey & Cohen, 1989). Modern continual-learning methods protect those weights while still leaving room for new learning. Elastic Weight Consolidation (EWC), for example, estimates how important each weight was for previous tasks and penalises changes to the important ones, so the network learns new tasks while old behaviour stays intact (Kirkpatrick et al., 2017).

We organise the field around three mechanisms rather than one algorithm. Continual pretraining extends a foundation model's training data after the initial run, so its world knowledge stays current. Adaptive fine-tuning re-tunes a model on recent, high-signal task data in small, scheduled increments. Knowledge refresh updates what the model knows — through retrieval indexes, edited memory, or targeted parameter updates — without a full training cycle. Each mechanism trades off freshness, cost, and forgetting risk differently, which is exactly what our research agenda is built around.

TL;DR. The world moves after you ship: input distributions shift, new facts arrive, and user expectations change. Full retraining from scratch is too slow and too expensive to be the only answer, so staying current has to be engineered into the model itself.

Every production model sits downstream of a changing world. Users change how they phrase requests, interfaces change, and the distribution of real inputs drifts away from the training data — a process known as data shift. A model that cannot adapt accumulates silent errors: it keeps answering confidently while the ground it was trained on moves. Continual learning attacks that decay directly, by letting the model track the distribution it actually serves.

The traditional remedy — full retraining — is expensive and slow. Frontier-scale runs cost real money in compute, and each run produces a point-in-time snapshot that starts going stale the moment it ships. Incremental updates are cheaper per unit of new knowledge, can be scheduled far more often, and can be evaluated and gated individually, so a bad update is caught before it reaches users.

Production models also go stale in subtler ways: they miss new terminology, new APIs, new product lines, and new facts that users assume the system knows. A model that cannot refresh its knowledge quietly becomes less useful, and users notice the gap long before dashboards do. Keeping a deployed model current is an operational requirement, not a research luxury.

TL;DR. We build models whose training does not stop at deployment: continual pretraining extends world knowledge, adaptive fine-tuning tracks task behaviour, and knowledge refresh keeps retrieved context current. Every update — however small — ships only after the eval suite confirms it did not break what already worked.

Our research agenda states it plainly: models that keep improving after deployment — continual pretraining, adaptive fine-tuning, and knowledge refresh without catastrophic forgetting. That sentence is a checklist. Continual pretraining schedules incremental data updates on top of an existing checkpoint, instead of one expensive run per model version. Adaptive fine-tuning re-tunes the model against recent, high-signal task data on a regular cadence. Knowledge refresh keeps the retrieval layer — indexes, memories, tool documentation — aligned with the world the model actually answers about.

The discipline is in the gate, not the update. Every increment — a pretraining step, a fine-tune, a refreshed index — runs through our eval suite before it ships: regression checks that old skills still work, behavioural checks that the new material was actually learned, and forgetting checks that compare post-update performance on held-out earlier tasks. An update that improves the new task but regresses an old one does not ship. That is the practical meaning of "without catastrophic forgetting" in our lab: forgetting is measured, not assumed away.

Self-Improving Agents · Self-Maintaining Systems · Eval-Driven Development · Model Optimization · What We Mean by Self-Improving Systems · The Eval-Driven Development Loop

Start a Mission Last updated: 13 August 2026