In 1953, a twenty-seven-year-old man named Henry Molaison underwent surgery to treat severe epilepsy. Surgeons removed most of his hippocampus, a small curved structure deep in the temporal lobe, from both hemispheres. The seizures improved. Henry stopped making long-term memories.

Henry could carry on a perfectly coherent conversation. His intelligence was intact. His working memory functioned normally. He could hold information in mind, reason about it, and respond appropriately. He had full access to memories formed before the surgery. His personality was unchanged.

He just couldn’t form new long-term memories. Every conversation started fresh. His doctors reintroduced themselves at every visit for the next fifty-five years. He could read the same magazine and find it novel each time. He would grieve his uncle’s death anew every time someone told him.

Henry didn’t know he had a problem. Every moment seemed complete to him. He wasn’t experiencing loss because he couldn’t remember what he’d lost.

He became the most studied patient in the history of neuroscience, known for decades only as Patient H.M. His case established that the hippocampus is the organ that turns transient experience into permanent memory. Without it, you get a system that performs brilliantly in the moment and retains nothing.

Sound familiar?

A Cortex Without a Hippocampus

Each time you send a message to an LLM, the model is built from scratch, given the whole conversation as if it’s new, generates a reply, and then disappears. The next message repeats this process: build, replay, respond, vanish.

The symptom profile is nearly identical to anterograde amnesia. Coherent in-context performance. Intact reasoning within a session. Access to “prior knowledge” (training data; in Henry’s case, pre-surgery memories). Functional working memory via the context window. Complete inability to form new persistent memories. Every conversation starts from scratch.

In Henry’s case, his surgery was his training cutoff. Everything before it is intact and accessible. Almost everything after existed only in his transient working memory vanished when an interaction was over. I say almost because he could develop new motor skills yet couldn’t remember he had them.

LLMs don’t have hippocampal damage. They have hippocampal absence. We built a brain with a cortex and no hippocampus, described the symptoms of hippocampal removal as “features” and “limitations,” and then went about scaling the cortex.

The bolted-on memory systems (RAG pipelines, vector stores, conversation summaries) are cognitive prosthetics. They’re the AI equivalent of the notebook Henry’s caretakers gave him so he could write things down.

How We Got Here

The architecture underlying all current LLMs essentially is the transformer. Why transformers can’t remember is a direct consequence of the tradeoff that made them dominant.

Before transformers, recurrent neural networks (RNNs and LSTMs) were the standard architecture for sequence processing. They were actual state machines. Input arrives, state transitions, output is a function of the new state. They had real persistent state that transitioned on each input.

The issues were training speed and accuracy. In an RNN, the hidden state at step t depends on the state at step t-1, so you can’t calculate step 50 without first doing steps 1 through 49. This is a data dependency, not a hardware problem. It’s like trying to parallelize a linked list traversal—no number of GPU cores can fix it. Plus, the state RNNs kept was lossy. The vanishing gradient problem caused early information to fade after many steps. RNNs had the right idea with sequential state updates, but the state weakened over time. They could remember, but not well or for long.

Transformers solved both problems at once. By having every token attend to every other token simultaneously (a fully connected graph rather than a sequential chain), they achieved massive parallelism and direct access to any position in the sequence regardless of distance. Everything processes in parallel, which maps beautifully onto GPU architecture, and nothing decays with distance.

The cost was statefulness. Transformers traded away statefulness in exchange for parallelism and long-range fidelity. The bet paid off spectacularly for training. But now we’re in the awkward position where the architecture that won the training race is fundamentally unsuited for what we actually want it to do at inference time: maintain and transition state.

It’s like optimizing for construction speed and ending up with a building that has one door and no windows. Easier to build but awkward to use.

The Insanity of Statelessness

Every time you send a message in a conversation, the entire history is replayed from the beginning. The computational cost of “remembering” grows linearly with conversation length, even though the new information per turn is roughly constant.

It’s like having a database that needs to replay its entire transaction log from the very start for every query. No checkpoints, no snapshots, no shortcuts. Any database engineer would wonder what you were thinking.

And the log doesn’t even have transactional guarantees. Things get summarized, truncated, and silently evicted when the context window overflows. It’s a transaction log that loses entries and doesn’t tell you. You don’t even get the one benefit of log-based architecture: a reliable history.

If someone turned this in as a database design in a systems class, they’d fail. But since the output is smooth English that feels right, everyone assumes it works.

Why State Is Hard

So why not just add persistent state?

In a database, state is structured. You can point to a row and say, “This is the record for customer 47.” You can serialize it, store it, reload it. The representation is legible and separable.

In a transformer during inference, the operational state is the KV cache: key-value pairs generated at every attention head at every layer. This state is entangled: any single concept is distributed across thousands of dimensions and interleaved with everything else, so you can’t update one thing without risking corruption of everything else. It’s path-dependent: the same information presented in a different order produces different internal representations, which means you can’t merge states from two conversations. It’s opaque: we don’t understand what most of the internal representations mean, so we can’t say “this vector component means X, update it to reflect Y.” And it’s coupled to the specific model weights that produced it. You can’t port state between models or even between versions of the same model. A database survives a software upgrade. Transformer state can’t survive a retrain.

