Continual learning did not solve forgetting for free. It made the costs visible.

Catastrophic forgetting is what happens when a network trained sequentially on multiple tasks loses earlier skill because weights that mattered for task A are changed to meet the objectives of task B (Kirkpatrick et al., PNAS 114(13):3521-3526, 2017, who cite McCloskey and Cohen, 1989, and French, 1999, among others, for the phenomenon). Continual learning is the research program that tries to train on a stream of tasks without that collapse and without retraining from scratch.

The program made forgetting a number, and produced three families of partial remedies whose costs their own authors state. Kemker et al. (AAAI 2018) compared five mitigation families on real images and sounds and concluded that "the catastrophic forgetting problem has yet to be solved". What follows is the cost sheet: foundational methods from 2016 to 2019, not a current survey. The stability-plasticity framing belongs to self-organizing memory systems.

TL;DR

• On split MNIST under class-incremental learning, EWC scores 20.01 (±0.06) against 19.90 (±0.02) for doing nothing, a gap of 0.11 percentage points, while replay methods clear 91. The figures come from one 2019 preprint, MNIST only.
• None of these methods closed the problem without a cost its own paper names, and the 2018 study that compared five mitigation families concluded nobody had. The costs, by family: underestimated parameter uncertainty, a stored subset of past data, or parameter growth plus a task label at inference.
• GEM, A-GEM and iCaRL all keep discrete stored examples, but only iCaRL's K and GEM's M memory locations are a fixed total budget; A-GEM's reported experiments size the memory per task, so its total grows with the number of tasks. That half of the literature maps onto an external record store; the weight-protection half does not.
• "Our memory does not forget" is not a claim until it is a measurement over an ordered sequence, with a stated assumption about what the system is told at read time.

What Elastic Weight Consolidation actually does

Elastic Weight Consolidation is a regularization method that adds a quadratic penalty pulling each weight back toward its value after the previous task, scaled by how important that weight was, estimated as the diagonal of the Fisher information matrix.

After task A, "All the information about task A must therefore have been absorbed into the posterior distribution p(θ|D_A)." That posterior is intractable, so, following MacKay's Laplace approximation, it becomes a Gaussian with diagonal precision from the diagonal Fisher. Equation (3):

L(θ) = L_B(θ) + Σ_i (λ/2) F_i (θ_i − θ*_{A,i})²

The Fisher is recomputed at each task switch: the switch is the trigger. Task identity came from a separate component, a hidden Markov model over task context whose procedure for adding new generative models was inspired by the forget me not process of Milan, Veness, Kirkpatrick, Bowling, Koop and Hassabis (NIPS 2016).

The authors state the ceiling. EWC "does not reach the score that would have been obtained by training ten separate DQNs", and they say "it is therefore likely that the chief limitation of the current implementation is that it under-estimates parameter uncertainty". Huszár then showed the quadratic penalties "might lead to double-counting data from earlier tasks" (preprint, 2017; letter in PNAS, 2018), and Kirkpatrick et al. conceded that "He correctly argues that in cases when more than two tasks are undertaken the two forms of the penalty are different" and that "our paper failed to discuss this explicitly". Their explanation for why the penalty still works was offered as conjecture, not as a result.

Zenke, Poole and Ganguli (ICML 2017) change the estimator: Synaptic Intelligence accumulates importance along the whole trajectory, and Equation (4) is undefined without Equation (5):

L̃_μ = L_μ + c Σ_k Ω_k^μ (θ̃_k − θ_k)²
Ω_k^μ = Σ_{ν<μ} [ ω_k^ν / ((Δ_k^ν)² + ξ) ]

SI is a structural regularizer. Its paper also names a cost of EWC's estimator: the exact diagonal Fisher "requires summing over all possible output labels", limiting it to low-dimensional outputs.

Gradient Episodic Memory and A-GEM: constraints instead of penalties

Gradient Episodic Memory is a continual-learning method that stores a small episodic memory of past examples and treats their loss as an inequality constraint on the current gradient step, avoiding an increase in past-task loss but allowing a decrease, to first order.

Lopez-Paz and Ranzato (NIPS 2017) also defined three metrics: average accuracy, forward transfer, and, with R_{i,j} the test accuracy on task t_j after the last sample of task t_i, their Eq. 3:

BWT = (1/(T−1)) Σ_{i=1}^{T−1} (R_{T,i} − R_{i,i})

