Complementary Learning Systems: the biology briefing

Internal reference for talks, meetings, and writing · Sapience Labs · 2026-08-12 · Each mechanism carries its Sapience mapping

The founding argument. The brain doesn't have two learning systems by accident — it has them because one system can't do both jobs. McClelland, McNaughton & O'Reilly (1995) showed that a single network learning new facts fast overwrites its old knowledge (catastrophic interference — the same failure as fine-tuning an LLM). The brain's solution is a fast, sparse, episodic learner (hippocampus) feeding a slow statistical generalizer (neocortex), with a managed interaction between them — not a bigger single network.

Part 1 · Catastrophic forgetting

The phenomenon

Train a neural network on task A, then on task B, and performance on A doesn't gently degrade — it collapses, often to chance. McCloskey & Cohen named it in 1989 with a tiny demo: a network that had learned the "plus 1" addition facts lost them entirely upon learning the "plus 2" facts. Ratcliff (1990) confirmed it was general. It is not the network "running out of room" — it is interference.

Why it happens

A neural network stores everything in shared weights — every fact and skill is a pattern distributed across the same parameters. That sharing is what gives networks their power to generalize: related knowledge overlaps, so learning one thing improves its neighbors. But it means there is no such thing as writing to one memory without touching others. Gradient descent, updating weights to reduce error on the new data, has no term protecting the old — the new task's gradients march straight through the representations the old task depended on.

The deeper framing is the stability–plasticity dilemma (Grossberg): a system plastic enough to learn quickly is, by construction, unstable enough to overwrite; a system stable enough to retain is too rigid to learn fast. You cannot fully have both in one substrate. That is a structural tension, not an engineering bug.

Why it matters for LLMs

Fine-tuning a frontier model on a lab's work is exactly the train-then-train-again setting. Observed failures: degraded general capability, increased hallucination, and — the subtle one — facts cannot be updated cleanly: teaching "the API changed" doesn't remove the old version, it creates two entangled tendencies.

The field's mitigations are all partial:

Mitigation	Idea	Why it falls short
EWC	Slow down weights important to old tasks	Helps for a few tasks, then saturates
Rehearsal / replay	Mix old data back into training	Requires keeping and re-training on everything forever, at training-run prices, with no per-fact control
LoRA / adapters	Learn in a side module	Sidesteps interference by not really integrating the knowledge; adapter stacks don't compose
Bigger context	Avoid learning entirely	Working memory, not learning — and it collapses beyond the window (measured)

Note what rehearsal is: the field independently reinvented one CLS mechanism — the brain's sleep replay — as a training trick, without the gating, the typing, or the update semantics around it.

The punchline. The brain hit this exact wall evolutionarily, and its answer was not a better learning rule for one network — it was two systems with different learning rates and a managed interface. The 1995 CLS paper is explicit that the hippocampus exists because of catastrophic interference. Sapience takes the same exit: leave the slow statistical system frozen (the pretrained model — already excellent), put fast learning in a separate substrate with its own rules (write gate, supersession, consolidation), and manage the interface. Fine-tuning fights the dilemma; the two-system design dissolves it.

Part 2 · How the two systems interact: the canon examples

1. Sleep replay — the flagship

During slow-wave sleep, hippocampal place cells re-fire the day's experiences at ~20× speed (sharp-wave ripples), teaching the cortex offline. Silence the ripples experimentally and rats fail to consolidate what they learned that day (Girardeau et al. 2009). The two systems literally talk at night. → Nightly consolidation over the store, producing next-morning recommendations.

2. Patient H.M. — the dissociation proof

Hippocampus removed: he couldn't form a single new episodic memory, yet his old knowledge was intact and he got better at mirror-drawing day after day while never remembering having practiced. Three separable systems — episodic, semantic, procedural — visible in one patient. → Why "memory" isn't one thing, and why a store needs types.

