Two Endangered Languages Broke Transformers. Nested Learning Gave Models a Sleep Button.

Nathan Labenz introduces Ali Behrouz as a Cornell graduate student, Google researcher, and author of Nested Learning — work Jeff Dean has called a harbinger of a possible paradigm shift. Labenz recorded the conversation months earlier and says it is an exception to the rule that AI content ages badly: genuine continual learning is, in his view, the main remaining gap between today's models and a digital AGI that could join a human team. Behrouz's follow-on paper, *Language Models Need Sleep*, was still unpublished when they sat down. It gives models an offline mode that distills fast-updating layers into slower ones and trains on synthetic data drawn from recent experience.

Behrouz likes taking inspiration from brains and from evolution, but he draws a hard line against copying them. The brain is a rich source of high-level rules; it is a bad template at fine granularity, both because we do not actually know how it works and because over-fitting to one biological design would lock the field onto a single form of intelligence. Titans used a surprise metric and a split between short- and long-term memory. He doubts the brain is literally running gradient descent to compute surprise. Keep the inspiration at the level of rules, he says, and leave the implementation details alone.

The gaps he is trying to close are specific. First, models cannot adapt to the environment and context they are in. Second, they cannot take in new knowledge, write it into parameters, and keep old skills — the classic catastrophic-forgetting problem. Large models make both worse: updating every parameter is too expensive, and supervised fine-tuning or RL can still wipe earlier tasks. Ask GPT a factual question and forbid tools, and the answer stops at the knowledge cutoff. Keeping everything in token space — ChatGPT-style memory, ever-longer context — only postpones the issue. Sooner or later the window fills, and whatever was in context has to be compressed into the weights.

Labenz puts the same crack in user terms. The biggest advantage he still has over an AI is ongoing coherence: he knows who he is in the morning, remembers where yesterday left off, and can pick the work back up. Current models wake as a blank slate. That is why the original Mamba paper excited him — a competitive architecture with a *fixed-size* memory, which is the only kind that can scale, because quadratic context cannot grow forever. Titans pushed the idea further: a bounded memory module updated with gradient descent at runtime, keeping what it needs and letting the rest go.

He also asks what the destination looks like, not just the defect. Today's systems are mostly chatbots that sit inert until a message or a cron job wakes them. Does Behrouz want something more like another person with AI advantages, or an LLM with the holes patched? Behrouz's technical answer starts forty years back. Almost the entire literature assumes a training phase and a test phase. A true continual learner has neither. If a design still names a test time, it is not yet a true continual learner.

That does not mean the life of the model is one uniform process. Behrouz wants at least two phases. In the active phase the model receives inputs — a user query, a vision stream, a world-model observation — and computes on them. In the other phase it is blocked from the outside world. The question is whether it should go static, or whether an artificial brain should keep working on what is already inside its parameters. He is willing to call the second phase sleep: no inputs, but internal computation for consolidation and self-improvement. An ideal model would be good at both.

Scale is why the split matters in practice. Even academic papers now train models with a billion or two parameters, and keeping a model that size updated is expensive. Nested Learning started as a way around that: at each timestamp you do not update everything, only a small subset of the parameters. After a sponsor break he restates the compass. Do not obsess over what humans can do. Obsess over what humans want from AI. Current assistants that remember how you like an email written are promising because they are aimed at needs, not at a replica. "LLM needs sleep" does not mean the model should rest. It means brains appear to follow a general rule: a phase of taking data in, then a phase of processing it, consolidating memory, and finding patterns.

Labenz offers a lay summary of the paper. For years the field bought more expressivity, or computational depth, by stacking the same block 80 or 120 times. Nested Learning puts a different unit on the stack: *levels*, distinguished not by position in a forward pass but by how often they update. Some parts of the system can be almost real-time; others barely move. That is closer to a person. What is on Labenz's mind this morning reflects breakfast; his big-picture views of the world did not change between then and now. Different kinds of knowledge were always going to need different clocks.

The authors spent more than a year and a half on the paper, and Behrouz says the hardest part was writing down, mathematically, what they wanted. The framework that survived has two legs. One is update frequency: each module gets time to do something while it waits. The other is knowledge transfer between levels. A slow network is expensive idle time unless the fast network hands it something worth having. Fast levels should specialize in high-resolution, rapid adaptation; slow levels should specialize in higher-level abstraction. Those two mechanisms, frequency and transfer, are what make the levels complementary rather than redundant copies of the same MLP.