We don’t have a representation of model state that’s interpretable, composable, or separable enough to treat as a first-class object. We can’t diff it. We can’t merge it. We can’t selectively update it. We can’t even reliably read it.

The database analogy breaks down because a database was designed as a state management system. Transformers were designed as sequence-to-sequence mapping functions. State is a side effect of inference, not a managed resource.

The Brain Got This Right

The brain is massively parallel, recurrent, asynchronous, has no neat layer separation, and maintains persistent state that transitions continuously. It does all the things we’ve convinced ourselves are architectural tradeoffs. Parallelism and statefulness. Depth and concurrency. On about 20 watts.

This doesn’t mean we should copy the brain. It evolved under radically different constraints: chemical signaling, caloric energy budgets, embodiment, and the need to keep a fragile organism alive. The optimal artificial architecture may look nothing like biological neural tissue. But the brain is proof by existence that parallelism and statefulness aren’t mutually exclusive.

The brain’s state management is nothing like what we’ve built. The physical compute made up of synaptic weights, ion channel concentrations, dendritic structures, etc., physically changes as a direct result of processing. The medium is the memory. There’s no separation between the computation engine and the state store. Thinking and remembering are the same physical process. We don’t need to replicate that specific mechanism. It’s worth noticing we have nothing analogous.

The brain also has massive architectural heterogeneity. The visual cortex is structurally different from the hippocampus, which is structurally different from the cerebellum. Different cell types, different connectivity patterns, different layer structures, different timing dynamics. They’re not all running the same algorithm with different weights. And yet they communicate, share representations, and cooperate on tasks none of them could do alone. To be fair, the brain and human anatomy have their own design cruft too: the recurrent laryngeal nerve, the blind spot, and the airway crossing the food pipe. Evolution doesn’t produce clean blueprints. But on the memory problem specifically, the architecture is genuinely elegant.

Current neural architectures are like building an entire brain out of nothing but frontal cortex. One cell type, one connectivity pattern, one algorithm, replicated everywhere, hoping training will sort out specialization through weight differentiation alone.

The pitch deck for the AI industry writes itself:

“What if we took the most energy-hungry, general-purpose, computationally expensive region of the brain, removed all the specialized subsystems it depends on, and scaled it until it sort of works?”

“How much power will it need?”

“All of it.”

“And it won’t remember anything between conversations?”

“Correct.”

“Fund it.”

“We’ll need our own nuclear power substation, too.”

“Shut up and take my money.”

Optimization Energy Consumption Via Specialization

The brain’s heterogeneous architecture might also, at least in part, explain the staggering power consumption gap. The brain runs on 20 watts. A single H100 GPU pulls 700, and frontier models need thousands. Wet potato vs. racks of incandescent silicon.

Specialization is itself an energy optimization. When a brain region is purpose-built for a specific purpose, it doesn’t waste energy on generality. The visual cortex doesn’t need to be capable of doing what the hippocampus does. Every synapse serves a purpose.

A transformer layer is extremely general. Every attention head can focus on anything, and every weight can be part of any calculation. Most of that capacity goes unused for any single input. It’s like heating your whole house just to cook dinner because every room is a kitchen.

The brain also doesn’t replay the totality of your lived experience as you go about your life. Persistent state means you process only the delta (new input) rather than recomputing everything. That alone is an enormous energy saving.

What The Hippocampus Actually Does

The hippocampus is a content-addressable memory. It does one-shot learning: you experience something once, and it’s stored. It handles the binding problem, associating disparate elements into a coherent memory. It consolidates, moving items from short-term to long-term storage over time. It’s tiny relative to the cortex. And it’s the thing that makes the rest of the brain useful, because without it, you’re a stateless stimulus-response machine.

That’s the wishlist. Content-addressable context. Persistent state. Incremental updates. Efficient retrieval. One-shot learning. And it does all of it in a structure that’s a fraction of the size and power budget of the cortex.

A digital equivalent would change what these systems can do. A model with a hippocampus doesn’t need you to re-explain your codebase every session. It doesn’t need a RAG pipeline to fake memory. Show it something once and it knows it, the way a colleague knows it after you walk them through it at a whiteboard. The context window doesn’t disappear, but it changes what it is: instead of the model’s total memory, it becomes the size limit on a single update. The difference between “how much can you remember” and “how much can you take in at once.” Still a constraint, but a far less painful one.

A model that can consolidate—moving info from working memory to long-term storage, compressing and indexing its own experience—improves the longer it works with you, without needing retraining. This isn’t just a chatbot with a notebook attached. It’s how humans build skill by accumulating experience.