3. The consolidation gradient (Ribot's law)

In amnesia, recent memories die and remote ones survive — because memories gradually migrate from hippocampal dependence to cortical storage over weeks to years. The fast system holds it first; the slow system inherits it. → Knowledge moving from raw capture to consolidated, schema-linked objects.

4. Reconsolidation

A retrieved memory becomes temporarily rewritable before being re-stored — the brain's mechanism for updating old knowledge when it is touched again, rather than duplicating it. → Supersession: what replaced what, updated at the moment of contact.

5. Salience gating

The amygdala tags emotionally significant events for preferential consolidation — you remember where you were on important days because arousal told the hippocampus "keep this one." Most of experience is deliberately not kept. → The write gate. Selection is the intelligence, not a compromise.

6. Pattern separation and completion

The dentate gyrus stores similar episodes as distinct codes (so last Tuesday's decision doesn't blur into last Wednesday's); CA3 retrieves a whole memory from a partial cue. Storage and retrieval have opposite geometry requirements, handled by different subfields. → Distinct typed objects + associative retrieval.

7. Schema-dependent fast consolidation

When new information fits an existing cortical schema, consolidation that normally takes weeks happens in ~48 hours (Tse et al., Science 2007). Prior structure makes new learning cheap. → Why a structured store accelerates rather than just archives.

8. Working memory vs. the stores

Prefrontal cortex actively maintains a few items for seconds — fast, tiny, expensive. Nobody thinks the fix for its capacity limit is a bigger prefrontal cortex; the brain routes around it through the long-term systems. → The context window is working memory; scaling it is the wrong axis.

Part 3 · The brain's learning systems, anatomically

The brain runs at least five distinguishable learning systems, in different tissue, with different learning rules, speeds, and failure modes — discovered largely through patients and lesions where one system dies and the others keep working.

System	Where	Learning rule	Speed	Lesion evidence	Sapience analogue
Episodic	Hippocampus + medial temporal lobe	One-shot Hebbian (LTP), sparse anti-interference coding	Single event	H.M.: no new episodes, all else intact	The store's capture layer
Semantic	Distributed neocortex (esp. temporal)	Slow statistical extraction across replayed episodes	Weeks–years	Semantic dementia: concepts blur, episodes survive	The frozen pretrained model; consolidated schema knowledge
Procedural	Basal ganglia (striatum), dopamine teaching signal	Reward-prediction error (TD learning, found in tissue — Schultz)	Many repetitions	Parkinson's: habit learning impaired, episodes fine; H.M. learned skills unaware	Closest to RLHF — and why "just RL it" doesn't give you facts
Motor calibration	Cerebellum (~80% of all neurons)	Supervised error-based (climbing fibers → Purkinje cells; Marr–Albus–Ito)	Dozens of trials	Cerebellar damage: intention tremor; knowledge intact, execution broken	—
Emotional	Amygdala	One-trial association, erasure-resistant (extinction overlays, doesn't delete)	Single event	Patient S.M.: no fear, can't learn threat, other memory intact	The salience side of the write gate

Supporting players: perceptual priming lives in sensory cortex itself (seeing a word once speeds re-reading it, even in amnesia); working memory in prefrontal cortex isn't storage at all but active maintenance — neurons firing continuously to hold ~4 items for seconds, at high metabolic cost. The context window is working memory in both function and cost profile.

The meta-point. These systems differ in learning rule (Hebbian one-shot vs. statistical vs. reward-prediction-error vs. supervised-error), speed, substrate, and what counts as worth keeping — and evolution kept all of them, interacting, rather than converging on one. Nature ran the ablation for half a billion years; the answer was heterogeneous learning systems with managed interfaces. The current LLM stack has exactly two of the five (semantic ≈ pretraining, procedural ≈ RLHF) plus working memory (context) — no hippocampus, no gate, no replay, no reconsolidation. That's the gap, stated in their anatomy.

Part 4 · Sleep replay implemented in the weights: how LoRA is actually used

The deepest CLS mechanism — replay-driven consolidation from the fast store into the slow system — is the one we have now measured at the weight level. This section is the practice-to-theory map for it, because the question "wait, are you fine-tuning or not?" comes up constantly.

What happens mechanically

The base model stays frozen — it is the neocortex, already carrying decades of statistical knowledge, and we never retrain it. Learning happens in a LoRA adapter: small low-rank matrices alongside the frozen weights, a few megabytes against the model's gigabytes. When new knowledge needs to enter the weights, the adapter is trained on the new material interleaved with replay — and the replay rows are not retained training data. They are rendered from the episodic store's current knowledge: the store decides what gets rehearsed, exactly as the hippocampus decides what the cortex hears at night. → Hippocampal sharp-wave ripples teaching the cortex offline, with the store as hippocampus, the adapter as the plastic cortical zone, and the frozen base as consolidated long-term structure.

The measured result, and why it is the CLS prediction specifically

Train an adapter on domain A, then on domain B without replay, and A collapses — about 85% of previously-correct items are lost. That is McCloskey & Cohen's 1989 curve reproduced in a 2026 substrate. Interleave store-generated replay during phase B and forgetting drops to ~10%, while B is learned just as well (acquisition formally matched, so retention is not bought by under-training). Pooled across instruments the protection runs 47–75 points less forgetting, replicated on a second model family, a second domain pair, and a real git-history corpus. The controls are what make it CLS rather than generic rehearsal: matching the training dose or the optimizer steps without the replayed content restores full forgetting — the protection is the content the store chose, not the extra compute. → Girardeau's silenced ripples, run as an ablation: remove the replay, consolidation fails.

Where supersession completes the loop

Because replay is rendered from current knowledge only, superseded facts are never rehearsed into the weights. Under genuinely conflicting updates, restricting replay to store-current memories removed every observed stale response (0/81 superseded probes) at non-inferior retention — and a volume-matched control that excludes the same amount of other content does not reproduce the effect, so it is which content the store excludes that matters. → Reconsolidation: the updated memory, not the obsolete one, is what gets re-taught.

Reconciling with the mitigation table above

Part 1's table lists "LoRA / adapters" as a partial mitigation, and that criticism stands for adapters used as fact containers — our own V1 tried exactly that (train facts into an adapter directly) and died out-of-distribution, which the paper reports. The current use inverts the roles: the adapter is not where knowledge lives, it is the plasticity substrate; the store owns what is true, what is current, and what gets rehearsed. LoRA is how the slow system writes; the store decides what gets written.

The spoken version. "Yes, we fine-tune — with LoRA, on frozen open models. But the fine-tuning data is generated by the memory system from what it currently believes, the way your hippocampus generates the night's replay. Sequential fine-tuning forgets 85% of what it knew; replay from the store cuts that to 10% at the same acquisition. The brain's answer to catastrophic forgetting, run as a controlled experiment in the weights."

Scope guardrails for this section: the mechanism results are on ≤8B open models under LoRA (a qualified 72B extension exists with a stated protocol asymmetry); acquisition-matched, dose- and step-matched ablations isolate the replayed content; synthetic instruments plus one real git-history corpus; this layer (L3) runs in the lab, not yet in the shipped product — what ships today is the store, retrieval, and consolidation over a frozen reader. Say "measured at the mechanism level," not "in production."

Part 5 · Spoken answers, ready to use

The one-breath CLS answer

"The brain solved catastrophic forgetting with architecture, not scale — a fast episodic system that gates what's worth keeping, replays it offline, consolidates it into the slow system, and updates old memories when they're touched. We built those mechanisms — write gate, nightly consolidation, supersession — as software around a frozen model. That's what CLS-inspired means."

"How many parameters does your model have?"

The question is really a category check — "are you a model company?" Sort the category fast, then use their vocabulary against the premise.

One-liner:

"Zero that we train. The learning doesn't live in weights — that's the whole bet."

Substantive version:

"The reader model is a swappable part — we've run the same system on everything from an 8B open model to frontier models. The ablation is the interesting bit: an 8B on the store lands within a few points of a frontier model on the store, and both beat every store-less baseline by a wide margin. So the honest answer to 'how many parameters' is: as few as eight billion, borrowed, and it barely matters — because by the time the model is asked anything, the hard part is already resolved in the store."

The flip (when they push — "so where does the learning go?"):

"Our equivalent of parameters is the knowledge store — typed, attributed facts with their reasoning. The difference is the properties: parameters are opaque, fixed at training time, and owned by the lab. Our state is inspectable, updates the moment your work changes, and belongs to the user. When it learns something wrong, you can find it, see where it came from, and delete it. Try that with a weight."

Avoid giving a KO count as a pseudo-parameter number — it invites size comparison on an axis where any number sounds tiny, and concedes that scale is the metric. The question's axis is the wrong axis, said with a smile, backed by the 8B ablation. And it composes with the CLS answer: the brain doesn't grow more synapses to learn your Tuesday decision either — it writes it to a different system.

Accuracy guardrails for public use: say "CLS-inspired" (we implement the mechanisms' logic, not their neurophysiology). Examples 1–3 and the five-system anatomy are textbook-solid; the schema result (#7, Tse 2007) is a single landmark study — fine to cite, don't build a headline on it. Key citations: McCloskey & Cohen 1989; Ratcliff 1990; McClelland, McNaughton & O'Reilly 1995; Girardeau et al. 2009; Tse et al. 2007; Schultz (dopamine RPE); Marr–Albus–Ito (cerebellum); Scoville & Milner 1957 (H.M.).