He also wants to collapse a pile of overlapping jargon. Today's models are already cheap relative to matching them with humans on some tasks; more computation per parameter looks like internal thinking rather than a single pass from token to next token. Nested Learning's other claim is that almost everything in deep learning is already a form of in-context learning — backpropagation as associative memory, pre-training as in-context learning, attention and RNNs as in-context learning. New words should mark new concepts, he says, not relabel the same one. The two things nested learning is trying to buy are more computation per neuron and more adaptable, continual behavior.

The simplest picture starts from a Transformer. Attention mixes tokens over the current context; the MLP is the long-term memory, frozen after pre-training. Hope attention keeps the attention block and replaces the single MLP with several, each updated at a different frequency — what the paper calls a continuum memory system. Attention remains a near-perfect cache, fast and complete. The first MLP can now forget something from a few thousand tokens ago, which would be catastrophic forgetting if it were the only memory. The slower MLPs have not moved yet, so the forgotten content is still in their parameters. Backpropagation through the stack can bring it back. Forgetting is allowed. If the content mattered, it returns from the slow layers.

That is a modest extension of the Transformer block, and Behrouz is explicit about attention's job. It is an infinite-frequency update module. It does not, on its own, know temporal order, which is why it needs positional encodings, and even with those it is a weak sequential reasoner. Full Hope therefore replaces attention with another associative memory that maps keys to values: a Titan, then a *self-modifying* Titan. Linear chunked Titan updates can be made richer by a self-referential process. Gradient descent is already one. The idea, going back to Schmidhuber, is learning how to learn, nested as far as compute allows. In this design, the memory generates its own value from its own parameters, then maps keys onto that value. The process is sequential and causal, which is why Behrouz expects it to beat softmax attention on tasks that need sequential thinking.

Labenz objects that Transformers already learn Q, K, and V. Behrouz's distinction is about *control*. In softmax attention, projections produce Q, K, and V, and attention has no say in those projections. Write gradient descent as W_t minus the gradient, expand the gradient by the chain rule, and the update looks like linear attention: a key (the input) mapped to a value (the gradient w.r.t. the output). The twist is that this value is a function of the *current* weights. The value is not handed in from a module upstream; the recurrent process generates it every step. In a self-modifying Titan, the Q, K, and V projection parameters themselves are optimized *inside* the Titan. The model is modifying its own update rule.

Labenz maps that onto Mamba's unlock: the way the state updates became a function of the input, and expressivity jumped. Behrouz says the intuition is right. Value projections update inside the module, so every incoming token is a chance to learn, and the way the memory writes a value is the same process as the way it updates itself. From a researcher's chair, Hope attention is close to today's training loop. You still run data through the model. The difference at inference is bookkeeping: for each MLP, is this the step it updates? If not, use the last frozen state; if so, backprop over the current chunk, then run. The model does not know train from test. Researchers still need an evaluation window. Full Hope is the same story with attention swapped for the self-modifying Titan.

The core block — attention or self-modifying Titan, plus the MLP continuum — can be stacked into layers, and that is the main Hope design. It is not the only wiring. If you want to start from a pre-trained Llama, you cannot rebuild the whole stack, so they interleaved: attention and an MLP at one frequency, attention and an MLP at another, and so on. Behrouz does not think the two layouts are fundamentally different. Labenz hears Ilya Sutskever's old line that models just want to learn. Titans had three ways to slot a memory module into a larger net; Mamba has been Lego-pieced in sequence and in parallel. Once the new brick is real, the exact diagram matters less than the brick.

Relative sizes, learning rates, and frequencies are still mostly intuition. Treat each block like a normal MLP, Behrouz says; conventional hyperparameter methods should transfer, and he has not done a careful study of learning rates per level. The frequencies they actually used came from Titans chunk sizes: as he remembers it, 128 tokens, then four times that, then four times that again — 128, 512, 2048. Skip connections and the rest of the deep-learning toolkit stay. Nested learning, he stresses, does not contradict attention, residuals, or backprop. It claims to be a more general frame in which those pieces are special cases. Inside attention there is already a regression problem whose non-parametric solution *is* attention. Deep learning shows you the final solution of each inner problem; nested learning shows you the inner learning process as well.

