Nested Learning: A Fix for Catastrophic Forgetting

What Is Nested Learning?

Nested Learning is a machine learning paradigm that treats a single model not as one architecture trained by a separate optimizer, but as a set of nested optimization problems that each learn at their own speed. It reframes the model's architecture and its training algorithm as the same kind of thing, different levels of learning that run and adapt at the same time.

It organizes a machine learning system into multiple learning levels that operate at different timescales. 

• The parameter level learns slowly across thousands of training steps. 
• The memory level decides what information to retain across recent inputs. 
• The optimizer level learns how to update the levels below it. 

Higher levels can influence how lower levels behave, which is what makes the structure hierarchical rather than just modular.

Key principles of nested learning

Nested learning follows these four key principles:

• Architecture and optimization are part of the same learning system. In Nested Learning, the optimizer becomes part of the learning process and can adapt over time.
• Different components learn at different speeds. A model's core parameters might update slowly over thousands of examples, while a short-term context mechanism updates with every new input, and a memory system updates somewhere in between.
• Depth comes from nested learning processes. Traditional deep learning creates depth by adding layers. Nested Learning creates depth by stacking multiple levels of learning and adaptation, where parameters, memory systems, optimizers, and update mechanisms can all learn at different timescales.
• Learning can continue after deployment. Components such as memory systems and learning mechanisms can continue adapting during inference, too.

Nested learning vs traditional deep learning

For years, we’ve relied on deep learning architecture, where data flows through a neural network, measures how wrong the model's predictions are (called the loss), and runs an optimizer that adjusts the model's parameters to reduce that error. 

You repeat this until the model is good enough. Then you freeze the parameters and deploy the model. From that point on, it doesn't learn from new inputs, doesn't adapt to shifts in the data, and doesn't improve with use.

Nested Learning changes that. Along with the model's parameters, memory modules, optimizers, and other components also continue learning over time.

Why Nested Learning Matters

A model learns new information by updating its parameters, but those same updates can overwrite knowledge it learned earlier. This phenomenon is known as catastrophic forgetting.

Researchers have introduced techniques such as freezing layers, regularization methods like Elastic Weight Consolidation (EWC), and replay buffers to preserve previous knowledge while learning new tasks. But these approaches are designed to protect a model from forgetting, not to fundamentally change how learning happens.

Nested Learning argues that this single-timescale approach is one of the reasons continuous learning remains so difficult. Instead of relying on a single set of parameters to absorb every new piece of information, it spreads adaptation across multiple learning levels. 

Different levels adapt at different speeds, making it possible to incorporate new information without constantly rewriting older knowledge. This idea is partly inspired by how human cognition works. After all, not all learning happens at the same pace:

• Reflexes can adapt almost instantly. 
• Short-term memories form over minutes or hours. 
• Beliefs, habits, and expertise may take months or years to develop.

How Nested Learning Works

Nested Learning organizes a machine learning system into levels, each a distinct learning process with its own role and update speed. To understand how they work, it helps to walk through each one and see how they connect.

The parameter level

Parameters are the weights inside the neural network that store what the model has learned from its training data. During training, the optimizer updates these weights after every batch using the computed gradients. 

Each update is small, so meaningful changes happen gradually over many training steps. As a result, the parameter level learns stable, long-term knowledge but is slow to adapt to new information.

The memory level

The memory level captures information from recent inputs that the parameter level is too slow to learn. 

Rather than storing everything it sees, it retains the most useful information and discards the rest. This allows the model to adapt to a new context without immediately updating its long-term knowledge.

The optimizer level

The optimizer decides how the model's parameters should be updated during training. It uses the gradients computed from the model's predictions to determine the size and direction of each update.

Adaptive optimizers such as Adam do more than use the current gradient. They also keep track of recent gradients and use that history when computing the next parameter update.

If Adam already does this, what does Nested Learning add?

The difference is in what can be learned. In standard deep learning, the rules governing how Adam updates its state are fixed before training starts and never change. Adam adapts the parameters, but nothing adapts Adam. 

Nested Learning introduces a meta-learning process above the optimizer that can evaluate how the optimizer is performing and modify its rules over time. The optimizer stops being fixed infrastructure and becomes something that can itself improve.

