Backpropagation-Free Continual Learning: A Unified Energy-Based Framework, Reproducible Benchmark, and Open Challenges

1. Introduction

How a neural network decides which of its many parameters to change in response to an error, the credit-assignment problem, is the engine of deep learning. For four decades that engine has been backpropagation of error [1], and its dominance has become self-reinforcing: hardware and software have co-evolved around it, an instance of the hardware lottery in which an algorithm prevails in part because it fits the machines available to run it [54]. The brain, however, is the original learning system and the one these models were meant to emulate, and it almost certainly does not implement backpropagation in its literal form [16,55], which has long motivated a search for credit-assignment rules that are local, energy-efficient and biologically tenable. This survey reviews that search and studies, empirically, what it buys us in one concrete arena: learning continually without forgetting.

That dominance is earned: from convolutional networks to transformers [3], the modern era is built on it. But backpropagation carries three structural constraints that the community has come to treat as unavoidable. Backpropagation is global: the gradient of each weight requires a signal propagated from the output back through the entire network. It is memory-intensive: the activations of the forward pass must be stored until the backward pass consumes them. And it separates training from inference. These properties have no clear biological substrate and make data movement, not arithmetic, the dominant energy cost of training, the well-known bottleneck of von Neumann hardware [4].

A long-standing alternative replaces the global backward pass with local learning, driven by the relaxation of an energy function. Predictive coding [7,9], equilibrium propagation [11], contrastive Hebbian learning [10] and, more recently, forward-only schemes all assign credit using quantities available locally at each neuron or synapse. These methods are biologically motivated [8,10] and map naturally onto in-memory and neuromorphic substrates [12]. They are, however, scattered across formulations, notations, benchmarks and codebases, which obscures what is established, what is open, and how the pieces fit together, most of all for continual learning, where catastrophic forgetting remains a central obstacle to deployable AI [20].

We adopt continual learning as the organising lens of this survey for three reasons. First, it stresses precisely the properties backpropagation lacks: a continual learner must update online, without revisiting a stored graph of the past, which is the native regime of local, equilibrium-based methods. Second, energy-based local networks are generative, so they can rehearse the past by sampling their own model rather than storing data, a storage-free analogue of hippocampal replay during sleep [70]. Third, this intersection is where the local-learning literature is currently converging, yet it lacks a unified, reproducible account. The lens thus turns an abstract debate about credit assignment into a concrete, measurable question, can a backpropagation-free network keep learning without forgetting?, that organises the rest of the paper.

1.0.0.1. Scope and contribution.

The manuscript is submitted as a Review. Its centre of gravity is therefore the synthesis of backpropagation-free credit assignment and continual learning, while the experiments serve as a reproducible benchmark embedded in that review. The theoretical material re-derives and numerically checks known energy-based correspondences; the benchmark tests one concrete continual-learning mechanism under controlled conditions; and the hardware and application sections explain why locality matters beyond this small case study. They should not be read as independent claims that the paper solves hardware deployment, modern vision or general artificial intelligence.

This paper is explicitly not a proposal of a new learning rule. Predictive coding, equilibrium propagation and generative replay all predate this work, including combinations of predictive coding with replay for continual and sequential learning [28]. The novelty claimed here is limited and concrete: synthesis, reproducibility and diagnostic benchmarking. We make four contributions, each with a different status:

(C1)

a synthesis contribution: a taxonomy of backpropagation-free credit assignment (Section 2) and continual-learning strategies (Section 3) in a common language;

(C2)

a theoretical/reproducibility contribution: a unified energy-based formulation (LEL) and a numerical re-validation of established results, including Lyapunov descent, the envelope-theorem local update and recovery of backpropagation in the small-nudge limit (Section 4);

(C3)

a reproducible benchmark contribution within the review: a controlled case study of local continual learning, regularization vs. replay vs. generative “dreaming”, across three datasets and two implementations (Section 5Section 6);

(C4)

a negative-results contribution: an explicit account of where the approach fails or remains unproven, especially depth, CIFAR-10, compute cost and projected rather than measured hardware energy (Section 7).

All experiments are released as small, dependency-light scripts to serve as a reproducible entry point. Table 7 maps each experiment to its script and headline finding. The paper should be read as a review-first contribution; the benchmark is used to make the synthesis executable and falsifiable.

Organisation

Section 2 surveys backpropagation-free credit-assignment methods. Section 3 surveys continual-learning strategies and the conceptual boundaries needed to interpret the benchmark. Section 4 states the unified LEL formulation and validates the theoretical correspondences. Section 5 gives the reproducibility contract. Section 6 reports theoretical checks, main empirical results, negative results and diagnostic limitations. Section 7 covers hardware context, representative applications and open challenges. Section 8 concludes.

2. Backpropagation-Free Credit Assignment

Credit assignment without a global backward pass takes several forms. The local alternatives can be organised by how they assign credit, and a key distinction—made precise by classical energy-based analyses [9,11]—is that several of them coincide with backpropagation in a common limit (Section 2.5) while differing sharply in their dynamics and hardware fit. Figure 1 maps the three families; Figure 2 contrasts the two computational styles.

The families surveyed below are not independent inventions but successive answers to one question: how to learn by settling an energy rather than propagating a gradient. Hopfield networks stored patterns as energy minima [60]; Boltzmann machines introduced the clamped-versus-free contrast [59]; predictive coding cast cortical perception as hierarchical error minimisation [7]; and equilibrium propagation made the energy-based gradient local and hardware-realisable [11]. In parallel, the complementary-learning-systems theory explained why fast and slow learning must coexist [70], and modern Hopfield networks showed that their single-step retrieval rule is transformer attention [60], connecting the energy-based programme to contemporary deep learning. The rest of this section organises the same body of work by mechanism rather than by date.

2.1. Predictive Coding

Origins and biological motivation.

Predictive coding (PC) originates in computational neuroscience as a theory of cortical perception. Rao and Ballard proposed that the visual cortex is organised as a hierarchy in which each level maintains a generative model of the level below and continuously predicts its activity; only the residual prediction error, the part of the signal that the model failed to anticipate, is propagated upward [7]. This inverts the classical feedforward picture: feedback connections carry predictions, while feedforward connections carry errors. The framework explained a range of extra-classical receptive-field effects and provided a concrete, neurally grounded account of how cortical microcircuits could perform inference.

The free-energy formulation.

Friston generalised this idea into the free-energy principle, casting perception and learning as the minimisation of a variational free energy that upper-bounds Bayesian surprise [8]. Under Gaussian assumptions the variational free energy reduces to a sum of squared, precision-weighted prediction errors, recovering the Rao–Ballard energy as a special case and embedding it in the language of approximate Bayesian inference. Bogacz provides a step-by-step derivation that makes the framework accessible to a machine-learning audience [8].

Energy, inference and the neural microcircuit.

In the discriminative machine-learning form used throughout this paper (Definition 1), a PC network defines the energy (2) as a sum of layerwise squared errors ${\mathbf{e}}_{\ell }={\mathbf{x}}_{\ell }-f({\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell })$. Inference is not a single forward pass but a relaxation: the hidden states descend the energy until the errors are mutually consistent. A key feature, central to the biological and hardware appeal of PC, is that this computation maps onto an explicit microcircuit with two populations, value (or representation) neurons that hold the states ${\mathbf{x}}_{\ell }$ and error neurons that hold the residuals ${\mathbf{e}}_{\ell }$, connected by synapses that perform the local update of Lemma 1. Both the error and the presynaptic activity needed to change a synapse are physically available at that synapse, so no separate backward pathway is required. Figure 3 shows one such junction.

Relation to backpropagation.

Whittington and Bogacz showed that a PC network with local Hebbian plasticity approximates backpropagation and equals it in a suitable limit [9]; we formalise and numerically validate this correspondence in Theorem 2. Song et al. identified a “prospective configuration” regime in which inference-then-learning can outperform gradient descent by settling neurons to their post-learning state before any weight update [10]. Incremental and parallel variants reduce the relaxation cost further [10,31], making the iterative inference increasingly a feature rather than a liability.

Versatility.

Beyond classification, predictive-coding machinery supports generation, reconstruction, associative memory and learning on arbitrary graph topologies [51,52]. A notable connection: modern continuous-state Hopfield networks showed that their single-step retrieval rule is the attention operation of transformers [60], linking the energy-based programme directly to the dominant contemporary architecture.

Strengths and open limitations.

PC is local, biologically grounded, admits a clear probabilistic interpretation, and is naturally generative (the same energy that performs discrimination can be run top-down to synthesise inputs), a property we exploit for continual-learning “dreaming” in Section 6. Its principal limitations are practical: the inference relaxation is iterative and therefore slower than a single forward–backward pass on von Neumann hardware (Section 7), and training degrades in very deep networks because the layerwise errors become exponentially imbalanced, an open problem we reproduce in Section 6 and discuss in Section 7.

2.2. Equilibrium Propagation and Energy-Based Learning

Energy-based models and the two-phase procedure.

Equilibrium propagation (EqProp) [11] learns over an energy-based model whose state settles to a fixed point of an energy $E(\mathbf{x},\mathbf{\theta })$. Training proceeds in two phases. In the free phase the network relaxes to an equilibrium ${\mathbf{x}}^0$ with the output free. In the nudged phase a small force of strength $\beta$ pulls the output toward the target, and the network relaxes to a slightly perturbed equilibrium ${\mathbf{x}}^{\beta }$ (Figure 4). The central result, the gradient theorem, is that the parameter update

$$\Delta \mathbf{\theta }\propto {\displaystyle \frac{1}{\beta }}\left({\displaystyle \frac{\partial E}{\partial \mathbf{\theta }}}({\mathbf{x}}^{\beta },\mathbf{\theta })-{\displaystyle \frac{\partial E}{\partial \mathbf{\theta }}}({\mathbf{x}}^0,\mathbf{\theta })\right)$$

(1)

converges, as $\beta \to 0$, to the exact gradient of the loss, using only quantities local to each synapse and a single circuit for both phases. This is the same small-nudge limit we re-derive and validate for the predictive-coding form in Theorem 2.