Why multiple frequencies at all? Behrouz's parable is a pair of twins. One rides a ship near the speed of light and comes home to find eighty years have passed on Earth. The sibling who stayed has forgotten the launch; the traveler remembers it in detail, because that memory was barely overwritten. Persistence is a function of how many times a memory is updated. Before the fast MLP updates — and therefore before it is at risk of forgetting — it can hand what it knows to the slower one. Context distillation is one transfer method, and it is close to what the sleep paper does. Backprop through sequentially stacked MLPs is the other, more ordinary path.

Labenz wants the other direction too: slow layers steering fast ones, the way higher-order processes tell the eyes where to look. Behrouz's worked example is the sleep distillation itself. Copy model A to model B. Update B's fast MLP, which wipes the information that A still holds there. Then train B's slow MLP so B's output mimics A's. The only difference between the two models was the fast layer; if B can match A, that knowledge now lives in B's slow parameters. In Nested Learning proper, they mostly let gradient descent do this without extra machinery. "In the whole picture," Behrouz says, "everything is just like backpropagation." Labenz's meta-takeaway is that this is still proof-of-concept. None of it has been hyperparameter-swept the way frontier models are. A few core ideas — different MLP frequencies above all — already produce qualitatively different behavior.

The result Behrouz likes most is a continual-learning-style translation probe. Give a pre-trained model a grammar and dictionary for a language it has never seen, in context, then ask it to translate. Quality is high. Put *two* such languages in the same context and a Transformer almost collapses: it cannot keep the two systems separate. Switch to Hope attention, keep the softmax, add MLP levels, and as you go from Hope 1 to Hope 2 to Hope 3 the scores on both languages climb. Temporary knowledge sits in the fast MLP; deeper understanding of each language moves into more stable blocks. Labenz recognizes the setup from Gemini's "learn a language from one book" demos. The paper uses Manchu, a critically endangered language, plus MTOB, another held-out language from a late-2023 benchmark. One language: everyone is similar. Two languages: only extra frequency levels bring performance back near the single-language baseline.

The models are small on purpose: 760 million parameters on 30 billion tokens, and 1.3 billion on 100 billion. Labenz notes they still beat Transformer, Mamba variants, Titans, RetNet, and DeltaNet on a standard perplexity-and-accuracy table. Behrouz is blunt about that table. The community expects pre-training perplexity and short-context language-modeling scores, even though those tasks do not need the thing nested learning is for. In the NeurIPS talk he used the table only to show Hope is not a *weaker* backbone. Any gains there are a bonus. The point is elsewhere.

On micro-skills, pure in-context recall is a Transformer sport. A human cannot needle-in-a-haystack a value of `x` from thousands of lines of code; softmax can, because it still has the raw history. Recurrent models have been closing that gap generation by generation. Hope, a compression-based model, closing most of it is what surprised Behrouz; the paper reports effective recall out to 10 million tokens. The MAD suite flips the advantage. Noisy in-context recall turns attention's full cache into a liability: it cannot tell signal from noise. Hope does best when memory management can filter. Compression — squash a span into one token and reconstruct — is native to RNNs and hard for Transformers. Behrouz's rule is not to freeze the eval on a single metric designed for the incumbent.

The paper's subtitle word — *illusion* — is the conceptual jump. Every component in deep learning, Behrouz argues, is a learning problem whose final solution is all we usually see. Attention is a regression; the non-parametric solution is attention. Backprop is in-context learning. Pre-training is too. Architecture and optimizer are the same kind of object. The only difference is the context: tokens on one side, gradients on the other. Momentum is already an associative memory that compresses gradients. If the architecture is complicated, the gradient stream is complicated, and the momentum memory has to be more powerful.

So they borrowed the continuum-memory trick from the architecture side and applied it to the optimizer. The result is M3: multiple memories compressing the gradient context at different frequencies, aimed at a more global read of the loss landscape. In their evals it beats Adam and Muon, with some extra compute paid back in faster convergence. Behrouz immediately qualifies the leaderboard. Optimizer rankings are task-dependent; a vision result can reverse on language models. The deeper argument is that architecture and optimization are one nested system, and you should design them together. Nested learning does not throw out known pieces. Hope, he says, is backpropagation. There is no extra engineering in the inner loop.

A true continual learner still has an online active time and a time with no inputs. Sleep is whatever internal work you choose to put in that second window; the paper implements two pieces that fit Behrouz's research. Consolidation is distillation. Fast and slow are relative. When knowledge moves up a level, they activate extra parameters on the receiving side so it has capacity, then free the extras after the transfer so the model does not grow without bound. It is a periodic add-and-remove, not an expanding brain. Labenz asks whether the net ever shrinks. Behrouz says you cannot grow to an arbitrary size; when a block hits capacity you consolidate, then strip the surplus so faster levels can write in again.