"Large negative backward transfer is also known as (catastrophic) forgetting." Forgetting is a measurement, not a mood.

Past-task losses act "as inequality constraints, avoiding their increase but allowing their decrease": the current gradient g must satisfy ⟨g, g_k⟩ ≥ 0 for every past task k, and when it does not, g is projected. The angle test is the linearized constraint, adopted "assuming that the function is locally linear (as it happens around small optimization steps)"; a step that passes it "is unlikely to increase the loss at previous tasks".

The projection is a quadratic program; GEM solves its dual, "a QP on t−1 ≪ p variables", not the primal over parameters. A-GEM (Chaudhry et al., ICLR 2019) replaces the t−1 constraints with one constraint over the union of the past-task memories, and projects only "when the gradient g violates the constraint":

if gᵀ g_ref ≥ 0:    g̃ = g
else:               g̃ = g − (gᵀ g_ref / g_refᵀ g_ref) g_ref      (Eq. 11)

GEM has the stronger guarantee on each individual task, forbidding any task-specific loss on the memory examples from rising; A-GEM has the stronger guarantee on average accuracy, because GEM can block a step over one task's constraint even when the average loss would have fallen. Those are guarantees, not measurements. A-GEM reports "the best average accuracy on all datasets, except Permuted MNIST, where prog-nn works better", and on that exception its own Table 4 puts GEM at 89.5 (±0.48) beside A-GEM's 89.1 (±0.14), inside GEM's error bar. A protocol-specific comparison, not a universal ranking.

iCaRL and the bounded exemplar budget

Class-incremental learning is the setting where a model must solve every task seen so far and also infer which task it has been given, with no task identity supplied at test time. iCaRL demands that an algorithm's computational requirements and memory footprint "remain bounded, or at least grow very slowly, with respect to the number of classes seen so far", ruling out storing everything and retraining.

Rebuffi, Kolesnikov, Sperl and Lampert (CVPR 2017) meet those demands with "classification by a nearest-mean-of-exemplars rule", "prioritized exemplar selection based on herding", and "representation learning using knowledge distillation and prototype rehearsal" (rule: their Eq. 2):

y* = argmin_{y=1,…,t} ‖φ(x) − μ_y‖,   μ_y = (1/|P_y|) Σ_{p∈P_y} φ(p)

Herding fills those sets: examples are added one at a time, each chosen to keep the running average of the stored features close to the mean feature vector of all that class's training images, which leaves the set ordered by priority. That order is what lets ReduceExemplarSet trim an old set later without the original data.

The budget itself: "when t classes have been observed so far and K is the total number of exemplars that can be stored, iCaRL will use m = K/t exemplars (up to rounding) for each class", so "the available memory budget of K exemplars is always used to full extent, but never exceeded".

fixed total budget K
after 10 classes:   m = K/10 exemplars per class
after 20 classes:   ReduceExemplarSet on old classes, then m = K/20
after 100 classes:  ReduceExemplarSet on old classes, then m = K/100

Algorithm 2 runs ReduceExemplarSet on every old class before ConstructExemplarSet on the new ones. Across a different axis, classes per increment: on iCIFAR-100 with K = 2000, iCaRL reaches 57.0, 61.2, 64.1, 67.2 and 68.6 average incremental accuracy, the paper's average over every evaluation point, for increments of 2, 5, 10, 20 and 50 classes. The 68.6 printed alongside is a different quantity, one 100-way accuracy for "the same network trained with all data available", so read the row for its slope rather than for a tie: the finer the increment, the lower the average.

Progressive Neural Networks: immunity by construction

Rusu et al. (arXiv:1606.04671, 2016, a preprint with no venue) freeze every previous column and add a new one per task. "Because also the parameters {Θ^(j); j < k} are kept frozen (i.e. are constants for the optimizer) when training Θ^(k), there is no interference between tasks and hence no catastrophic forgetting." The authors name two costs: parameters grow with the number of tasks, with "only a fraction of the new capacity" used, and "choosing which column to use for inference requires knowledge of the task label". They call the approach "a stepping stone towards a full continual learning agent". Immunity does not buy transfer: across twelve Atari targets, "progressive nets result in positive transfer in 8 out of 12 target tasks, with only two cases of negative transfer".

Three scenarios: why two continual learning numbers rarely compare