Relation to Hopfield networks and contrastive Hebbian learning

EqProp generalises the energy-descent dynamics of continuous Hopfield networks [60], whose equilibria are energy minima, and is closely related to contrastive Hebbian learning (CHL), in which weights are updated by the difference between a “clamped” and a “free” phase [11]. The lineage is older still: the two-phase structure descends directly from the positive (clamped) and negative (free) phases of the classical Boltzmann-machine learning rule [11], which already updated weights from the difference between two equilibrium statistics. The energy-based methods PC, EqProp and CHL all compute the backpropagation gradient in a common infinitesimal-inference limit [9,11], so they are different dynamical realisations of the same underlying credit assignment.

Extensions and hardware

EqProp has been extended to convolutional and spiking architectures, and its single-circuit, local character makes it a leading candidate for analog and neuromorphic implementation. Spike-driven EqProp (EqSpike) projects inference- and training-energy reductions of several orders of magnitude relative to GPUs and can learn online on neuromorphic substrates [12]. A practical drawback, the requirement of an infinitesimal nudge and, in the original formulation, symmetric weights, has motivated work that reduces the nudge-induced bias and broadens the comparison of these schemes with backpropagation [36,50].

Gradient-estimator bias and exactness

A subtlety specific to EqProp is that a single finite nudge yields a biased estimate of the gradient, and this bias was identified as the main reason for poor scaling to harder visual tasks. Laborieux et al. cancel it with symmetric positive and negative nudges, enabling training of deep convolutional networks [36]; holomorphic equilibrium propagation computes exact gradients through finite-size oscillations rather than an infinitesimal nudge [49]; and comparative studies analyse the family of energy-based algorithms specifically for analog computing [50].

Limitations

Like PC, EqProp inherits the cost of an iterative relaxation and, historically, the difficulty of scaling to deep and large networks; both are active research fronts (Section 7).

2.3. Forward-Only Learning

A more radical departure discards the backward pass, and the propagated error itself, entirely. The Forward-Forward (FF) algorithm [40,41] replaces the forward–backward pair with two forward passes: one on “positive” (real) data and one on “negative” (contrastive) data. Each layer is trained by a purely local objective, to make a scalar “goodness” (e.g. the sum of squared activations) high for positive data and low for negative data, so credit assignment uses only quantities present at that layer, with no retrograde signal at all. The consequences are attractive for hardware: training can be pipelined and streamed, no computation graph is stored, and the weight-transport problem disappears. Signal-propagation and forward-projection schemes assign credit through a single forward sweep or closed-form projections [13,14]. Training with purely local error signals, auxiliary per-layer losses, has likewise reached respectable benchmarks [15]. The principal open challenges are designing effective negative data and closing the accuracy gap to backpropagation on large models; this is the youngest and least saturated branch of the family, and the one we flag as the most promising for future work (Section 7).

Variants. A fast-growing literature refines FF along several axes. Convolutional extensions inject label information across all spatial positions through Fourier- or morphology-based spatial labels, enabling FF to train CNNs [40]; and channel-wise competitive learning partitions each layer’s output channels by class and computes a group-wise goodness, sharpening class selectivity [41].

Open challenges. Generating effective negative data is ad hoc; the goodness objective relies on a discrete threshold; and inference can scale linearly with the number of classes. Closing the accuracy gap to backpropagation while resolving these issues is the defining open problem of this branch.

2.4. Feedback Alignment and Target Propagation

An intermediate class keeps a propagated error signal but avoids the exact transposed weights that backpropagation requires (the weight-transport problem). Feedback alignment replaces the transposed forward weights in the backward pass with fixed random matrices; and yet the forward weights learn to partially align with these random feedback weights, so useful gradients still flow [16,78,79]. Direct feedback alignment routes the output error directly to every hidden layer through independent random projections, removing the sequential backward chain altogether [17]. Target propagation takes a different route: instead of propagating gradients it propagates targets, computed by learned approximate inverses, so that each layer-to-layer pair forms an autoencoder; difference target propagation corrects the inversion error [18]. These methods are more biologically plausible than backpropagation, especially in models that separate dendritic compartments or local error channels [71,72], but a recurring limitation is that approximation error accumulates across layers, which hampers scaling to very deep networks.

Scaling. Direct feedback alignment has been shown to scale to transformers and geometric learning; sign symmetry analyses show that only the sign of feedback weights need align with the forward ones [16]. The persistent limitation is accuracy at scale, where gradient approximation eventually costs performance.

2.5. Theoretical Relationships and the Error-Locality Spectrum

A recurring confusion in this literature is whether these methods are rivals, special cases, or the same algorithm in disguise.

A common limit

The deepest connection is that predictive coding, equilibrium propagation and contrastive Hebbian learning all compute the backpropagation gradient in a shared infinitesimal inference limit: when the output is nudged (rather than clamped) by an amount $\beta \to 0$, the local, equilibrium-based weight change aligns with the true loss gradient [9,11], which exhibits the three as different dynamical realisations of one underlying credit-assignment principle. Our Theorem 2 and its numerical validation (cosine $\to 1$ as $\beta \to 0$) instantiate this limit for the formulation used here. Away from the limit, e.g. with a fully clamped output, the local rule instead descends the model’s own free energy (Theorem 1), which is not the task loss; this is why the measured alignment saturates below one under clamping.

A spectrum of error locality

The families can be arranged on a spectrum according to how much of an error signal they propagate. At one end, backpropagation propagates an exact global error. Feedback alignment and target propagation keep a propagated error but approximate the transport [16,18]. Energy-based methods (PC, EqProp) replace propagation with relaxation: the error is computed locally and reconciled across layers by the dynamics rather than by an explicit backward sweep. At the far end, forward-only methods discard the propagated error entirely, learning each layer from a local objective on its own activations [15]. Moving along this spectrum trades fidelity to the exact gradient for locality, parallelism and hardware compatibility (Figure 5).

Where LEL sits

The Local Equilibrium Learning formulation used in this study is the discriminative, energy-based (predictive-coding-style) member of this family that we use as a single, transparent vehicle for the rest of the paper; it is defined formally in Section 4.

Which family for which constraint

The relationships above go beyond taxonomy: they imply a practical decision rule, because the families trade the same quantities differently (Table 1). When the binding constraint is activation memory, training very wide or long-horizon models, or learning on-device, the energy-based methods are preferred: their footprint is $O\left(\mathrm{width}\right)$ because they store states, not a depth-long graph. When it is hardware co-location, analog crossbars or neuromorphic chips, equilibrium propagation and predictive coding are the strongest fit, since the update reads only quantities present at the synapse and needs no transported weights. When it is raw scalability to very deep networks today, backpropagation and, among the alternatives, feedback alignment remain ahead, because energy-based depth is still an open problem (Section 7). When it is streaming or pipelined training with no stored graph, forward-only methods are the most natural, at the current cost of an accuracy gap. And when it is continual learning without stored data, the focus of this survey, the energy-based members gain a real structural advantage, because the very same network can generate its own rehearsal data (Section 4 and Section 6). No single family dominates; the right choice is dictated by which of these resources is scarce.

3. Continual Learning: Problem and Methods

Continual learning asks a network to acquire a sequence of tasks over time while retaining what it learned before. That setting aligns with the structural traits of local, energy-based methods—online updates, a native generative direction—and is where credit-assignment alternatives to backpropagation are most likely to matter. Section 6 then studies how local networks fare on this problem.

3.1. Catastrophic Forgetting, Scenarios and Metrics

The phenomenon

When a neural network is trained on a sequence of tasks, learning a new task tends to overwrite the weights that encoded earlier ones, so performance on the old tasks collapses, catastrophic forgetting, identified already in early connectionist models [19,20]. It is the single largest obstacle to lifelong, on-device and streaming learning, and it is not specific to backpropagation: any method that descends a task loss by adjusting shared weights is exposed to it, as our own negative result for local learning confirms (Section 6).

Three scenarios

The difficulty depends sharply on what the model is asked to do at test time. Van de Ven and Tolias distinguish three canonical scenarios [20]: (i) task-incremental (Task-IL), where the task identity is given at test time and the model need only discriminate within a task (e.g. a multi-head output); (ii) domain-incremental (Domain-IL), where the structure is fixed but the input distribution shifts and the task identity is unknown; and (iii) class-incremental (Class-IL), where the model must choose among all classes seen so far without any task label. Class-IL is by far the hardest because it additionally requires calibrating outputs across tasks, and it is precisely the regime in which weight-regularization methods collapse. We report Class-IL as our primary metric and Task-IL as a secondary one (Section 6); the three are contrasted in Figure 6.

Evaluation

Standard metrics include the average accuracy over all tasks after the full sequence, the forgetting (drop from the peak accuracy of each task to its final accuracy), and backward/forward transfer [20]. Common benchmarks are Split-MNIST and Permuted-MNIST, Split-Fashion-MNIST and Split-CIFAR; we use Split versions of all three image datasets, and additionally report two informative bounds, the joint-training ceiling (all classes at once) and the oracle (replay of stored real data), which isolate the contribution of the continual mechanism from that of the base classifier.

3.2. Methods: Regularization, Replay and Architecture

Three families dominate the continual-learning literature [19,20,65,66].

Regularization

These methods add a penalty that discourages changes to weights deemed important for past tasks. Elastic Weight Consolidation (EWC) weights a quadratic anchor by the diagonal of the Fisher information, an estimate of each parameter’s importance [21]; Synaptic Intelligence (SI) accumulates an analogous importance online along the optimisation path [22]; and Memory Aware Synapses (MAS) measures the sensitivity of the network’s outputs to each parameter, allowing unsupervised importance estimates [23]. A related, distillation-based variant, Learning without Forgetting (LwF), instead anchors behaviour rather than weights: it matches the previous model’s responses on the new task’s data through a knowledge-distillation loss, requiring no stored old data and no per-parameter importance estimate [56]. A central, well-replicated empirical fact, which our experiments reproduce, is that these methods work in task-incremental settings but fail in class-incremental ones, because a quadratic (or distillation) penalty cannot teach the network to separate classes that were never seen together [20].

Replay