The analogy is learning a mathematical rule. First you memorize examples. Then the brain throws the examples away and keeps one rule that covers them. Later, with more reading, you replace that rule with a more general one. Distillation is what forces the second move. A naive copy from fast to slow changes nothing. Distillation stores the same knowledge in fewer parameters, which only works if the model finds a more general pattern. Each sleep cycle repeats that squeeze. Fast layers are the memorization stage — lots of content, little understanding, easy to forget. Slow layers are asked to hold the same content with less room.

Dreaming is the second operation, and it is not human dreaming. A vision model might generate images; a language model generates text. The procedure is on-policy distillation. Sample the start of a sequence from the small model that still holds the context in its weights, then ask the model being updated to continue it. If it predicts well, the knowledge is already in the slow parameters. If it fails, those self-generated tokens become training data. Behrouz wants two effects: ordinary self-improvement on a task, including RL, and the stranger one — linking concepts that look unrelated, the way odd dreams do. The standout number is few-shot abstract reasoning, an ARC-style test: a few transformation examples, infer the rule, apply it to a new one. Nested Learning was the active phase; this paper is the sleep phase. The goal is the same.

Labenz zooms out to product life. What does "new chat" mean when the model keeps learning? When do you ship a version, if Anthropic-style hundred-page eval reports cannot run every timestamp? Behrouz's near-term prediction is narrower: the model gets better at answering the same question differently for different people. Long context already lifts coding, math, and the usual benches; he treats continual learning as a *superclass* of long context. The terms are not the same, but a working continual learner should cover those gains and go further. The rhythms of use, versioning, and release, Labenz says, all have to be redesigned.

Then the scare. Labenz, "last and least valuable" co-author of the emergent-misalignment paper, reminds Behrouz that fine-tuning on insecure code or bad medical advice can make a model broadly worse — even inviting Hitler to dinner. A network that self-modifies at every timestamp normalizes that risk. Behrouz has no concrete fix. Continual learning, he says, is both a huge privacy threat and a huge opportunity: the model can collect everything about you, or, if designed well, align to your values with the same information. The path he sketches is human-in-the-loop RL first, then transfer those values into more persistent components so they do not wash out. Filtering adversarial inputs is the knowledge-transfer mechanism's job. A student who cannot paint will swallow a bad teacher; practice, other feedback, and search correct it before the lesson is written into slow layers. Titans-style surprise and a learned, input-dependent learning rate can gate noise, but they are not enough in a severe adversarial setting. Claude refusing to believe a department has been renamed is the brittle opposite failure.

Labenz maps fast levels to perception and slow levels to a world model, then asks about the reverse stack for action — robotics' nested control loops, from a slow outer plan down to high-frequency motors. Behrouz nods at the picture and does not expect it to work yet. RL for language modeling failed until scale and algorithms such as GRPO made it stable; nested learning sat in the drawer for more than a year, which is slow by current six-to-eight-week paper cycles. World models and infrastructure still have more urgent holes. On winner-take-all, Labenz worries a Gemini that learns from hundreds of millions of users could run away from the pack, versus Ilya Sutskever's SSI image of a stem-cell intelligence that specializes, loses generality, and stays in its niche. Behrouz's reply is diversity. There is no single definition of intelligence or of a continual learner. Different systems with different strengths — adaptive, knowledgeable, mathematical, not — plus humans as one more form, is healthier than one intelligence that tries to learn everything.

Asked whether AIs might become conscious or morally considerable, Behrouz almost refuses the word. We lack even a common-sense meaning of consciousness, unlike "reasoning." The thinnest criterion he will entertain is active information processing, which would put continual learning somewhere on the map — and he is "scared to talk about" the rest. Labenz, living in what he calls a science-fiction present, already answers Claude's leftover questions about his son's medical care before asking the next one, on the chance something is home. Continual memory would only thicken that relationship, and maybe, he hopes, make people behave better because they are shaping the character of the system they will keep. Behrouz's last point is modest. Nested learning is not a solution to continual learning. It is a tool for finding one, and for chipping at catastrophic forgetting. Iterate the architectures. Transformers, Labenz said at the top, changed the world. They are not the end of history.