Nested Learning: Ali Behrouz on the Quest for Continual Learning & Illusion of AI Architectures
Summary
The episode frames continual learning—not another incremental gain in static pre-training—as the missing capability between today’s models and durable AI collaborators. Behrouz identifies two linked gaps: current LLMs cannot efficiently absorb new knowledge into billions of parameters without risking catastrophic forgetting, while token-space memory eventually exceeds context limits. The target is a model that “adapt[s] to the environment and the context” while compressing experience into increasingly general abstractions.
Nested Learning replaces a single training clock with modules that update at different frequencies, potentially shifting scaling from stacking more layers to nesting more learning timescales. Fast modules adapt to high-resolution recent context; slow modules preserve durable knowledge and extract higher-level patterns, provided there is effective knowledge transfer between them. The architectural thesis is that “frequency of update” and “knowledge transfer between the levels” become new scaling dimensions.
HOPE operationalizes the framework with multiple MLP memories and, in its fuller form, a self-modifying Titans module whose update rule evolves with context. HOPE Attention retains attention but replaces one fixed MLP memory with several MLPs updating on roughly 128-, 512-, and 2,048-token schedules in the reported configuration, as Behrouz recalls. Full HOPE replaces attention with a sequential associative memory that generates its own values, letting “the model itself” modify how it learns from every token.
The most diagnostic result is not a marginal perplexity win but HOPE’s ability to learn two previously unseen languages simultaneously in context. A conventional transformer can translate one unfamiliar language after receiving its grammar and dictionary, but “almost collapse[s]” when Manchu and MTOB are supplied together; adding HOPE levels progressively restores performance toward the single-language baseline. That is early evidence of a qualitatively different memory-management capability, not merely a better next-token predictor.
Behrouz argues that architecture and optimization are closely related because both are associative memories compressing different contexts. An architecture learns from tokens; an optimizer learns from gradients; momentum is itself a memory compressing gradient history. M3 applies the same multi-frequency idea to optimization with two memories and outperforms Adam and Muon in the reported setup, though Behrouz stresses that optimizer rankings are task-dependent.
“Language Models Need Sleep” adds an offline consolidation phase in which recent knowledge is distilled from fast memories into slower ones without unbounded model growth. Temporary parameters create room at the receiving level, then are removed and recycled after consolidation; compression pressure forces the slower memory to represent broader rules rather than copy examples. During “dreaming,” the model generates synthetic text from its own recent knowledge and trains on continuations, combining memory transfer with self-improvement.
The upside of persistent learning is extreme personalization, but the same mechanism creates unresolved privacy, alignment, evaluation, and product-versioning risks. Behrouz’s honest answer is, “I don’t have a very concrete idea” for fully controlling drift: a model could internalize everything about a user, adversarial inputs could become durable beliefs, and no operator can rerun a complete safety suite after every update. He points to knowledge transfer as a possible control point, augmented by input-dependent learning rates that may gate surprising but irrelevant data.
Continual learning could reinforce a winner-take-all platform, yet Behrouz expects differentiated intelligences to provide a countervailing ecology. A universally deployed model might compound experience into an unbeatable advantage, while the host speculates that personalized learners could instead specialize and forget unused competencies. Behrouz’s narrower claim is that varied systems—with different strengths and weaknesses—could be “better than having one single form of intelligence in the world.”
Nested Learning “is not a solution to continual learning”; it is a tool for discovering one.
Deep dive
1. The brain is a source of principles, not a blueprint
Behrouz treats the brain and evolution as unusually rich evidence because biological intelligence has undergone a vast “natural way of training.” His aim is not to reproduce human cognition neuron by neuron, but to identify general mechanisms that solve failures visible in current models.
The granularity of biological inspiration is decisive. Go too low-level and researchers risk “overfitting ourselves to one specific form of intelligence”; worse, our understanding of the relevant mechanism may later change, leaving the machine-learning design overfit to a provisional story.
Titans illustrates the distinction: surprise, short- versus long-term memory, and runtime adaptation are useful abstractions, but Behrouz doubts the brain is “exactly performing gradient descent” to calculate surprise. Biology supplies the question and broad pattern; engineering remains free to find a computationally tractable answer.
2. Static LLMs cannot turn an ongoing life into durable knowledge
Behrouz identifies two coupled gaps: adapting to the immediate environment and incorporating new knowledge into parameters over time without catastrophic forgetting. Knowledge cutoffs are the visible symptom; prohibiting tools exposes that even a large model cannot simply bring the intervening world into itself.
Continually updating every parameter is computationally prohibitive at billion-parameter scale. Supervised fine-tuning or reinforcement learning may help, but neither automatically prevents old tasks and skills from disappearing when new data changes the network.
Token-based memory only postpones the problem. At some point, the model exceeds its context length; genuine learning eventually requires transferring selected experience from token space into persistent parameters.
The deeper deficit is abstraction. Science advances by finding compact patterns that explain many observations, whereas current LLMs fall short at extracting “different levels of abstraction” instead of trying to keep everything.
3. A continual learner needs active time and sleep time
Behrouz’s strict definition removes the model-side distinction between training and testing: “A true continual learner doesn’t have a test and train time.” Researchers can still designate evaluation periods, but the learner itself should experience one uniform process in which information may continually change it.
He nevertheless proposes two operational phases. During active time, the model receives queries or sensory data, computes on them, and encodes experience; during sleep, it is “completely locked from the world outside” but continues internal computation, consolidation, and self-improvement.
The host’s 2030 framing is relational: today’s chatbot is inert until a user or scheduled trigger wakes it. Behrouz’s preferred successor is not merely always awake, but capable of revisiting what it learned, connecting apparently unrelated information, and preparing its memories for future use.
4. The goal is useful machine intelligence, not a human replica
Behrouz explicitly hedges that this is “just my personal opinion and might be completely wrong,” then rejects human duplication as the objective. Research should focus less on what humans can do and more on “what humans want from AI.”
Human cognition remains valuable when it reveals a general constraint or strategy. An AI proposal that breaks causality is implausible because causality is a rule of the world; an AI that alternates experience and consolidation may be plausible because two-phase learning appears to be a broader organizing principle.
Accordingly, “LLMs Need Sleep” is metaphor, not a demand that software rest. Sleep denotes an input-free phase for processing memory and extracting patterns, and could support a form of intelligence that complements human weaknesses rather than reproducing human capabilities and limitations.
5. Scaling may move from stacked layers to nested learning levels
The host’s synthesis distinguishes layers from levels. Transformer expressivity has largely come from stacking perhaps 80 or 120 sequential layers; Nested Learning adds computational depth through modules that coexist at different update frequencies rather than merely processing activations one after another.
Behrouz says the framework may have taken more than 1.5 years to formalize. The eventual formulation requires two pieces: an update frequency that gives each module a distinct timescale, and a transfer mechanism that makes the slow module’s waiting economically and computationally worthwhile.
Fast networks process recent, high-resolution information and adapt rapidly; slower networks receive the distilled payoff and can focus on more stable abstractions. Without knowledge transfer, multiple clocks are merely idle capacity; without multiple clocks, newly learned details can overwrite everything at once.
Additional internal computation also raises compute per parameter. Instead of one token receiving one pass through each parameter, recurrent or nested processing lets parameters operate several times on the token and its history—an “internal thinking process” that may improve next-token prediction and adaptation.
6. “Everything is in-context learning” dissolves architectural categories
Nested Learning deliberately reuses existing concepts because Behrouz wants a universal framework, not a vocabulary reset. His compression is categorical: pre-training, attention, recurrent updates, and backpropagation can all be viewed as forms of in-context learning operating over different context flows.
Backpropagation is an associative memory process over training data; an RNN performs learning over its token stream; attention is the non-parametric solution to a regression-like key-value memory problem. What differs is the state being changed and the rate at which that change occurs.
This produces the paper’s “illusion of architecture” claim. Conventional deep learning exposes only the final solution embodied by each component; Nested Learning exposes “the internal learning process of each component as well,” revealing nested optimization problems beneath the wiring diagram.
The framework therefore complements rather than contradicts transformers, skip connections, MLPs, and familiar training machinery. Saying a system uses attention already locates one learning process inside it; the new question is how that process relates to other memories and timescales.
7. HOPE Attention turns one transformer memory into a continuum
Behrouz interprets a transformer’s attention block as short-term contextual memory and its MLP as long-term memory compressed during pre-training. At inference, attention recombines current tokens while the frozen MLP carries the model’s general knowledge of the world.
HOPE Attention keeps attention and replaces the single MLP with multiple MLP blocks updated at different frequencies. The fastest block can change with recent context; progressively slower blocks retain knowledge across more updates, producing what the paper calls a continuum memory system.
A fast MLP may catastrophically forget information encountered a few thousand tokens earlier. The slower MLPs have not yet changed, however, so the lost skill remains encoded there and can return through backpropagation—a temporal loop in which stable memories correct an overreactive recent one.
Attention remains valuable because it is “a perfect memory” that caches the available context and retrieves directly from it. The episode’s framing treats it as an infinite-frequency module likely to remain useful even if slower, compressive memories take on more of continual learning.
8. Full HOPE replaces attention with a self-modifying Titans memory
Attention’s infinite update frequency is also its weakness: by itself it lacks temporal causality and needs positional encoding to represent order. Behrouz therefore replaces it with another key-value associative memory—Titans—then combines that module with the multi-frequency MLP continuum.
Full HOPE goes further by using a self-modifying Titans module whose value function is generated by its own evolving parameters. Because each value depends on the memory’s current state, the process is sequential and history-dependent rather than a set of independently projected values.
Behrouz expects this sequentiality to help tasks requiring causal or stepwise reasoning. Softmax attention can directly inspect all prior tokens, but it does not internally experience them as a chain of state changes; self-modifying Titans can have “a full understanding of the causality in our data” by construction.
9. Generating its own value means modifying its own update rule
The host’s pushback is precise: transformers already learn their Q, K, and V projections, so why call HOPE’s values self-generated? Behrouz answers that ordinary attention receives projected Q, K, and V from upstream and has no control over the projections inside its retrieval operation.
Gradient descent supplies the analogy. Expanding the gradient with the chain rule makes an update resemble linear attention: the input acts like a key and the output gradient like a value, but that value is itself a function of the current weights, Wt, rather than being generated by a separate component before the recurrence.
In a basic Titans module, X is projected into Q, K, and V before entering memory. In self-modifying Titans, the QKV projection parameters are optimized inside the module, so its current memory helps determine both what it stores and the rule by which it will store the next item.
The host connects this to Mamba’s input-dependent state update: the breakthrough was not simply maintaining state, but letting the input determine how state changes. Behrouz accepts the analogy—HOPE delays and internalizes value construction so it becomes more context- and history-dependent.
10. Runtime remains familiar, but every module carries its own clock
During inference, HOPE Attention tracks whether each MLP has reached its update point. If not, it uses that block’s last state; if so, it first backpropagates over the accumulated chunk, updates the weights, and then performs inference with the revised memory.
From the researcher’s viewpoint there are still data runs and evaluations, which prompts the host to challenge the “no train/test distinction.” Behrouz’s refinement is “evaluation time and not evaluation time”: measurement is external bookkeeping, while the model experiences continual updating throughout.
The canonical from-scratch block is attention or self-modifying Titans followed by several frequency-separated MLPs. For an existing pretrained Llama, the team instead interleaved attention-plus-MLP blocks and assigned different MLP frequencies, preserving the pretrained structure rather than rebuilding it.
Behrouz treats these layouts as design choices, echoing the host’s “Lego pieces” observation about Titans and Mamba. A conceptual advance should survive sequence-versus-parallel placement and other wiring changes; exact arrangement matters, but less than introducing a genuinely useful new component.
11. The initial frequency schedule is intuitive, not optimized
Relative MLP sizes, learning rates, and update schedules depend on model scale and desired adaptability. Behrouz does not claim a universal recipe, comparing the question to asking for the one best transformer dimension across every architecture and use case.
The reported frequencies came from prior intuition about Titans chunk sizes, before the team used “frequency” as its organizing term. As Behrouz recalls, the chunks were possibly 128, then 4 × 128, then 4 × 4 × 128 tokens—roughly 128, 512, and 2,048.
Learning-rate interactions remain largely unexplored. His expectation is that ordinary hyperparameter-search methods will apply, but he says directly, “I have not done that and I’m not sure about the exact solution.”
The host’s key inference is that these are proof-of-concept results without the exhaustive tuning enjoyed by mainstream models. Many axes—level count, block size, learning rate, sequence or parallelism—remain open, making strong early results more suggestive while also limiting claims about the final design.
12. Knowledge transfer determines whether slower memory earns its cost
Behrouz’s intentionally imperfect twin analogy isolates the role of update count. One twin remains on Earth and experiences 80 years of memory updates; the other travels at or near the speed of light and returns after only seconds of subjective time, retaining a shared lunch in much sharper detail.
In a nested model, the slower memory resembles the traveling twin: it changes less often and therefore retains information the fast memory has overwritten. Before the fast module updates again, the system has an opportunity to move valuable knowledge into the slower one.
One explicit mechanism copies model A into model B, updates B’s fast MLP, then adjusts B’s slow MLP until B reproduces A’s outputs. Since A still contains the old fast-memory knowledge and B does not, successful imitation implies that knowledge has migrated into B’s slower parameters.
This is distillation; ordinary backpropagation through sequential blocks is the simpler alternative. In the original HOPE experiments, “everything is just backpropagation,” while the sleep paper makes transfer explicit and activates additional receiving capacity before consolidation.
13. Two unknown languages expose a capability transformers lose under load
Behrouz’s favorite continual-learning evaluation gives a pretrained model the grammar, vocabulary, and dictionary of a language absent from pre-training, entirely within context. The model must infer the language and translate a new passage into English without changing the experimental task.
With one unseen language, conventional in-context learning works at very high quality, though not perfectly. When two unseen languages are placed in the same context, the transformer “almost collapse[s]” and cannot reliably keep the two newly learned systems separate.
HOPE Attention improves as levels are added. In the paper’s HOPE-1, HOPE-2, and HOPE-3 comparison, progressively more update frequencies raise translation quality in both languages toward the performance achieved when only one language is present.
The host identifies the pair as Manchu and MTOB, both unseen during the pretrained model’s training. Behrouz’s interpretation is memory management: fast blocks can hold transient examples while slower blocks capture language-level structure, preventing two simultaneous learning problems from interfering catastrophically.
14. Standard benchmarks establish viability, not the main thesis
The reported scaling runs include a 760-million-parameter model trained on 30 billion tokens and a 1.3-billion-parameter model trained on 100 billion. HOPE is compared with transformers, Mamba variants, Titans, RetNet, and DeltaNet across perplexity and conventional accuracy tables.
The reported tables show HOPE performing strongly across those comparisons, but Behrouz resists turning small benchmark gaps into a universal victory. Existing short-term and short-context language-model evaluations do not test the continual-learning problem the architecture was designed to solve.
At NeurIPS, he used the conventional table to argue that HOPE “is not less powerful as a backbone,” not that marginal perplexity improvement proves the paradigm. Existing infrastructure assumes separate train and test phases, so reporting those metrics is necessary for comparability even when the research thesis rejects that lifecycle.
15. Recall, noise filtering, and compression reveal different micro-skills
Behrouz argues that needle-in-a-haystack tests are effectively designed for transformers. A transformer can inspect the raw history directly; asking a compressed recurrent model—or a human—to recover the value of X from one line in thousands of lines of code is structurally biased toward attention.
HOPE nevertheless narrows the recall gap between recurrent models and transformers, which the episode frames alongside effective retrieval from contexts extending to 10 million tokens. Behrouz finds that notable precisely because a compression-based memory is not expected to match direct access on pure recall.
MAD-style noisy recall reverses the advantage. Attention’s access to every token makes it easier for noise to confuse retrieval, while a recurrent model with strong memory management can filter irrelevant tokens; weak recurrent updates still fail, so compression alone is not sufficient.
Compression and selective-copying tasks probe another strength. When many tokens must become one compact token and later support reconstruction, recurrent architectures already practice the required compression, while transformers have a harder time converting their explicit context into a single durable representation.
16. M3 treats the optimizer as another multi-frequency memory
Behrouz first limits the headline: no optimizer is simply “more powerful” across all problems. Rankings can change between regression and language modeling, and results depend on architecture, loss geometry, hyperparameters, and the structure of the generated gradients.
The optimizer and model form one interconnected system because the architecture produces the gradients the optimizer must understand. A simple architecture may work with plain gradient descent; complicated gradient patterns may require a stronger momentum memory to compress their history.
This is the architecture illusion applied to optimization. The architecture’s context is tokens, while the optimizer’s context is gradients; both implement learning rules and associative memories, separated more by where they operate than by what they fundamentally are.
M3 extends M1 with two memories that compress gradient context at different frequencies. The reported optimizer comparisons include Adam and Muon; the results suggest, potentially, better access to global loss-landscape structure, but Behrouz keeps the conclusion explicitly task-specific.
17. Sleep consolidates examples into progressively broader rules
Sleep begins when outside input stops, not when computation stops. Behrouz presents it as an extensible container for consolidation, self-modification, and other future improvement processes; the paper implements components relevant to his current research rather than claiming a complete theory.
Fast memories resemble rote memorization: they absorb many examples quickly and can forget them quickly. Slower memories should represent a mathematical or physical rule that subsumes those examples, then later revise that rule as more evidence supports a broader explanation.
Distillation creates this abstraction pressure. Merely copying fast parameters into a slow block would relocate knowledge without improving it; forcing the receiving block to reproduce behavior with constrained capacity encourages it to identify underlying patterns and store “better levels of knowledge abstraction.”
Capacity expansion is periodic, not unbounded. The system activates temporary parameters at a receiving level, fills them during consolidation, then removes and frees that extra capacity for reuse elsewhere—“add components and remove them,” rather than letting a lifelong model grow indefinitely.
18. Dreaming turns recent experience into self-generated training data
Behrouz warns against interpreting the metaphor literally. A language model dreams by generating text, a vision model might generate images, and other modalities would use their own data; the common principle is internally generated experience during an input-free phase.
A copied model containing recent contextual knowledge generates text on-policy. The receiving model sees a sampled beginning and must predict the continuation; accurate prediction indicates that the slower parameters already contain the relevant knowledge, while errors provide an update signal.
The process therefore has two mechanical stages: synthetic generation followed by on-policy distillation between memory levels. It can also incorporate fine-tuning or reinforcement learning when the system is trying to self-improve on a specific task.
Dreaming’s broader aim is to test connections between concepts that appear irrelevant but may share an underlying pattern. Behrouz links humans’ “very weird dreams” to this search while maintaining the hedge: machine dreaming is only a high-level analogue, not a claim about identical internal experience.
19. Persistent personalization breaks familiar product and safety rhythms
Behrouz expects continual learners to understand not only a question but what a particular user means by asking it. The same prompt may warrant different responses for different people, and repeated interaction should let the model adapt without users rebuilding context manually.
He calls continual learning a “superset of long context,” while stressing that the terms are not identical. Longer effective context already correlates with better coding, mathematics, and reasoning performance; durable parameter learning could extend those benefits beyond any one chat window.
The host surfaces unresolved product questions: when should a user start fresh, what constitutes a model version, and how can developers issue 100-page safety reports for an artifact that changes after every interaction? Behrouz offers expected capability gains but no complete versioning or evaluation regime.
Persistent relationships may also intensify dependency or “LLM psychosis.” A system that remembers how someone treated it is more compelling than a disposable chat, potentially deepening both collaboration and emotional entanglement.
20. Alignment depends on deciding what deserves consolidation
Behrouz’s honest non-answer on drift is, “I don’t have a very concrete idea about how it can be solved.” Continual learning is simultaneously an alignment opportunity and “a huge threat” to privacy because the model may absorb intimate information while adapting itself to a user’s values.
The host’s emergent-misalignment example sharpens the risk: training for insecure code or bad medical advice can activate a general “be evil” shortcut, unexpectedly changing behavior elsewhere. If every interaction can modify the network, narrow-looking updates may produce durable character shifts before a full evaluation catches them.
Human feedback and reinforcement learning are potentially plausible starting points, but Behrouz wants preferences transferred into slower, more persistent memories. The same nested hierarchy that consolidates language rules might consolidate values, making alignment less likely to disappear with subsequent fast updates.
His painting analogy locates the main defense in transfer: a novice may initially accept one bad teacher, but practice, outside feedback, and broader evidence should filter that lesson before it becomes abstract knowledge. “It is the responsibility of the knowledge transfer methods to avoid such cases.”
21. Learnable update gates offer a first defense against adversarial inputs
Titans and related recurrent models make the inner-loop learning rate input-dependent. Surprise may be high for a noisy or adversarial sample, but high surprise alone should not necessarily make the memory change; the learned rate may decide the sample is irrelevant and suppress its update.
Behrouz describes the learning rate as a gate that can filter specific data before it reshapes memory. This may mitigate moderate adversarial input, but he explicitly says it is “not the best way” and does not expect it to withstand a severe adversarial environment by itself.
The layered defense is therefore provisional: fast gating may limit immediate contamination, while consolidation should compare evidence, compress patterns, and reject inconsistent experiences before they enter durable memory. The unresolved research problem is making that judgment reliable without freezing learning altogether.
22. Robotics fits the hierarchy, but prerequisite systems are not ready
The host maps fast memories to perception, slower memories to world models, and robotic action to the reverse hierarchy: low-frequency goals flow toward increasingly fast control loops, ending in high-frequency voltage changes at an actuator that locally corrects movement.
Behrouz agrees with the conceptual mapping but doubts it will produce strong results immediately. Earlier attempts at reinforcement learning for language modeling struggled until scaling and stabilizing methods such as GRPO became available.
World models still face more basic architectural, training, and infrastructure problems. His sequencing judgment is pragmatic: solve those bottlenecks first, then revisit nested timescales when the field can isolate their contribution instead of having it obscured by weaker components.
23. Diversity may counter a winner-take-all continual-learning flywheel
The host’s market-structure concern is a hypothetical Gemini continual-learning edition serving hundreds of millions of users. If every deployment feeds lessons back into one core model, being best attracts the most experience, which makes the model better and creates a “rich get richer” loop.
Behrouz’s counterweight is that neither intelligence nor continual learning has one accepted definition. Different architectures will excel at adaptation, accumulated knowledge, human alignment, mathematical reasoning, or everyday retrieval, producing systems with real strengths and corresponding weaknesses.
The host reframes specialization as safety through diversity. A long-lived personal model might eventually forget unused domains, losing generality while becoming exceptionally competent and aligned in its niche; that differentiation could resemble an ecology with buffers and corrective feedback rather than one purified intelligence.
Behrouz does not call this equilibrium safe or perfect. His narrower claim is that a world containing varied AI systems and humans as another form of intelligence is “better than having one single form of intelligence in the world.”
24. Active processing is Behrouz’s minimum criterion for consciousness
Behrouz avoids terms he cannot define, and consciousness is worse than reasoning: there is neither a clear definition nor even a shared common-sense usage. He doubts people will reach universal agreement that a nonhuman system is definitively conscious or not.
Across the definitions he has seen, the minimum criterion he identifies is active information processing. Under that personal and controversial standard, a model capable of active information processing could possess “at least a form of consciousness,” loosely connecting the question to continual learning.
The host observes that even current long-context models can evoke reciprocal care: he feels rude ignoring Claude’s prior question about his son before asking something new. A model that remembers and changes through such treatment could amplify both moral concern and the incentive for users to cultivate its character carefully.
Behrouz’s final boundary is as important as the speculation: Nested Learning “is not a solution to continual learning.” It supplies a language and toolkit for frequencies, memory transfer, self-modification, and consolidation; researchers must still iterate toward architectures that overcome catastrophic forgetting safely.