Replay-based methods revisit past experience while learning new tasks. The simplest, pseudo-rehearsal, labels random inputs with the previous model and rehearses them [24]; it is cheap but, as we show, fails in high dimension because random inputs lie off the data manifold. Deep generative replay instead trains a generative model (e.g. a VAE or GAN) to synthesise past data, which the solver then rehearses [24]; brain-inspired replay generates internal representations from the network’s own context-modulated feedback, achieving strong class-incremental performance without storing raw data [25]. Several refinements have followed: latent/feature replay synthesises in the space of deep features rather than raw pixels, which is cheaper and more stable; diffusion-based generative replay improves sample fidelity; and generative negative replay rehearses contrastive rather than positive samples [37]. Exemplar methods instead store a small memory of real examples: iCaRL combines such a memory with nearest-mean classification and distillation [26], while Gradient Episodic Memory (GEM) uses the stored examples as constraints, projecting each update so that it does not increase the loss on any past task [57]; its averaged variant, A-GEM, relaxes this to a single aggregate constraint, trading a little retention for a large gain in speed and memory [64]. Energy-based networks are themselves generative, which makes “dreaming”—replaying self-generated samples—a natural, storage-free form of replay and the strategy studied in Section 6.

Architecture

A third family allocates dedicated capacity per task or gates a shared network by context, isolating tasks at the cost of growing parameters or requiring task identity. Context-dependent gating with synaptic stabilisation is one representative example [27]; PackNet is another, packing several tasks into a single fixed-size network by iteratively pruning and freezing a task-specific subset of weights, which eliminates forgetting outright at the price of a per-task binary mask [58].

Table 2 compares the principal methods along the axes that matter for deployable, biologically grounded continual learning: whether they store raw data, whether they are generative, whether they avoid backpropagation, and whether they succeed in the demanding class-incremental scenario.

The table makes the intended niche of this review explicit. To the best of our knowledge, the combination studied here, storage-free generative replay with local credit assignment in an energy-based classifier/generator, occupies a comparatively underexplored part of the class-incremental literature. The point is not to claim that no related method exists, but to provide a transparent benchmark for this particular combination of locality, replay and memory accounting.

3.3. Local Learning Meets Continual Learning

The intersection of local, energy-based learning and continual learning is recent and unusually active. Because energy-based networks are generative, “dreaming”, replaying self-generated samples, is a natural strategy for them. Predictive-coding networks have been used for lifelong and sequential learning [28], and the underlying principle of prediction-error-driven consolidation, updating memory in proportion to surprise, fits naturally with continual adaptation. The complementary learning systems theory argues that the brain avoids catastrophic interference by pairing a fast, sparse hippocampal learner with a slow, distributed neocortical one, and interleaves replay of the former into the latter during consolidation [70], precisely the fast-learn-then-rehearse structure that generative replay imitates. More broadly, several brain mechanisms, hippocampal replay during sleep, spike-timing-dependent plasticity and sparse distributed memory, are now mapped onto machine-learning methods through associative-memory consolidation models [38,61] and surveys of brain-inspired continual learning [39]. Our empirical case study (Section 6) sits squarely in this line. Closely related work already exists in predictive coding, equilibrium propagation and generative replay; the claim here is not that any one component is new. Rather, to the best of our knowledge, prior work has not combined the same review taxonomy, reproducibility protocol and diagnostic continual-learning benchmark under the LEL formulation. The case study is included to make that synthesis executable and testable: the same energy-based framework classifies and dreams under a fairness-controlled protocol, leading to a conclusion that the continual-learning literature increasingly supports, parity in raw accuracy and a clear advantage of replay over unprotected learning.

Benchmarks, baselines and reproducibility.

Cumulative progress in this area has been hampered by inconsistent evaluation, which makes published numbers hard to compare. Three choices matter. The benchmark: the community has converged on Split- and Permuted-MNIST, Split-Fashion-MNIST and Split-CIFAR, but the difficulty depends entirely on which of the three scenarios (task-, domain- or class-incremental) is reported, and papers do not always state it [20]. The metric: average accuracy over seen tasks, the forgetting (peak-minus-final accuracy), and backward/forward transfer capture different facets and should be reported together [20]. The bounds: comparisons are only interpretable relative to a joint-training ceiling and, ideally, an oracle that replays stored data; without them, a high number may reflect a strong base classifier rather than an effective continual mechanism. For backpropagation-free methods specifically, early studies used incompatible protocols and ad hoc baselines, which has motivated unified, simplified benchmarking suites and frameworks [31]. We adopt these practices throughout Section 6, fixed scenarios, both bounds, multiple seeds, two independent implementations, and released code, precisely so that our results are reproducible and fairly comparable rather than another incommensurable data point.

3.4. Conceptual Boundaries and Design Principles

Interpreting experiments in this area requires keeping three levels of analysis separate. Table 3 fixes the vocabulary: credit-assignment mechanisms (backpropagation, predictive coding, LEL), continual-learning mechanisms (EWC, replay, architectural gating) and evaluation protocols (Split-MNIST, Class-IL, Domain-IL) are independent choices, and many apparent disagreements in the literature arise from conflating them. With that vocabulary in place, Table 4 identifies the five replaceable components of a local continual learner and the main options for each; Table 5 provides a structured benchmark progression where each rung exposes one additional difficulty. A method should normally demonstrate competence at a given rung before claiming the next.

Design patterns for local continual systems

The design patterns in Table 4 make the design space concrete by viewing a local continual learner as a pipeline with five replaceable parts: an inference dynamics, a local synaptic update, a retention mechanism, a generator or memory policy, and an evaluation protocol. This modular view is useful because most improvements change only one part. A new relaxation schedule should be tested while keeping replay fixed; a new generator should be tested while keeping the classifier and task order fixed; a new memory policy should be compared under the same Class-IL evaluation. Otherwise, a positive result may be impossible to attribute.

This table also explains why the present paper is conservative. We fix the architecture and use simple local generators so that the role of replay can be seen clearly. A more competitive system would almost certainly change several rows at once, for example a deeper residual local architecture, a feature-space generator and a neuromorphic implementation. Such a system may be the right engineering target, but it is a poor first scientific test because success would not reveal which component mattered. The baseline here is deliberately smaller so that future work can make controlled substitutions.

A benchmark ladder

A useful research programme should not jump directly from Split-MNIST to large-scale vision or language. Local methods have additional moving parts, and each benchmark should expose one new difficulty. We propose the ladder in Table 5 as a practical progression. The lower rungs test whether the local rule works and whether forgetting is real; the middle rungs test storage-free replay and generator fidelity; the upper rungs test scaling, representation learning and hardware.

A method should normally pass a rung before claiming the next. For example, a high Class-IL number without a joint-training ceiling and an oracle replay bound does not show that the continual mechanism is strong; it may only show that the base task is easy. Conversely, a low CIFAR-10 number does not by itself refute the mechanism if the joint ceiling is also low. The ladder is meant to keep the interpretation attached to the bottleneck actually being tested.

4. A Unified Energy-Based Formulation (LEL)

To study these ideas concretely and reproducibly we fix a single, minimal member of the energy-based family, which we call Local Equilibrium Learning (LEL). LEL is used here only as a notational umbrella, not as a new algorithmic family: it is deliberately standard, essentially discriminative predictive coding, so that the theory below restates established results in one notation and the experiments of Section 6 can be read without translating between formalisms.

4.1. Model

Definition 1

(Network as an energy system). A network of layers $\ell =0,\dots ,L$ has neuron states ${\mathbf{x}}_{\ell }\in {\mathbb{R}}^{n_{\ell }}$, input clamped to ${\mathbf{x}}_0=\mathbf{d}$, and parameters $\mathbf{\theta }=\{{\mathbf{W}}_{\ell },{\mathbf{b}}_{\ell }\}$. With ${\mathbf{a}}_{\ell }={\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell }$, prediction ${\mathbf{\mu }}_{\ell }=f\left({\mathbf{a}}_{\ell }\right)$ and error ${\mathbf{e}}_{\ell }={\mathbf{x}}_{\ell }-{\mathbf{\mu }}_{\ell }$ ($f\in C^1$), the free energy is

$$F(\mathbf{x},\mathbf{\theta })=\frac{1}{2}{\displaystyle \sum _{\ell =1}^L}{\parallel {\mathbf{x}}_{\ell }-f({\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell })\parallel }^2.$$

(2)

This is the standard predictive-coding energy [7,9]; inference minimises F over hidden states and learning minimises it over $\mathbf{\theta }$.

4.2. Inference as Relaxation

Hidden states follow ${\dot{\mathbf{x}}}_{\ell }=-\partial F/\partial {\mathbf{x}}_{\ell }$, with $\partial F/\partial {\mathbf{x}}_{\ell }={\mathbf{e}}_{\ell }-{\mathbf{W}}_{\ell +1}^{\top }(f^{\prime }\left({\mathbf{a}}_{\ell +1}\right)\odot {\mathbf{e}}_{\ell +1})$. Figure 7 shows the resulting train-time loop.

Proposition 1

(Energy is a Lyapunov function). Along the inference dynamics

$${\displaystyle \frac{dF}{dt}}=-\sum _{\ell }{∥{\displaystyle \frac{\partial F}{\partial {\mathbf{x}}_{\ell }}}∥}^2\le 0,$$

with equality only at equilibrium; trajectories are bounded and converge to the equilibrium set. This is the classical energy-descent property of Hopfield and PC networks [60]; numerically, F decreases monotonically ($5.30\to 2.68$) with $\parallel \partial F/\partial \mathbf{x}\parallel \to 0$.

Proof. 

By the chain rule and (2), $\frac{dF}{dt}={\sum }_{\ell }\langle \partial F/\partial {\mathbf{x}}_{\ell },{\dot{\mathbf{x}}}_{\ell }\rangle =-{\sum }_{\ell }{\parallel \partial F/\partial {\mathbf{x}}_{\ell }\parallel }^2\le 0$, with equality iff every partial derivative vanishes, i.e. at an equilibrium. Since $F\ge 0$ is non-increasing it converges; by LaSalle’s invariance principle the trajectory approaches the largest invariant set contained in $\{\dot{F}=0\}$, namely the equilibrium set. Uniqueness of the equilibrium follows when the Hessian ${\partial }^{2}F/\partial {\mathbf{h}}^2$ is positive definite (moderate spectral radii of the ${\mathbf{W}}_{\ell }$), a contractive regime.    □