van de Ven and Tolias, "Three scenarios for continual learning" (arXiv:1904.07734, 2019), is a preprint, an extended version of a NeurIPS 2018 workshop paper, never journal-published, and not the 2022 Nature Machine Intelligence paper by van de Ven, Tuytelaars and Tolias. Table 1 splits the field by test-time requirement:

Scenario	Required at test time
Task-IL	Solve tasks so far, task-ID provided
Domain-IL	Solve tasks so far, task-ID not provided
Class-IL	Solve tasks so far and infer task-ID

The emphasis on and is the paper's. Its Class-IL columns, each a mean over 20 random seeds with SEM:

method	split MNIST, Class-IL	permuted MNIST, Class-IL
None (lower bound)	19.90 (±0.02)	17.26 (±0.19)
EWC	20.01 (±0.06)	25.04 (±0.50)
Online EWC	19.96 (±0.07)	33.88 (±0.49)
SI	19.99 (±0.06)	29.31 (±0.62)
DGR + distill	91.79 (±0.32)	96.38 (±0.03)
iCaRL	94.57 (±0.11)	94.85 (±0.03)
Offline (upper bound)	97.94 (±0.03)	97.59 (±0.02)

On split MNIST under Class-IL, in this 2019 preprint whose experiments use the split and permuted MNIST protocols only, EWC scores 20.01 against 19.90 for doing nothing: a gap of 0.11 percentage points. The abstract states that "when task identity must be inferred (i.e., class incremental learning)", the authors "find that regularization-based approaches (e.g., elastic weight consolidation) fail and that replaying representations of previous experiences seems required for solving this scenario", while the Discussion notes that "MNIST-images are relatively easy to generate". Quoting "EWC fails" without that scope overclaims on the authors' behalf.

The paper's other contribution is a warning: "even when studies use exactly the same sequence of tasks to be learned (i.e., the same task protocol), results are not necessarily comparable", because protocols differ in what the model is told at test time.

Where the agent-memory analogy holds, and where it breaks

What follows is a design analogy, not a claim that these papers evaluated an agent-memory service. By external memory this section means a store of independent records behind a fixed embedding and retrieval pipeline, where a write inserts, edits, supersedes or evicts one record rather than taking a gradient step.

Where it holds

Rehearsal on a stored subset. GEM and A-GEM keep past examples for training; iCaRL keeps real exemplar images and uses them twice. These are discrete stored records, not weights. The records in GEM exist to police a gradient. In an agent's store they are the thing being kept.

A bounded budget forces a selection policy. iCaRL's fixed K, plus the reduce-before-add order that holds it, is a curation loop, not a coefficient. The Progressive Networks authors point the same way.

Importance weighting as a principle. Protect what has proven useful and let the rest go. The principle transfers, the estimator does not. The association-side analogue is Hebbian memory, where concepts recalled together strengthen their association, with a prediction-error update on feedback. The unit is concepts for the edge, a memory for the valence update.

Where it breaks

Addressing, not the absence of learning. Every method above defends one set of shared parameters against the next update, by penalty, by constrained step direction, by freezing, or, in iCaRL, by rehearsing stored exemplars and distilling the old network's outputs. In an external memory as defined above, a feedback update moves one record's valence and strengthens the edges between the concepts involved, so it cannot rewrite what another record is made of the way an SGD step for task B rewrites the weights task A depended on. The concept graph is shared, though, and an edge that moves changes what surfaces for every record carrying that concept: a narrower kind of interference, not an absence of it.

Retrieval interference is a separate risk, and it is real. Records that do not overwrite each other still compete at read time: a new record can crowd an old one out of a ranked result without anything being overwritten. Measure it separately.

Task boundaries. The three-scenario vocabulary is scoped by its authors to clear training-time boundaries, which an agent's query stream does not supply.

Growth is the default. A record store already grows with content, so "add capacity instead of overwriting" is not news; iCaRL's bounded half is the interesting one.

What "forgetting" names. Here it is a side effect of learning something else; in a record store it is a deliberate operation, the subject of why agents need to forget. "Consolidation" divides the same way: EWC consolidates weights against the next gradient step, while agent memory consolidation is an offline phase that replays and abstracts accumulated raw writes into reusable structure. The first is a training-time remedy for the forgetting described here, not a mechanism a record store inherits.

Builder's implications