How the levels interact

These different levels don't work independently. Information flows between them, and each level influences how the others learn over time. 

• The parameter level gradually builds long-term knowledge through training. 
• The memory level provides recent context that helps the system respond to new information more quickly. 
• The optimizer determines how the parameters are updated. 

Together, the levels allow the model to balance short-term adaptation with long-term learning.

The Hope Architecture

Hope is the paper's proof-of-concept architecture, a self-modifying variant of the Titans architecture that Google built to test whether nested learning actually works in practice. It pairs a memory that can rewrite its own update rules with a Continuum Memory System, so it can keep learning at several different speeds instead of freezing after training.

Self-modifying Titans

Titans contain memory modules for storing information that the model considers surprising or important. Instead of relying only on its parameters, the model carries useful information forward through these memory modules.

Hope goes one step further. As new data comes in, the memory modules continue updating. The system also adjusts the rules it uses for future updates. That's why the architecture is called self-modifying.

Continuum Memory System

Most memory architectures split memory into two buckets: short-term and long-term. Information either lives in a fast, temporary store or gets consolidated into stable long-term storage. Hope replaces that binary split with a continuum, a spectrum of memory modules that update at different speeds.

Some memory components update rapidly and capture recent information. Others change more slowly and preserve stable knowledge accumulated over longer periods. That means new information can enter through the fast-updating layers without immediately disrupting slower, more stable memory.

How Hope performs

The paper evaluated Hope on language modeling, long-context reasoning, continual learning, and knowledge incorporation, using different baselines for different tasks. Language modeling and common-sense reasoning were benchmarked against Titans, Samba, and a standard transformer, while the long-context retrieval tasks compared Hope and Titans against TTT and Mamba2.

On language modeling and common-sense reasoning benchmarks, Hope achieved lower perplexity and higher accuracy than all three baselines.

The more telling results came from tasks that require the model to retrieve a specific piece of information buried inside a long context. The paper tested multiple variants of increasing difficulty: pass-key retrieval, number retrieval, and the hardest variant, word-level retrieval. Hope outperformed the baselines across all variants, with the CMS design specifically contributing to the long-context gains.

The architecture also performs well on continual learning benchmarks. When trained across sequences of tasks that typically cause catastrophic forgetting, Hope retains more previously learned knowledge than the comparison models reported in the paper.

Nested Learning vs Other Continual Learning Approaches

Nested Learning isn't the first attempt to address catastrophic forgetting. For years, researchers have proposed continual learning techniques to let models retain previously learned knowledge while learning new tasks. Let’s see the key differences across proposed approaches.

Methods like EWC, Progressive Neural Networks, and Experience Replay are neural networks that slow down forgetting during training. The underlying architecture remains largely the same. 

Nested Learning rethinks the architecture itself, so that learning happens across multiple levels and timescales: fast-changing memory handles recent experience, while slower-changing parameters capture long-term knowledge.

Nested Learning in Practice

Unofficial community reproductions have started appearing on GitHub, giving researchers a way to experiment with the architecture and attempt to reproduce the published results.

That said, Nested learning has no official integrations with major deep learning frameworks, and you can't simply pip install nested learning and add it to an existing PyTorch or JAX project. Building and evaluating these models still requires working directly with research code.

But the direction is focused on community adoption. So watch for Hope or Continuum Memory System (CMS) modules to be integrated into mainstream frameworks and adopted in production systems.

Final Thoughts

Nested Learning challenges one of the core assumptions behind modern deep learning. Instead of making models more capable by stacking more layers, it explores whether intelligence can emerge from multiple learning processes operating at different timescales.

That shift also changes how we think about optimization. Traditional deep learning treats the model architecture and the learning algorithm as separate components. Nested Learning brings them closer together with the aim of making learning itself hierarchical.

It's still the early days. Nested Learning remains an active area of research, and many of its ideas will need broader validation before they become part of mainstream machine learning. If you'd like to build a stronger foundation in the concepts behind nested learning, including neural networks, optimization, and memory mechanisms, I recommend checking out our comprehensive Deep Learning in Python track.