4.3. Learning as a Local Rule

Lemma 1

(Locality). $\partial F/\partial {\mathbf{W}}_{\ell }=-(f^{\prime }\left({\mathbf{a}}_{\ell }\right)\odot {\mathbf{e}}_{\ell }){\mathbf{x}}_{\ell -1}^{\top }$: each update uses only the error of layer ℓ and the activity of layer $\ell -1$.

Theorem 1

(Exact descent on the reduced free energy). With $E\left(\mathbf{\theta }\right)={min}_{\mathbf{h}}F(\mathbf{h},\mathbf{\theta })$ and a unique smooth minimiser ${\mathbf{h}}^{★}\left(\mathbf{\theta }\right)$, the envelope theorem gives ${\nabla }_{\mathbf{\theta }}{E=\partial F/\partial \mathbf{\theta }|}_{{\mathbf{h}}^{★}}$; the local update is thus exact gradient descent on E without any backward pass. This is the equilibrium-gradient argument underlying EqProp and PC [9,11].

Proof. 

By the total derivative, ${\nabla }_{\mathbf{\theta }}{E=\partial F/\partial \mathbf{\theta }|}_{{\mathbf{h}}^{★}}+(\partial F/\partial \mathbf{h}{|}_{{\mathbf{h}}^{★}})(\partial {\mathbf{h}}^{★}/\partial \mathbf{\theta })$. The second term vanishes because ${\mathbf{h}}^{★}$ minimises $F(·,\mathbf{\theta })$, so ${\partial F/\partial \mathbf{h}|}_{{\mathbf{h}}^{★}}=0$ (Proposition 1). Hence ${\nabla }_{\mathbf{\theta }}{E=\partial F/\partial \mathbf{\theta }|}_{{\mathbf{h}}^{★}}$, which by Lemma 1 is assembled from purely local equilibrium quantities, with no backward sweep over the network.    □

Theorem 2

(Recovery of backpropagation in the small-nudge limit). With a nudged energy $F_{\beta }=F+\frac{\beta }{2}{\parallel {\mathbf{x}}_L-\mathbf{y}\parallel }^2$, the local update direction converges, as $\beta \to 0^{+}$, to the backpropagation gradient of $\mathcal{L}=\frac{1}{2}{\parallel \mathbf{y}-{\mathbf{\mu }}_L\parallel }^2$ [11]. We confirm this numerically (Figure 8): the cosine between the local update and $-{\nabla }_{\mathbf{\theta }}\mathcal{L}$ rises from $0.76$ at $\beta =1$ to $1.0000$ as $\beta \to 0$, whereas with a fully clamped output it saturates at $\approx 0.62$ (the local rule descends E, which differs from the task loss).

Proof 

(Proof sketch). At $\beta =0$ the free-phase equilibrium reproduces the feedforward predictions, so the hidden errors vanish. The first-order response of the equilibrium to the nudge propagates the output error downward through the same matrices ${\mathbf{W}}_{\ell +1}^{\top }$, producing the recursion ${\mathbf{e}}_{\ell }={\mathbf{W}}_{\ell +1}^{\top }(f^{\prime }\left({\mathbf{a}}_{\ell +1}\right)\odot {\mathbf{e}}_{\ell +1})$, which is identical to the backpropagation $\mathbf{\delta }$ recursion; substituted into Lemma 1 it reproduces ${\nabla }_{\mathbf{\theta }}\mathcal{L}$. This is the Equilibrium Propagation / predictive-coding argument [9,11]; the fully clamped case ($\beta \to \infty$) instead descends E, explaining the measured saturation at $cos\approx 0.62$.    □

Remark 1.

Optimisers such as Adam or Levenberg–Marquardt arenotalternatives to backpropagation: they consume a gradient that backpropagation computes. Local methods instead replace the gradientcomputation. Likewise, parameter-efficient fine-tuning (e.g. LoRA) reduceshow manyweights are trained but still relies on the global backward pass.

4.3.0.27. Probabilistic interpretation.

The energy (2) is not an arbitrary objective; it is the negative log-probability of a hierarchical Gaussian generative model, and this is what gives the local rule its statistical meaning. Suppose each layer predicts the next through a Gaussian whose mean is the forward map and whose covariance is ${\Sigma }_{\ell }$,

$$p({\mathbf{x}}_0,\dots ,{\mathbf{x}}_L)={\displaystyle \prod _{\ell =1}^L}\mathcal{N}\left({\mathbf{x}}_{\ell };f({\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell }),{\Sigma }_{\ell }\right).$$

(3)

Taking negative logarithms turns the product into a sum of precision-weighted squared errors plus constants,

$$-logp=\frac{1}{2}{\displaystyle \sum _{\ell =1}^L}{\mathbf{e}}_{\ell }^{\top }{\Pi }_{\ell }{\mathbf{e}}_{\ell }+\frac{1}{2}\sum _{\ell }log\left|{\Sigma }_{\ell }\right|+\mathrm{const},{\mathrm{\Pi }}_{\ell }={\Sigma }_{\ell }^{-1},$$

(4)

so Equation (4) shows that the unit-precision case ${\Pi }_{\ell }=\mathbf{I}$ recovers exactly the free energy of Definition 1. Three consequences follow, and they line up one-to-one with the operations of the algorithm. Inference (clamping the data and relaxing the hidden states, Algorithm 1) is maximum-a-posteriori estimation of the latent activities under (3); the relaxation of Proposition 1 is gradient ascent on the log-posterior. Learning (the local weight step) is the M-step of generalised expectation–maximisation: with the activities held at their MAP values, $-logp$ is minimised over the parameters, which by the envelope theorem (Theorem 1) is exactly the local Hebbian update. And the precisions ${\Pi }_{\ell }$ weight each layer’s error by its reliability, a free parameter in unit- precision LEL, but the very lever that, when re-balanced across depth, counteracts the error attenuation of Section 7. This is the predictive-coding reading of the free-energy principle [8], here made explicit for the discriminative network we study.

4.4. Precision, Inference Budget and Complexity

Three practical aspects connect the formulation above to its empirical behaviour. First, the squared-error energy (2) is the unit-precision special case of the variational free energy: weighting each layer’s error by a precision (inverse variance) yields $F=\frac{1}{2}{\sum }_{\ell }{\mathbf{e}}_{\ell }^{\top }{\Pi }_{\ell }{\mathbf{e}}_{\ell }$, and the per-layer precisions ${\Pi }_{\ell }$ are exactly the quantities one re-balances to alleviate the depth problem (Section 7). Second, inference is run for a finite number T of relaxation steps rather than to exact equilibrium; T is an accuracy–cost knob, and the envelope guarantee of Theorem 1 holds at the true equilibrium, so too small a T biases the update. Third, the cost of one parameter update is $O\left(T\right)$ forward-like passes, versus $O\left(1\right)$ for backpropagation; this is the price of replacing a backward sweep with a relaxation, and is the basis of the efficiency analysis of Section 7. Table 6 collects the analytical scaling. The measured overhead is about $5\times$ rather than the asymptotic $T=15\times$, because backpropagation itself costs two to three forward-equivalents per update. More telling are the structural rows: LEL stores $O\left(\mathrm{width}\right)$ activations instead of the $O(\mathrm{depth}\times \mathrm{width})$ graph that backpropagation must retain, and needs no transposed weight copy—the two properties that make it portable to in-memory hardware.

The generative direction

Because the energy is defined symmetrically over predictions and states, the same network that discriminates ($\mathbf{d}\to \mathbf{y}$) can be run generatively: with the label clamped and the input free, relaxation produces inputs consistent with a class, and sampling a latent prior and propagating top-down yields novel samples. This dual use, inference and generation in one model, is what enables the self-generated “dreaming” replay studied in Section 6, and is a structural property that purely discriminative, backpropagation-trained perceptrons lack [24,25].

5. Benchmark Design and Reproducibility Protocol

All models are multilayer LEL networks trained with the local rule of Lemma 1; inference uses T relaxation steps with the output clamped (or nudged) to the target. Datasets are MNIST [20], Fashion-MNIST [35] and CIFAR-10 [65], flattened and mean-centred; class-incremental Split tasks present classes two at a time. Generative “dreaming” uses per-class local generators, a principal-subspace model (Oja’s rule [29]) or a nonlinear predictive-coding autoencoder, sampled and labelled by the frozen previous model and mixed with the current task; no raw data of past tasks is stored, in the spirit of generative replay [24,25]. Baselines (EWC [21], SI [22]) use a matched backpropagation MLP. Experiments are released as NumPy scripts; the headline continual-learning result is reproduced independently in MATLAB. Table 7 summarises the study.

5.1. Experimental Setup

We use three standard image datasets, MNIST [20], Fashion-MNIST [35] and CIFAR-10 [65], with pixels scaled to $[0,1]$ and mean-centred (CIFAR is kept in colour, flattened to 3072 dimensions). For the continual setting we form the standard Split benchmark: the ten classes are presented as five binary tasks ($\{0,1\},\{2,3\},\dots ,\{8,9\}$), trained strictly in sequence with no access to past data. Unless stated otherwise we sub-sample a few hundred to a few thousand examples per class to keep the relaxation-based training fast. We evaluate two scenarios: class-incremental (argmax over all ten outputs) as the primary, hardest metric, and task-incremental (argmax restricted to a task’s two classes) as a secondary one [20]. Two bounds frame every result: the joint-training ceiling (all classes learned together) and the oracle (replay of stored real images), which separate the contribution of the continual mechanism from that of the base classifier.

Classifier and inference