Decide whether retention means holding the average or protecting each important category: a pooled score can conceal damage to a rare but consequential memory. Then measure: backward transfer gives the shape, re-testing earlier items after later ones. It has not been applied, in the sources this article uses, to an agent memory system, so what follows is a proposed protocol, not a reported result.

1. Write one session's knowledge and score it on fixed checks.
2. Add later sessions under a declared storage budget.
3. Re-run the earlier checks with unchanged scoring rules.
4. Declare what the reader is told at read time: which user, which session, which namespace.
5. Separate deliberate deletion from retrieval failure, and inspect per-session change next to the average.

Two runs that disagree on step 4 are not comparable.

Common questions

What is catastrophic forgetting in neural networks?

Catastrophic forgetting is what happens when a network trained on a new task loses what it could do before. The EWC paper states the mechanism directly: it occurs when a network is trained sequentially on multiple tasks, because weights that were important for task A are changed to meet the objectives of task B.

What is Elastic Weight Consolidation (EWC)?

EWC is a regularization method that adds a quadratic penalty pulling each weight back toward its value after the previous task, scaled by how important that weight was, estimated as the diagonal of the Fisher information matrix. The Fisher is recomputed at each task switch.

How is Gradient Episodic Memory different from EWC?

EWC penalizes moving important weights. GEM stores a small set of past examples and treats their loss as an inequality constraint: a gradient step is allowed only if it causes no first-order increase in loss on stored examples, and is projected to the nearest allowed direction when it would. A-GEM replaces GEM's per-task constraints with a single constraint over one pooled memory.

Do continual learning algorithms solve catastrophic forgetting?

No. The EWC authors report their method does not reach the score of training separate networks per game. A 2018 AAAI study comparing five mitigation families concluded the catastrophic forgetting problem has yet to be solved. Progressive Networks avoid forgetting only by freezing old parameters and adding new ones, which costs parameter growth and a task label at inference.

Does continual learning research apply to an AI agent's external memory?

Partly. The rehearsal half applies: GEM, A-GEM and iCaRL all keep discrete stored examples, and iCaRL's fixed exemplar budget is a real model for curating a bounded record store. The weight-protection half mostly does not: records are addressed individually, so a write does not rewrite another record's text, embedding or valence. What records do share is the concept graph, whose edges move with use: a narrower and more contained kind of interference, not an absence of it.

How should you measure whether an agent's memory forgets?

Over an ordered sequence, not a single split. Continual learning defines forgetting as large negative backward transfer, measured by re-testing earlier tasks after later ones. Two studies running the same task sequence are still not comparable unless they share the same assumption about what the system is told at test time.

Sources

• EWC. Kirkpatrick et al., PNAS 114(13):3521-3526, 2017 (DOI); Huszár, PNAS 115(11):E2496-E2497, 2018 (DOI), quotation from the preprint, arXiv:1712.03847, 2017; Kirkpatrick et al., reply to Huszár, PNAS 115(11):E2498, 2018 (DOI).
• Forget-me-not process. Milan, Veness, Kirkpatrick, Bowling, Koop, Hassabis, NIPS 2016.
• Synaptic Intelligence. Zenke, Poole, Ganguli, ICML 2017 (arXiv:1703.04200).
• GEM. Lopez-Paz and Ranzato, NIPS 2017 (arXiv:1706.08840). A-GEM. Chaudhry et al., ICLR 2019 (arXiv:1812.00420).
• iCaRL. Rebuffi et al., CVPR 2017 (arXiv:1611.07725).
• Progressive Neural Networks. Rusu et al., arXiv:1606.04671, 2016. A preprint, no venue.
• Three scenarios. van de Ven and Tolias, arXiv:1904.07734, 2019. Not van de Ven, Tuytelaars and Tolias, "Three types of incremental learning", Nature Machine Intelligence 4(12):1185-1197, 2022.
• The phenomenon, cited here and not quoted. McCloskey and Cohen, Psychology of Learning and Motivation 24:109-165, 1989 (DOI); French, Trends in Cognitive Sciences 3(4):128-135, 1999 (DOI).
• Field status. Kemker, McClure, Abitino, Hayes, Kanan, AAAI 2018 (arXiv:1708.02072).

Related

• Agent memory consolidation
• Self-organizing memory systems
• Hebbian memory for AI agents
• Rescorla-Wagner agent memory
• Why agents need to forget

Written by Edward Izgorodin. Last reviewed 2026-09-20.

— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Plans and limits · Docs: Getting Started