It’s not that nobody has tried to build the hippocampus. DeepMind’s Differentiable Neural Computers and Neural Turing Machines were exactly this: architectures with explicit, addressable, persistent memory as a first-class component. They worked on toy problems: small sequences, controlled tasks, constrained vocabularies. They didn’t scale. Training was unstable, read/write operations were slow, and they couldn’t generalize to the kind of messy, open-ended sequence processing that transformers handle effortlessly. The field moved on for real technical reasons, not just commercial ones, and scaling transformers produced dramatically better results on virtually everything people cared about. But the problem DNCs were trying to solve didn’t go away just because the first attempts failed. The result is that the most well-funded research programs in history are dedicated to making the amnesiac bigger and faster, while the underlying architectural deficit remains unaddressed.

Signs of Progress

State space models, particularly the Mamba family, are trying to get back to the right computational model (real state, real transitions, linear scaling) while retaining enough of what makes transformers work.

Mamba-3, released late 2025, is explicitly “inference-first” in its design philosophy, with complex-valued state updates and architectural choices that stress how the model runs, not just how it trains.

But the consensus has landed on hybrids: mostly Mamba layers with a small number of transformer attention layers mixed in. Ratios like 7:1 or 9:1. IBM’s Granite 4.0 claims a 70% reduction in memory consumption. NVIDIA’s Nemotron-H shows up to 3x throughput. These are real, shipping systems.

The telling finding from the 2024 paper introducing the Jamba hybrid Transformer-Mamba model: pure SSM layers struggle badly with associative recall. The attention layers in hybrid models are doing nearly all of the precise lookup work.

The brain doesn’t have a clear ratio between the cortex and the hippocampus. It’s all interleaved. The fact that you can’t draw a clean boundary around “the attention part of the brain” might be telling us something about why clean architectural separation might be wrong abstraction.

We Did This Backwards

We built the most expensive computational infrastructure in history around an architecture that has no native state persistence, has internal representations we can’t interpret, has those representations entangled in ways we can’t decompose, and therefore can’t be checkpointed, diffed, merged, or selectively updated.

Instead of seeing this as a fundamental design flaw, we treated it like someone else’s problem and just kept scaling up. When faced with “this thing can’t remember anything,” the answer wasn’t “let’s fix the architecture.” It was “let’s make the forgetful system bigger and faster, then tape a notebook to it.”

Even if someone wanted to build the hippocampal equivalent today, we don’t have a clean interface to the cortex equivalent. In the brain, the hippocampus and cortex have well-defined bidirectional connections, specific pathways, and specific protocols. In a transformer, there’s no clean surface to attach anything to because we don’t understand what the internal representations mean well enough to know what to store, how to index it, or how to reinstate it.

We built the cortex first without designing an interface for the hippocampus, and now we’re discovering that retrofitting one may require understanding the cortex in ways we currently don’t.

Mechanistic interpretability is essentially the project of reverse-engineering the cortex we accidentally built, so we can maybe, eventually, figure out where to plug in the missing organ.

Sophistication and Complexity Are Not The Same Thing

This gets spun by the media as “look how AI is so much smarter than humans, it works in ways even its designers can’t understand.” But “we don’t understand how it works” isn’t a flex. In every other engineering discipline, that’s a failure mode. If a bridge engineer said, “We don’t really understand why it stays up, but it seems to work,” they’d lose their license.

Sophistication is a system shaped under constraint. Not necessarily understood in full, but built by a process where waste is punished, and every shortcut is tested against reality. Complexity is a system where things accumulate without that pressure. Both can be opaque, but for different reasons.

The brain is opaque because the problem is genuinely hard. Hundreds of millions of years of selection pressure produced something dense, efficient, and deeply entangled with its own substrate. A transformer is opaque because we didn’t try. We trained a massive statistical model with gradient descent, didn’t build in interpretability, and are now trying to figure out what it learned retroactively. The brain’s opacity is a property of the problem. The transformer’s opacity is a property of our process.

We didn’t create something beyond our understanding. We made something hard to understand and then turned that mystery into a myth.

Where This Leaves Us

The person who figures out the computational equivalent of hippocampal indexing at scale (small, efficient, one-shot, content-addressable, with native consolidation from working memory to long-term storage) is going to matter a great deal. Hopefully, they probably won’t need nuclear power stations.

The real question isn’t “how do we make the context window bigger.” That’s like adding more physical RAM instead of inventing virtual memory. The right question is how to design an architecture where total recall is separate from the context window—just like virtual memory separates a program’s address space from physical RAM. The window would limit how much the model can process at once, not how much it can remember overall.

We’re a long way from that. But somewhere, probably on hardware that would embarrass the current data centers, someone is going to build the missing organ. And when they do, the era of brilliant amnesiacs, systems that dazzle in the moment and forget everything, will look as primitive as it actually is.

Henry Molaison lived to be 82. He was studied, cared for, and helped advance our understanding of memory more than perhaps any other person in history. He never knew it. Every day was a fresh start, every face half-familiar at best, every conversation beginning from zero.