The classifier is a multilayer LEL network (e.g. $784\to 256\to 10$, tanh hidden units, linear outputs, one-hot targets in $\{-1,+1\}$). During training the output is clamped to the target and the hidden states are relaxed for T steps of the dynamics ${\mathbf{x}}_{\ell }\leftarrow {\mathbf{x}}_{\ell }-\gamma \partial F/\partial {\mathbf{x}}_{\ell }$ (typically $T\approx 15$–60, $\gamma \approx 0.2$); the weights are then updated by the local rule of Lemma 1 with a small learning rate, in mini-batches. At test time inference is a plain forward pass (no clamping). The same machinery, run with the input free, provides the generative direction. Algorithm 1 states the supervised update in full; it has no backward sweep, the inner loop is the only iteration, and every weight change reads only the local error ${\mathbf{e}}_{\ell }$ and the presynaptic activity ${\mathbf{x}}_{\ell -1}$.

Algorithm 1:Local Equilibrium Learning: one supervised mini-batch update.

Require:  batch $(\mathbf{d},\mathbf{y})$; parameters $\mathbf{\theta }=\{{\mathbf{W}}_{\ell },{\mathbf{b}}_{\ell }\}$; steps T; rates $\gamma ,\eta$ 1: ${\mathbf{x}}_0\leftarrow \mathbf{d}$;   ${\mathbf{x}}_L\leftarrow \mathbf{y}$                                                              ▹ clamp input and output 2: ${\mathbf{x}}_{\ell }\leftarrow f({\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell })$ for all hidden ℓ                        ▹ feedforward init 3: for$t=1,\dots ,T$do                                                        ▹inference: relax to equilibrium 4:     for each hidden layer ℓ do 5:         ${\mathbf{a}}_{\ell }\leftarrow {\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell }$;   ${\mathbf{e}}_{\ell }\leftarrow {\mathbf{x}}_{\ell }-f\left({\mathbf{a}}_{\ell }\right)$ 6:         ${\mathbf{x}}_{\ell }\leftarrow {\mathbf{x}}_{\ell }-\gamma \left({\mathbf{e}}_{\ell }-{\mathbf{W}}_{\ell +1}^{\top }(f^{\prime }\left({\mathbf{a}}_{\ell +1}\right)\odot {\mathbf{e}}_{\ell +1})\right)$ 7:     end for 8: end for 9: for each layer ℓdo                                                    ▹ learning: one local Hebbian step 10:     ${\mathbf{W}}_{\ell }\leftarrow {\mathbf{W}}_{\ell }+\eta (f^{\prime }\left({\mathbf{a}}_{\ell }\right)\odot {\mathbf{e}}_{\ell }){\mathbf{x}}_{\ell -1}^{\top }$;   ${\mathbf{b}}_{\ell }\leftarrow {\mathbf{b}}_{\ell }+\eta (f^{\prime }\left({\mathbf{a}}_{\ell }\right)\odot {\mathbf{e}}_{\ell })$ 11: end for 12: return$\mathbf{\theta }$

Generative models for dreaming

Two local, backpropagation-free generators are used per class. The linear generator is the principal subspace of the class, the fixed point of Oja’s rule [29], from which codes are drawn from a Gaussian (or a small Gaussian mixture) and decoded. The nonlinear generator is a predictive-coding autoencoder ($\mathbf{z}\to tanh\left({\mathbf{W}}_1\mathbf{z}\right)\to \mathbf{x}$) trained with the same local rule and sampled from its latent prior. In both cases $n_d$ samples per previously seen class are generated, labelled by the frozen previous model, and mixed with the current task’s data, a storage-free instance of generative replay [24,25]. Algorithm 2 and Figure 9 assemble the full class-incremental loop: every step, classifier update, generator training, and labelling of dreams, is local, so no part of the pipeline performs backpropagation or stores raw data of past tasks.

Algorithm 2:Class-incremental learning by local generative dreaming.

Require:  task stream ${\mathcal{T}}_1,\dots ,{\mathcal{T}}_K$; dreams per class $n_d$ 1: initialise classifier $\mathbf{\theta }$;   seen classes $\mathcal{S}\leftarrow ⌀$;   generators $\mathcal{G}\leftarrow ⌀$ 2: for each task ${\mathcal{T}}_k$ with new classes ${\mathcal{C}}_k$ do 3:     $D\leftarrow {\mathcal{T}}_k$                                                                             ▹ current-task data 4:     for each old class $c\in \mathcal{S}$do                                             ▹ dream the past 5:         draw $n_d$ pseudo-inputs from generator $G_c$; label them with the frozen $\mathbf{\theta }$ 6:         append the labelled dreams to D 7:     end for 8:     update $\mathbf{\theta }$ on D using Algorithm 1                             ▹ local, no backprop 9:     for each new class $c\in {\mathcal{C}}_k$ do 10:         train a local generator $G_c$ on its data; add $G_c$ to $\mathcal{G}$ 11:     end for 12:     freeze a copy of $\mathbf{\theta }$;   $\mathcal{S}\leftarrow \mathcal{S}\cup {\mathcal{C}}_k$ 13: end for 14: return$\mathbf{\theta }$

5.2. Baselines and Evaluation

Regularization baselines (EWC [21], SI [22]) are implemented on a matched backpropagation MLP, with the EWC penalty weighted by the diagonal Fisher information and the SI importance accumulated along the optimisation path, each swept over its strength $\lambda$. We report class- and task-incremental accuracy and the implied forgetting, averaged over five seeds with standard deviations. Every figure and table in Section 6 is produced by a released script (Table 7); the headline Split-MNIST result is reproduced in an independent MATLAB implementation, and all energy figures are computed from published per-operation costs [4].

5.3. Reproducibility Protocol

This subsection makes the experiments auditable rather than maximally optimised. All core scripts use small NumPy or MATLAB implementations, explicit random seeds and plain arrays; no automatic differentiation package is used for the LEL experiments. This matters because the central claim concerns where the number comes from: it must follow from a genuinely local update, not from a disguised global one. A reader should be able to inspect every line that computes an error, relaxes a state or updates a weight.

The protocol has four rules. First, each experiment fixes the task order $\{0,1\}\to \{2,3\}\to \dots \to \{8,9\}$ so that differences are not due to task permutation. Second, all reported continual results are interpreted relative to a joint-training ceiling and, where possible, an oracle replay bound. Third, the regularization baselines are implemented with backpropagation on a matched MLP, not on a stronger architecture, because their role is to test the retention mechanism under a comparable representational budget. Fourth, generator-based experiments store only the parameters or statistics of the generator, never raw examples from previous tasks. When a method stores real examples, it is labelled as an oracle or exemplar method.

Repository and reproducibility package.

The repository contains the source .tex file, the NumPy scripts for all headline experiments, an independent MATLAB reproduction of the Split-MNIST result, figure-generation scripts, fixed random seeds and all configuration values in the tables. Datasets (MNIST [20], Fashion-MNIST [35], CIFAR-10 [65]) are public and downloaded by script. The repository also stores raw numeric outputs so that a reader can distinguish manuscript formatting from experimental regeneration. No result depends on an unavailable private dataset or pretrained model.

Table 8 records the main hyperparameters used by the reproducible scripts. These settings should not be read as optimal; they are stable defaults that make the reported phenomena visible. In particular, the relaxation budget T is an experimental variable, not a sacred constant: Section 6 shows that in a shallow network the accuracy is almost flat across T, while the wall-clock cost rises nearly linearly.

Memory policy.

Continual learning is often defined by resource constraints, so the memory policy must be explicit (Table 9). Vanilla LEL stores only the current parameters; regularization baselines store parameter anchors and importance estimates; oracle replay stores real old images; local dreaming stores generator parameters or compact class statistics, then synthesises pseudo-examples on demand. Storing a generator is a model-memory cost, not a data-memory cost—a distinction that matters when interpreting any “storage-free” claim.

6. Results: Reproducible Benchmark and Diagnostic Case Study

The theory of Section 4 tells us what local learning is; this section asks what it does for continual learning. The experiments here are diagnostic and auditable, intended to verify the theoretical claims and provide an honest baseline, not to constitute an empirical contribution in the sense of a methods paper. To keep the empirical message unambiguous, we separate four kinds of result. The first is a theoretical sanity check: local learning can match backpropagation on small supervised problems, as the theory predicts. The second is the main positive benchmark: local generative replay prevents class-incremental forgetting far better than vanilla learning or weight regularization. The third is a set of negative results: locality alone does not prevent forgetting, EWC/SI do not solve Class-IL here, and naive noise replay fails off the data manifold. The fourth is diagnostic limitation: the shallow local model remains weak on raw-pixel CIFAR-10, deeper stacks suffer error imbalance, and the method is more expensive on ordinary von Neumann hardware.

6.1. Local Learning Matches Backpropagation

The first question is whether the local rule learns at all on non-trivial problems. On the non-linear two-moons task, which a linear model cannot solve, a local network reaches $96.75\%$, against $99.0\%$ for backpropagation on the identical architecture. On a ten-class MNIST subset the gap closes with sufficient training: LEL attains $90.0\%$ versus $89.8\%$ for a matched MLP. We stress that this is parity, not superiority: the local rule learns as well as backpropagation, exactly as Theorem 2 and the predictive-coding literature predict [9,10], but not better. A practical caveat surfaced repeatedly in our runs: because inference is iterative, an under-resourced relaxation (too few steps T, or too few epochs) understates LEL’s accuracy and, in the continual setting, its forgetting; hence the fairness controls detailed below. The constructive reading of this parity is sobering for the continual-learning question that follows: if the local rule computes essentially the same update as backpropagation, it should also inherit backpropagation’s catastrophic forgetting, which is exactly what we find next.

Forgetting without mitigation

Because LEL reduces to the backpropagation gradient at the inference equilibrium (Theorem 2), one should expect it to inherit, not cure, catastrophic forgetting. We confirm this with an essential fairness control: at 400 epochs a deep-task-then-new-task protocol shows LEL apparently forgetting little ($6.5\%$), but this merely reflects under-training on the new task; trained to convergence, both LEL and a matched backpropagation network forget catastrophically ($\sim 38\%$). Reporting the under-trained number alone would be misleading, a caveat also stressed in continual-learning evaluation [20]. The advantage, therefore, must come from an added mechanism, not from the local rule itself.

6.2. Continual Learning: Regularization Fails, Replay Works

Table 10 reports the headline class-incremental Split-MNIST comparison.

Vanilla local learning collapses to chance, inheriting backpropagation’s forgetting (a direct consequence of Theorem 2). Weight regularization (EWC, SI) does not help in the class-incremental regime, matching the literature [20]. The reason is structural rather than a matter of tuning: a quadratic penalty can protect weights that were important for old classes, but it cannot create the decision boundaries that separate classes never seen together, and in class-incremental learning the model is never shown two tasks’ classes jointly, so no anchor can teach their relative calibration. Replay sidesteps this exactly because it re-presents past classes alongside the new ones. Generative dreaming recovers $96\%$ of the joint ceiling (Figure 12); in the easier task-incremental scenario, where cross-task calibration is not required, the same model reaches $97.4\pm 0.2\%$. Figure 13 and Figure 14 trace this over the task sequence, vanilla learning ends able to classify only the most recent task, while dreaming retains them all. The number of dreams $n_d$ trades memory for retention ($19.3,75.2,82.6,86.7,88.5\%$ for $n_d=0,250,500,1000,2000$); sampling latent codes from a Gaussian mixture with $n_d=3000$ closes the gap to $88.7\%$, $1.5$ points from the oracle (Figure 10).

Figure 10. Ablation of the dream budget $n_d$ on Split-MNIST. Even a small number of self-generated samples recovers most of the accuracy; returns diminish as $n_d$ approaches the oracle (perfect-memory) bound.

Figure 10. Ablation of the dream budget $n_d$ on Split-MNIST. Even a small number of self-generated samples recovers most of the accuracy; returns diminish as $n_d$ approaches the oracle (perfect-memory) bound.

A second ablation isolates the cost of the inference itself: how many relaxation steps T the local rule needs to assign credit well. We trained the single-task MNIST classifier ($784\to 256\to 10$) for a fixed number of epochs while varying T, measuring test accuracy and wall-clock time (Figure 11). The result is informative and, at first sight, counter-intuitive: accuracy is essentially flat, $84.9\%$ at $T=1$ and $85.0\%$ at $T=25$ (the absolute level sits below the $90\%$ reported above because the per-run training budget is held deliberately small to isolate the effect of T), while wall-clock time grows almost linearly in T (from $3.0$ to $18.0$ s, a $6\times$ increase). For a shallow network a single relaxation step already captures most of the credit-assignment signal, so the extra equilibration is nearly wasted compute. This sharpens the efficiency discussion of Section 7: the per-step locality of the rule is what matters, and one should spend relaxation steps only where they pay off, primarily in deeper networks, where the error must propagate through more layers before the activities settle (the depth barrier discussed in Section 7). It also makes the measured $7.5\times$ slowdown over backpropagation a worst-case figure tied to large T, not an intrinsic property of local learning.

Figure 11. Ablation of the number of relaxation steps T in the local classifier (single-task MNIST). Accuracy (left axis, solid) is flat across T; wall-clock time (right axis, dashed) grows roughly linearly. One step already suffices for a shallow network.

Figure 11. Ablation of the number of relaxation steps T in the local classifier (single-task MNIST). Accuracy (left axis, solid) is flat across T; wall-clock time (right axis, dashed) grows roughly linearly. One step already suffices for a shallow network.

Figure 12. Class-incremental Split-MNIST. Backpropagation-based regularization (EWC, SI) does not exceed the vanilla/chance level, whereas local generative dreaming reaches $86.8\%$, close to the oracle (perfect-memory replay) and the joint-training ceiling.

Figure 12. Class-incremental Split-MNIST. Backpropagation-based regularization (EWC, SI) does not exceed the vanilla/chance level, whereas local generative dreaming reaches $86.8\%$, close to the oracle (perfect-memory replay) and the joint-training ceiling.

Figure 13. Forgetting over the task sequence on Split-MNIST (average class-IL accuracy over all tasks seen so far). Vanilla local learning degrades toward chance as new tasks arrive, its accuracy on the first task collapses from $99.9\%$ to $0\%$ after a single new task, whereas local generative dreaming retains earlier tasks throughout (first-task accuracy stays $\ge 96\%$).

Figure 13. Forgetting over the task sequence on Split-MNIST (average class-IL accuracy over all tasks seen so far). Vanilla local learning degrades toward chance as new tasks arrive, its accuracy on the first task collapses from $99.9\%$ to $0\%$ after a single new task, whereas local generative dreaming retains earlier tasks throughout (first-task accuracy stays $\ge 96\%$).

Figure 14. Per-task accuracy after the full five-task sequence. Vanilla local learning retains only the most recent task (T5) and scores zero on all earlier ones; local generative dreaming retains every task. This is the same phenomenon as Figure 13, viewed as the final distribution over tasks.

Figure 14. Per-task accuracy after the full five-task sequence. Vanilla local learning retains only the most recent task (T5) and scores zero on all earlier ones; local generative dreaming retains every task. This is the same phenomenon as Figure 13, viewed as the final distribution over tasks.

6.3. Why Dreaming Works: The Data Manifold

Why does self-generated replay help where labelling random noise does not? The answer is geometric. Real data occupy a thin manifold within a high-dimensional ambient space; a useful rehearsal sample must lie on that manifold, because the old classifier was only ever shaped there. We make this precise with a controlled toy in which a 2-D two-moons manifold is embedded in ${\mathbb{R}}^{30}$. We measure, for each rehearsal strategy, the residual distance of its samples to the data manifold (the norm of the component orthogonal to the principal subspace). Gaussian noise sits far off the manifold (distance $6.3$, versus $0.26$ for real data) and barely mitigates forgetting ($9.8\%$); a local manifold generator obtained from Oja’s principal-subspace rule [29] places its samples essentially on the manifold (distance $\approx 0$) and all but eliminates forgetting ($0.5\%$).

This explains why naive pseudo-rehearsal fails in high dimension [24]: as dimensionality grows, random inputs are almost surely off-manifold, so the old model labels meaningless points and the rehearsal is uninformative. It also identifies why an energy-based network is structurally suited to continual learning: because it is generative, it can dream on its own learned manifold—internal, context-modulated generation in the spirit of brain-inspired replay [25]—whereas a purely discriminative perceptron has no such generator. This geometric account also predicts the dataset-dependence we observe in Section 6: the harder the manifold is to model, the more the quality of the generator (not the continual mechanism) bounds the result.

We confirm this dependence directly by varying the capacity of the generator. Using a stable linear generator, the per-class principal subspace, the fixed point of Oja’s rule [29], we sweep the subspace dimension k and measure class-incremental retention (Figure 15). Retention rises monotonically with k, from $76.1\%$ with a single principal component to $88.1\%$ at $k=64$, and saturates as it approaches the oracle bound; at $k=16$ it already reaches $86.5\%$, matching the nonlinear generator’s headline $86.8\%$. Two readings follow. First, the continual mechanism is not the bottleneck: even a one-dimensional generator recovers four-fifths of the ceiling, far above the $19.3\%$ of vanilla learning. Second, the residual gap to the oracle is governed by how faithfully the generator covers the class manifold, exactly the quantity k controls, so a better generator, not a better replay schedule, is the lever for closing it.

Comparative performance

A fair reading of the evidence avoids the overclaim that local learning beats backpropagation outright. Table 11 summarises the honest picture: LEL matches backpropagation in raw accuracy (Theorem 2); it surpasses backpropagation-based regularization (EWC, SI) by a wide margin in class-incremental continual learning when equipped with local generative replay ($86.8\%$ vs. $\le 19.4\%$); it lags on current von Neumann hardware in speed and compute; and it holds structural advantages (activation memory, locality, biological plausibility) whose energy payoff is, so far, a hardware projection.

Cross-dataset generality.

Table 12 extends the comparison to Fashion-MNIST and CIFAR-10.

The mechanism generalises across all three datasets. The CIFAR-10 result ($37.0\%$) is deliberately modest: the joint-training ceiling is only $39.6\%$ and the oracle reaches $37.5\%$, so local dreaming recovers the attainable ceiling. The low ceiling reflects the shallow raw-pixel classifier, not the continual mechanism; the bottleneck is base representation quality (Figure 16).

6.4. Open Problem: Depth and Error Imbalance

Training a deep LEL network from scratch exhibits a clear depth barrier: at $D=10$ the per-layer equilibrium errors span six orders of magnitude (input-side $\sim {10}^{-8}$, output-side $\sim {10}^{-2}$), so deep layers receive almost no learning signal. Growing the network by “grafting” layers incrementally (each healed by local relaxation) improves a depth-8 ten-way network from $61.2\%$ to $84.5\%$, but it does not balance the errors; it works because each layer learns useful features while still near the output. This is essentially greedy layer-wise growth [32], reported here as a characterisation of the open problem, not a solution.

Figure 17. The depth/error-imbalance barrier in a $D=10$ LEL network: equilibrium prediction errors decay roughly one order of magnitude per layer toward the input, spanning six orders of magnitude, so the deepest layers receive almost no learning signal.

Figure 17. The depth/error-imbalance barrier in a $D=10$ LEL network: equilibrium prediction errors decay roughly one order of magnitude per layer toward the input, spanning six orders of magnitude, so the deepest layers receive almost no learning signal.

The downstream effect on accuracy is direct. Training a single-task MNIST classifier from scratch at increasing depth (one hidden layer up to eight, all of width 128), test accuracy falls monotonically from $84.0\%$ to $74.4\%$ (Figure 18 and Table 13): every layer added near the input is a layer that learns little, so it costs rather than adds capacity. Figure 17 shows the cause (vanishing equilibrium error) and Figure 18 the consequence (lost accuracy); together they bound the problem the remedies of Section 7 must solve before local learning can match backpropagation on deep networks.

Figure 18. Effect of depth on a single-task MNIST classifier trained from scratch with the local rule. Accuracy declines monotonically as depth grows, because the layers near the input receive a vanishing equilibrium error (Figure 17) and therefore barely learn.

Figure 18. Effect of depth on a single-task MNIST classifier trained from scratch with the local rule. Accuracy declines monotonically as depth grows, because the layers near the input receive a vanishing equilibrium error (Figure 17) and therefore barely learn.

7. Hardware, Applications, and Open Challenges

The structural properties of energy-based local learning—locality, generativity and in-memory compatibility—motivate dedicated hardware research and deployment contexts that the preceding benchmark cannot reach.

7.1. Hardware and Neuromorphic Realisations

A central motivation for backpropagation-free learning is hardware. On conventional von Neumann machines the dominant energy cost of both training and inference is not arithmetic but data movement: fetching weights and activations between memory and compute units costs one to three orders of magnitude more energy than the multiply–accumulate that consumes them [4]. Backpropagation aggravates this in two ways: it must store the entire forward activation graph for the backward pass, and it requires a transposed copy of the forward weights to route the error, the weight-transport problem [16], which has no natural physical realisation. Local methods avoid both: the error and presynaptic activity needed to update a synapse are available in situ, so the update can, in principle, happen where the weight is stored.

In-memory and analog computing.

This locality is precisely what in-memory and analog accelerators exploit. In a memristor or resistive crossbar, the synaptic weight is the conductance of a device, so a matrix–vector product is performed in place by Ohm’s and Kirchhoff’s laws, computation and memory are co-located and weight movement is eliminated [42]. The for deep learning this means lower data-transfer cost, higher compute efficiency per joule, and training and inference on the same device [43]. The feasibility of training in such memory is no longer hypothetical: analogue non-volatile memory has trained networks to software-equivalent accuracy on MNIST and CIFAR by performing the multiply–accumulate in place at the location of the weights [63], exactly the regime in which a local update rule that needs no transported weights is most at home (Figure 19).

In-situ local training on crossbars.

The point that matters for this survey is that crossbars favour local learning rules. Self-adaptive in-situ learning has been demonstrated in multilayer memristor networks [44]; parallel in-situ training has been realised with electrochemical RAM [34]; and activity-difference training, updating weights from the difference between two network states, a contrastive/equilibrium-style local rule that avoids an explicit backward pass, has been run directly on memristor crossbars [45]. These results make energy-based, local credit assignment a natural algorithmic match for analog hardware. The principal obstacles are device-level: non-linear and stochastic conductance updates and device-to-device variability degrade training accuracy, and overcoming them is an active hardware–algorithm co-design problem [46].

Neuromorphic processors and on-chip learning.

Digital neuromorphic processors provide event-driven, massively parallel substrates with on-chip plasticity: IBM TrueNorth runs one million spiking neurons below 100 mW [76]; Intel Loihi pioneered on-chip local learning [47]; its successor Loihi 2 and SpiNNaker2 are current event-driven platforms in which states and weights are held in local memory beside the compute [76,77]. Local rules are a natural fit, and EqSpike is the clearest algorithmic example: it recasts equilibrium propagation in a spike-driven form and, when mapped to silicon, is projected to cut inference energy by about three orders of magnitude and training by about two relative to a GPU, while supporting online on-chip learning [12]. A caveat: on-chip learning can itself dominate the energy budget, so the update rule must be hardware-aware [46].

Spiking implementations.

Bridging continuous local-learning theory and spiking hardware is an active area. Surrogate-gradient methods make spiking networks trainable by smoothing the non-differentiable spike [33], and analog surrogate-gradient training has been demonstrated on neuromorphic substrates [34]. The conversion of rate-based relaxation into event-driven dynamics, and the device variability such mappings must tolerate, remain the central trade-offs [46].

7.2. Representative Application Contexts

The benchmark focused on continual learning, but local equilibrium networks are also relevant where on-device adaptation, limited memory, or biological plausibility constrain the design.

Continual and lifelong learning.

This is the application tested here. Sequential learners must update after deployment without retaining every past example, and energy-based local networks offer a natural storage-free replay mechanism because they can generate samples from their own learned structure [20,67,68]. The benchmark in Section 6 should be read as a minimal reproducible case of that idea, not as a final solution for all lifelong-learning settings.

Perception and representation learning.

Predictive coding began as a model of cortical perception and remains useful as a generative representation learner: a hierarchy that minimises prediction error can also learn features and reconstruct missing or corrupted inputs [7,8,69,73]. For the present paper, this matters because replay quality depends on whether the generator captures the data manifold; the CIFAR-10 limitation is therefore partly a representation limitation.

Edge, robotics and neuromorphic deployment.

Local updates are attractive when devices face strict memory, bandwidth and energy budgets, as in embedded perception, adaptive robotics and streaming sensorimotor control [12,34,47,76,77]. The claim is conditional: on ordinary CPUs the iterative relaxation is slower than backpropagation, but on in-memory or neuromorphic substrates locality may reduce data movement. That hardware advantage remains to be measured for the full continual pipeline.

7.3. Open Challenges and Research Programme

The evidence assembled in this survey—coherent theory, a reproducible case study and a hardware case that is strong in principle—also marks where the field needs to go next. Three barriers must be overcome before local continual learning can move beyond image benchmarks, and the community is actively working on all three.

Depth and scaling.

The depth/error-imbalance barrier is the central open problem of local learning. Backpropagation itself only conquered very deep networks through residual connections [5] and normalisation [6]; local learning still lacks a comparably mature toolkit, and importing these ideas is part of the active effort below. As our testbed shows (Section 6, Figure 17), training a deep energy-based network from scratch leaves the layers near the input with vanishingly small equilibrium errors, so they barely learn; vanilla predictive coding is known to degrade once the stack grows beyond a handful of layers. Several complementary remedies are under active investigation, which we group by the mechanism they target.

Parameterisation, re-balancing and better schedules.

Depth-aware parameterisation, adapting $\mu$P-style scaling to inference dynamics, keeps activity learning rates stable across width and depth. Precision-weighting of per-layer errors redistributes the energy during relaxation, the natural remedy for the imbalance our testbed exhibits (Figure 17). Prospective-configuration-style training separates inference from plasticity, making the learning rule easier to analyse and improving sample efficiency [10,31].

EqProp at scale and shared benchmarks.

Reducing the bias of the finite-nudge gradient estimator enabled scaling to deep convolutional networks [36]; standardised benchmarks are beginning to make cross-method comparison fair [31]. The problem is actively contested but not closed, and our reproducible testbed (Figure 17) is a small, transparent instrument for studying it.

Nudge, weight symmetry and the two-phase requirement.

Energy-based methods classically require either an infinitesimal nudge (EqProp) or clamped outputs (PC), and often symmetric weights, requirements that are awkward biologically and on hardware. Recent work relaxes the infinitesimal-nudge assumption with finite-nudge formulations, while feedback-alignment results show that exact weight symmetry is not strictly necessary for useful learning [16]. Reducing or eliminating the two-phase structure, and quantifying the bias introduced by finite nudges, remain open.

Modern architectures.

Almost all local-learning results concern multilayer perceptrons and convolutional networks; extending local credit assignment to the architectures that dominate contemporary AI, attention and transformers [3], is largely unexplored. Sequential tasks remain dominated by LSTM networks and their variants [2]; a local formulation of attention-based sequence processing has not yet demonstrated comparable accuracy on standard benchmarks. Whether an energy-based or forward-only formulation of self-attention can match backpropagation is, to our knowledge, an open and high-value question.

Theory and evaluation.

Theoretical understanding is advancing (Lyapunov stability of the inference dynamics [60], the infinitesimal-inference limit that links these methods to backpropagation [9,11]), but generalisation guarantees, convergence rates under realistic conditions, and the interaction between inference accuracy and learning remain partially open. On the empirical side, the field has historically suffered from inconsistent benchmarks; unified evaluation suites and reproducible studies such as this one are needed for cumulative progress [31].

Computational and energy trade-offs.

On von Neumann hardware LEL is more expensive: the T-step relaxation costs $\sim 5\times$ the operations of backpropagation and was $\sim 7.5\times$ slower in our CPU measurement; we claim no speed advantage there. Its structural benefits are (i) activation memory $O\left(\mathrm{width}\right)$ vs. $O(\mathrm{depth}\times \mathrm{width})$, and (ii) locality, which permits execution on in-memory and neuromorphic substrates that backpropagation cannot easily use because of the weight-transport problem [16].

The structural reason is data movement: off-chip DRAM access costs about two orders of magnitude more energy than the arithmetic it feeds [4], so on von Neumann hardware training energy is dominated by shuttling weights and activations rather than by multiply–accumulate operations. Because every LEL update reads only quantities already present at the synapse, it can execute where the weight is stored, eliminating the dominant data-movement term and projecting a 120–$1200\times$ reduction relative to backpropagation on DRAM—consistent with figures reported for spike-driven equilibrium and surrogate-gradient learning on neuromorphic substrates [12,33,34]. Backpropagation cannot occupy this regime at all because its backward pass requires a transported copy of the weights. We stress that this is a projection from per-operation figures, not a device measurement; the numbers in Table 14 quantify the on-hardware cost.

Empirical failures and scope limits

The negative results are first-class findings, not caveats appended after the fact. They separate what failed empirically from what remains outside the scope of this benchmark.

Negative empirical results

Vanilla local learning does not beat backpropagation in accuracy or forgetting; because the equilibrium update approaches the backpropagation gradient (Theorem 2), it inherits catastrophic forgetting unless an additional retention mechanism is added. Weight regularization also failed in the class-incremental setting: EWC and SI stayed near chance, and the energy-based EWC variant destabilised relaxation by pulling weights away from the contractive regime required by Proposition 1. Noise replay failed for a different reason: random samples lie off the data manifold and therefore do not recreate meaningful old-task decision boundaries. Finally, simple “free” fixes for depth, including metaplastic per-synapse learning rates and homeostatic norm control, did not remove the error-imbalance barrier.

Depth limitation

The strongest algorithmic limitation is depth. In the current implementation, layers near the input receive equilibrium errors several orders of magnitude smaller than layers near the output, so adding depth can reduce rather than improve accuracy (Figure 17 and Table 13). Grafting helps by allowing early layers to learn while they are still close to the output, but it does not solve the underlying imbalance. The manuscript therefore does not claim that LEL is ready for very deep networks; it identifies a reproducible failure mode that future local-learning methods must overcome.

Computational-cost limitation.

LEL is not faster on standard von Neumann hardware. The iterative relaxation requires multiple state updates per training sample, making it roughly 5–$7.5\times$ more expensive in our measurements than a matched backpropagation baseline (Table 14). The possible advantage is structural rather than immediate: local updates reduce activation storage and may avoid costly data movement when executed in memory or on neuromorphic hardware. Until that full pipeline is implemented and measured on a device, the energy argument remains a projection.

CIFAR-10 limitation

The CIFAR-10 result is deliberately modest. A final accuracy of $37.0\%$ would be unacceptable if the paper were claiming competitiveness with modern backpropagation-trained CNNs or Transformers. That is not the claim. The experiment tests whether the same local replay mechanism still recovers most of the available ceiling when the base model is a shallow raw-pixel classifier. It does ($37.0\%$ out of a $39.6\%$ ceiling), but the low ceiling shows that useful deployment will require stronger local representations, feature-space replay or a more capable local generator.

Scope limitation

The benchmark uses small networks, public image datasets and controlled task sequences. It does not address large-scale foundation models, naturalistic non-stationarity, continual reinforcement learning or measured hardware energy. These omissions are intentional: the purpose is to provide a clean reference point where the role of local credit assignment, replay, generator quality and memory budget can be inspected without hidden pretrained components.

Research programme

Table 15 translates the open challenges above into testable tasks, tracing a path from the current proof of concept—local generative replay on image benchmarks—toward scalable, hardware-native continual learning without backpropagation.

8. Conclusions

This survey set out to answer one concrete question: can a backpropagation-free network keep learning without forgetting? The answer is yes, but only with the right retention mechanism, and that finding requires common, reproducible ground rather than the scattered formulations, notations and benchmarks that have fragmented the local-learning literature. We organised the two halves of the problem (backpropagation-free credit assignment and continual learning) into one taxonomy, expressed the energy-based family through a single transparent formulation, re-derived and numerically re-validated its core theory, and ran a controlled empirical case study across three datasets and two independent implementations. The intent was never a new learning rule, but a synthesis, reproducibility package and benchmark that make the field legible and give others a concrete baseline to extend or falsify.

Empirical synthesis

Across three datasets and two independent implementations the results converge on a clear hierarchy: generative dreaming is the only retention mechanism that works reliably under the strict Class-IL protocol. EWC and SI remain near chance; noise replay fails because random samples lie off the data manifold; only locally generated “dream” samples, drawn from the energy-based model’s own learned distribution, recreate the decision boundaries needed to prevent catastrophic forgetting. The effect is quantitatively large and general: local dreaming reaches 86–$88\%$ retention on Split-MNIST ($96\%$ of the joint-training ceiling) and 96–$98\%$ of the ceiling on Fashion-MNIST and CIFAR-10, reproduced in a second independent implementation. The remaining gap to the oracle ceiling is governed by generator quality, not by the continual mechanism—a conclusion the generator-capacity ablation confirms directly (Figure 15).

What the evidence shows

Four findings hold up across every dataset and both implementations. First, local energy-based learning matches backpropagation in supervised accuracy. This is well understood by now, because the local update equals the backpropagation gradient in the small-nudge limit (Theorem 2, Figure 8), and that we confirm rather than claim as novel. Second, precisely because of this equivalence, vanilla local learning inherits catastrophic forgetting; locality is not, by itself, a cure. Third, the cure is structural rather than regularisational: weight anchoring (EWC, SI) fails in the class-incremental regime, and when ported to the energy-based setting it even destabilises the inference relaxation. Generative replay, by contrast, succeeds, and energy-based networks support it natively because the same network that discriminates can dream on its own learned data manifold. Fourth, the resulting effect is large and general: local dreaming converts chance-level forgetting into 86–$88\%$ retention on Split-MNIST ($96\%$ of the joint-training ceiling) and reaches 96–$98\%$ of the ceiling on Fashion-MNIST and CIFAR-10, reproduced in a second programming language. The limit is as clear as the result: the absolute number is set by the quality of the base classifier and the generator, not by the continual mechanism, and we isolated this experimentally rather than just asserted it, showing retention rise monotonically with generator capacity toward the oracle (Figure 15).

Why it matters

These results recast backpropagation as one credit-assignment choice among several rather than a law of learning. The case for the alternatives is not, today, that they are more accurate; they are not, a conclusion consistent with broader reviews of continual and biologically inspired learning [19,65,66]. It is that they are structurally different in ways that matter for where computing is heading: they are local, so they need neither a stored computation graph nor a transported copy of the weights; they are generative, so they can rehearse the past without storing it; and they update online, which is the native regime of systems that must keep learning after deployment. These are exactly the properties an energy-, memory- and data-movement-constrained future rewards, and they are the reason the intersection of local learning and continual learning, the niche this survey occupies, is worth taking seriously.

What remains open

We have been deliberate about not overclaiming. On conventional von Neumann hardware the approach is several times slower and more energy-hungry than backpropagation; its energy advantage is a principled projection onto in-memory and neuromorphic substrates, not a measurement we made. Training degrades in very deep networks because the layerwise equilibrium errors become exponentially imbalanced. We reproduce this open problem honestly, and the community is actively attacking it through reparameterisation, energy re-balancing and better inference schedules (Section 7). And the extension of local credit assignment to the architectures that dominate contemporary AI, namely attention and transformers, remains almost entirely unexplored. We also reported, as carefully as the positive results, what did not work: naive energy sampling diverges, regularisation destabilises the relaxation, and the most natural “free” fixes for the depth barrier did not help. These negative results are part of the contribution, because they delimit the design space for those who follow.

Outlook

The most important next step is to stop projecting and start measuring: to express the relaxation and the generative dreaming in a spiking or analog form and report joules on real neuromorphic devices, converting the structural energy argument into evidence. In parallel, importing the depth remedies surveyed here into the continual-learning pipeline, and probing whether an energy-based or forward-only formulation of self-attention can match backpropagation, would tell us whether local learning scales to the problems that matter most. We have tried to lower the barrier to all of this by releasing the unified formulation and every experiment as small, dependency-light, independently reproduced scripts. The primary contribution of this review is to establish a reproducible baseline and clarify the research agenda for local credit assignment in continual learning—not to resolve it.

Appendix B.1. Signs and Objectives

In the supervised, fully clamped version used for most experiments, the output state is fixed to the target during relaxation. The layer error is ${\mathbf{e}}_{\ell }={\mathbf{x}}_{\ell }-f({\mathbf{W}}_{\ell }{\mathbf{x}}_{\ell -1}+{\mathbf{b}}_{\ell })$, and the local weight increment is proportional to $(f^{\prime }\left({\mathbf{a}}_{\ell }\right)\odot {\mathbf{e}}_{\ell }){\mathbf{x}}_{\ell -1}^{\top }$. This sign is chosen so that the update descends the reduced free energy. It is tempting to compare this update directly with the backpropagation gradient of the supervised loss, but in the fully clamped regime the objectives are not identical. The exact comparison to backpropagation is the nudged regime of Theorem 2, where the output is softly pulled toward the target and the limit $\beta \to 0$ is taken. This distinction explains why the theorem-validation script reports two different behaviours: full clamping saturates below perfect cosine alignment, while the small-nudge update approaches alignment one.

Appendix B.2. Relaxation Stability

The inference step size $\gamma$ is a stability parameter as much as a speed one. If $\gamma$ is too small, the network may not approach equilibrium within the chosen budget T; if it is too large, the activities oscillate or diverge. A simple diagnostic is to track the free energy or the norm of the state gradient across relaxation steps. In a stable run, the energy should decrease or at least settle after a small transient caused by finite-step discretisation. When the energy grows systematically, increasing epochs or replay samples will not fix the experiment; the state dynamics themselves are outside the contractive regime assumed by Proposition 1.

Appendix B.3. Finite Inference and Biased Updates

The envelope theorem gives the local gradient at equilibrium. In code, equilibrium is approximated by a finite number of steps. The resulting update is biased, and the bias is controlled by both the relaxation budget T and the conditioning of the energy landscape. This is why T should be reported even when accuracy appears insensitive to it. A shallow network may work with $T=1$ or $T=2$ because the forward initialisation is already close to equilibrium; a deeper network may require more steps, different precisions or residual dynamics before the same claim is meaningful.

Appendix B.4. Clamping, Nudging and Test-Time Inference

Training and testing use different operations. During training, the input and either the output target (clamped case) or a soft output penalty (nudged case) participate in the energy. During testing, the experiments here use the feedforward prediction for classification, because no target is available. One can also run free relaxation at test time, but then the protocol must specify which variables are clamped, which are free, and how the predicted label is read out. Mixing these conventions across methods can change the result, especially in recurrent or strongly energy-based models.

Appendix B.5. Generator Training and Labelling

The dreaming pipeline contains two models: a generator for samples and a frozen classifier for labels. The generator should be trained only on the current class data when that class is first seen. Later, it is sampled without access to old raw data. The labels assigned to dreams come from the frozen previous classifier in the general pseudo-rehearsal setting; in controlled variants one may use class labels directly, but then the experiment is no longer testing the same self-labelling mechanism. This difference should be stated because it affects whether errors in the old classifier are propagated into the rehearsal set.

Appendix B.6. Minimal Pseudocode for One Task Transition

The following task-transition view is often easier to implement than the full algorithmic listing. Let ${\theta }_{k-1}$ be the classifier after task $k-1$, and let $\{G_c:c\in {\mathcal{S}}_{k-1}\}$ be the stored local generators for old classes. For a new task with data $D_k$, create a training set

$${\tilde{D}}_k=D_k\cup \{(G_c\left(z_i\right),{\theta }_{k-1}\left(G_c\left(z_i\right)\right)):c\in {\mathcal{S}}_{k-1},i=1,\dots ,n_d\}.$$

(A1)

Then train the classifier locally on ${\tilde{D}}_k$, train new generators for the new classes, and freeze a copy of the classifier for the next labelling step. The important feature is that past raw data never enter ${\tilde{D}}_k$; only generated samples do.