At least six sites in this hub write about memory, each minding its own business. Neuroscience covers how an experience goes from fleeting to still-there decades later. Psychology covers how half of what you remember was assembled by the person you are now. The AI site covers how a model wipes out old skills while learning new ones. The site on assistant engineering covers how you actually build the "remembers you" part of a product. Meta-knowledge covers how long to wait before you review.
Put them side by side and the easy question is whether they resemble each other. Of course they do; that question costs nothing.
The genuinely odd thing is elsewhere. A hundred billion nerve cells, a few hundred billion numbers, and a database full of text chunks share no materials whatsoever. Why do they fail in the same two ways — unable to hold on to what matters, and perfectly willing to narrate, in convincing detail, things that never happened?
Start by dismantling a deep illusion. Recall feels like playing back a tape. The brain has no tape.
When something happens it gets pulled apart, and the pieces are parked in whichever region handles them: colour with colour, sound with sound, where-it-happened with space. No single location holds the whole scene. What ties the pieces together is the hippocampus, the pair of structures deep in the brain that act as an index. At the moment of the event it rapidly notes that these particular fragments belong together and staples the same bookmark onto them. When you recall, it follows the bookmark, re-gathers the scattered pieces and assembles them on the spot. Whatever is missing gets filled in from what's similar, and from what you know and expect today.
So memory is generated, not read out. There are experiments behind that sentence. The psychologist Elizabeth Loftus had families plant the suggestion of a childhood event that never happened; roughly a quarter of adult participants "remembered" getting lost in a shopping mall as a child and being found by a stranger, and volunteered extra detail unprompted.
There is also an offline shift. A freshly learned thing starts out hanging on the hippocampus — fast, but easily overwritten. To become something still present in forty years it has to migrate slowly into the large, stable warehouse of the cortex. That migration is called consolidation, and it happens mostly while you sleep. In deep sleep the hippocampus replays the route you walked during the day, compressed: a few minutes of walking runs through in a few hundred milliseconds, over and over, teaching the cortex a little at a time. A badly slept week isn't a week that didn't happen. It's a week that never got filed.
And here is the unsettling part. Every time you pull a memory up, it doesn't just get inspected and put back. It briefly unseals, becomes soft and editable, and is then stored again. This is reconsolidation — the consolidation step, run again on every use. Each act of recall quietly rewrites the memory, mixing in your current mood, someone's offhand remark, your present understanding. The memories you revisit most are probably the ones you have altered most.
Forgetting isn't a failure of the system either. Precisely because you can't recall what every dog you ever saw looked like, you have the concept "dog" at all.
The other side of the house is a much smaller desk. Someone reads out a phone number while you're hunting for a pen; for those few seconds the number is in your head, and one distraction later it's gone. That's working memory. It isn't a scaled-down version of long-term memory — it barely stores anything, it just keeps a few things lit. Capacity is closer to four than to the famous seven plus or minus two, and it counts parcels rather than parts: in 138 0013 8000 you are holding three blocks, not eleven digits.
What matters more is who runs the desk. The prefrontal cortex, right behind your forehead, doesn't hold much content itself; it directs. It keeps the current goal raised, decides what gets onto the desk, and fends off distraction. Under stress that fragile activity gets scattered outright, which is why your mind goes blank in an exam: the desk has been cleared without warning.
"The model has memory now" can mean three quite different things: what's in the window, what's in the weights, and what's in the attached store.
The window. Each time a model replies, all it can see directly is the text inside its context window. Talk long enough and the earliest turns slide out; at that point it simply doesn't know them. The AI site puts the framing bluntly: the window is a working set, not a database, and the goal is to put the right things in it, not more things. Being in the window doesn't even guarantee being seen. Put the key fact at the start or end of a hundred-thousand-token context and recall runs around eighty percent; put it dead centre and it drops to about half.
The weights. Nothing a model read is stored verbatim anywhere. It's kneaded into hundreds of billions of connection weights, and an answer is generated on the spot as the most answer-shaped thing to say. Which is why it occasionally invents, with complete composure, a citation or a figure that doesn't exist. That's hallucination.
This kind of memory has another notorious flaw: train on new data and the old skills wash out. It's called catastrophic forgetting, and it was identified back in 1989. The AI site gives a twenty-line experiment you can run: learn task A, accuracy around 0.95; then learn task B, go back and test A, and it's down to about 0.55.
The cause isn't capacity. Heavily over-parameterised networks do it too. There's room for both tasks, but gradient descent has no reason to look for the solution that serves both — it just walks downhill on the current one. In engineering terms: the weights are one globally shared mutable state, learning a new task is an in-place overwrite, and there is no versioning and no transaction.
Out of this falls a spectrum, the stability-plasticity dilemma: weights too rigid and nothing new gets in, weights too loose and each new thing erases the last. Three families of fix sit at different points along it — attach a spring to each important weight and pull it back towards its old value (elastic weight consolidation), keep a replay buffer and mix old samples in with new ones during training (experience replay), or give each task its own slice of parameters and freeze it when the task is done (parameter isolation).
The attached store. This is what most people mean today by giving an AI a memory: turn each passage into a string of numbers so that similar meanings land at nearby coordinates, then at query time pull back the nearest few and drop them into the window. The thing holding those coordinates is a vector store, and what it supplies is the missing "find it again from a cue" step.
Its ceiling isn't the model, it's the retrieval. The page on retrieval quality says it flatly: hand the model the right document and it will almost always answer correctly; fail to, and all it can do is make something up. A system with recall@5 = 0.71 means that for 29% of questions the correct document never entered the model's field of view at all — a number most teams have never measured.
Worth noting: the people closest to shipping products stopped treating memory as a storage problem some time ago.
The first claim on the assistant-engineering site is that managing conversation history, task scratchpads, user profile and domain knowledge in one place is the root cause of assistants going incoherent after three turns. These four have completely different lifetimes — a scratchpad should be burned after the task, a profile should outlive everything — and once they share a vector store, the next task gets polluted by the last one's leftovers.
The long-term layer then splits again by query type: similarity goes to the vector store, exact facts like "what's my name" go to a key-value table, and "what happened last time" goes to an append-only event log ordered by time.
Two details are worth carrying away. First, when a model maintains the user profile itself, every write must cite a specific message as evidence, and no evidence means no write — otherwise a third of the profile is model inference six months on. Second, the profile needs an eviction policy. Let it grow to five thousand tokens and it eats half the context budget; leave the event log unpruned for half a year and a single retrieval will blow the prompt apart.
Between people and machines sits a practical line of work: learning science. Its subject is how to make something stick inside a system already known to reconstruct and to forget.
The finding is mildly counterintuitive. Memory doesn't get stronger the more densely you review; it gets strongest when you review right at the point of nearly forgetting. The forgetting curve described by the psychologist Hermann Ebbinghaus drops fastest in the first day or two, but each reactivation flattens the decay, so the next interval can stretch — a day, then three, then a week, then a month.
Retrieval practice is the sharper result. Spend the same time rereading versus self-testing and the long-term gap is large: in one classic study the self-testing group could recall about half the material a week later, the rereading group about three-tenths — even though the rereaders felt more fluent and more confident at the time. That feeling has a name, the fluency illusion. The smoother it reads, the easier it is to mistake recognition for mastery.
The mental-models site draws the line more precisely. Recognition understanding is passive: you see the answer and think, yes, that's it. Generative understanding is active: you can rebuild the thing from a blank page. Whether you can re-explain it with the book shut is the only honest boundary between the two.
Back to the question from the start: why do three systems made of entirely different stuff fail in such similar ways?
Because they made the same compromise in the same place. None of them kept the recording. What each keeps is a lossy trace, plus a cue for finding it again.
People keep fragments and the bookmark the hippocampus stapled on. A model's knowledge is smeared across hundreds of billions of weights, with the source text nowhere. A vector store keeps chunks and their coordinates in semantic space. All three are alike in the consequence: when the thing is needed, it has to be rebuilt on the spot.
That consequence is hard. Rebuilding means filling gaps, and filling gaps means sometimes filling them wrong. Fill them right and we call it a good memory. Fill them wrong and we call it false memory in people and hallucination in machines. These aren't two similar-looking bugs; they are two exits from one path. The line from the retrieval-quality page joins them neatly: without the right document, all it can do is make something up.
The second thing in common is a balance. The brain has to do two opposite jobs at once: keep two near-identical experiences separate (today the car is in section B, yesterday it was in A — let those blur and you never find it), and reconstruct the whole from half a cue (three notes, half a face). Neuroscience names these pattern separation and pattern completion, and assigns them to two different parts of the hippocampus. Engineering calls the same balance stability versus plasticity, and has already turned it into an explicit knob: the coefficient in elastic weight consolidation, turned up for stability and down for plasticity. One trade-off, expressed once as anatomy and once as a hyperparameter. The directions are reversed, which is the interesting part — the brain's problem is how to actively forget what should go, and the network's problem is how not to passively lose everything.
The third is the most immediately useful. How certain something feels and how accurate it is are nearly independent. The psychologist Ulric Neisser tracked people's memories of the day the Challenger shuttle exploded, comparing accounts given the next day with accounts given two and a half years later: nearly half the details had been rewritten, some people were flatly wrong about where they had been, and confidence ratings hadn't budged. Among US convictions later overturned by DNA evidence, roughly seventy percent involved eyewitness misidentification. Vivid, fluent and certain is not evidence of accuracy in people. It isn't in models either.
To show a connection like this is more than decorative, you have to point at a specific problem it solved that had no good answer before. There is one here, and the dates are clear.
Catastrophic forgetting was identified in 1989, and what it blocked was elementary: let a network learn tasks one after another and each new one erases the last. Brains do this every day and barely suffer from it.
The complementary learning systems theory, proposed in 1995, named the correspondence. The brain isn't one memory system but two: one fast and easily overwritten, one slow and stable. New experience lands on the fast one, and nightly compressed replay teaches it, bit by bit, to the slow one. Splitting the job by speed is what pulls "learn quickly" and "don't overwrite the old" apart from each other.
Later engineering mostly just built that blueprint. Experience replay — keep a buffer, sample old examples at random and train them alongside the new — is still very nearly the strongest baseline in continual learning. Generative replay, in 2017, went further: store no old data at all, and instead train a generator to synthesise things that look like the old task, saving storage and sidestepping privacy. That line's stated inspiration is the hippocampus replaying experience during sleep.
It has a bill of its own to pay. The generator is also learning continually, so it degrades across generations; its "old samples" drift further from the real thing, error compounds along the chain of tasks, and over a long sequence the early tasks collapse anyway. What was collected from next door is a real architecture, not a universal charm.
But the test is met: a six-year-old engineering impasse was answered by the anatomy of another field, and three decades later that answer is still the best one available.
Step up a level from memory and you can see what cross-disciplinary borrowing actually saves. If only the word travels, you have gained nothing. If the reasoning underneath travels with it, you inherit everything that reasoning has already earned.
The translation is almost line by line. Don't ask leading questions — "did he swing first?" and writing your conclusion into the prompt are the same gesture. Store content separately from its source: people routinely keep the content and lose the source, mistaking something heard, imagined or dreamt for something witnessed, and requiring an evidence message ID on every profile write is the same defence. Record at the time instead of recalling afterwards: a team reviewing an incident shouldn't rely on memory, because hindsight reshapes it, and every entry in an event log needs a timestamp or the model will read yesterday's decision as today's.
Now for the sentence you hear most: "the model has memory now."
Nine times out of ten, "memory" in that sentence means storage plus retrieval. But the most valuable part of human memory isn't in the storing or the retrieving. It's in the night shift — in weaving new experience into old knowledge and grinding detail down into regularity. The neuroscience site says so without hedging: bolted-on memory has the shape but not the substance, and the hard part was never storing and fetching.
The five questions below aren't a trap. They're for deciding whether a claim can carry a design decision.
1. Is writing selective? A system that keeps everything is a log, not a memory.
2. Is reading retrieval or reconstruction? Something that never errs and never fills gaps is a database. Only something that fills in, and bleeds between entries, is on the reconstruction path — which is also why it will inevitably make things up.
3. Does reading rewrite what was read? In people it does; that's reconsolidation. Query a vector store ten thousand times and not one character changes.
4. Is there offline reprocessing? Weaving the new into the old, wearing detail down into rules. In people this happens in sleep.
5. Does it forget on purpose? Is there an eviction policy, or does it just run until it bursts?
The context window fails essentially all five. What it corresponds to isn't long-term memory at all, it's working memory — and it's missing the more important half of that. A human desk has a controller deciding what gets on and keeping the irrelevant off; the window has no such role, it looks at whatever you put there, and it carries that sagging middle of the recall curve besides. Which makes "a longer window means a better memory" the most expensive misunderstanding in this area. Desk size was never the bottleneck. The problem isn't holding enough, it's choosing.
Vector retrieval passes question two and fails three and four outright. Four is the damaging one: nothing that goes in gets replayed at night or abstracted into a concept, so six months later the store still holds the same raw passages. It is an excellent way to find things by cue. It does not digest.
Knowledge in the weights is a different case. Training itself is a huge offline reprocessing pass, and it really does render vast material down into regularities, so it passes question four far better than a vector store does. What it lacks is episodes: it cannot remember what you said yesterday. The three families of continual-learning fixes are attempts at question five.
Agent memory engineering comes closest of the four, which is no accident — the people doing it were deliberately building towards the full meaning of the word. Layer separation, write routing, a self-maintained profile, eviction policies, an auditable event log: four of the five questions answered explicitly.
One more case deserves its own mention, because it is an honest borrowing: spaced-repetition software. It doesn't gesture at the curve, it computes it and schedules against it. What it took wasn't the shape of a word, it was a relation you can put numbers into. That is what collecting on a connection actually looks like.
And the drifting case is easy to spot. "Organisational memory", "the memory of a city" — these can be lovely, but when you try to make a design decision with one, all five questions come back blank. Push on it and you find that what it wanted has another name: the best thing a team can do after an incident isn't to improve its "organisational memory", it's to write things down as they happen, because hindsight reshapes recall. That's a logging problem, and the prescription is entirely different.
Having taken it apart, it's only fair to say how to use it. Roughly three tiers.
When it's countable, count. Review schedules from the forgetting curve, working-memory capacity in chunks, recall@k for retrieval, the knob along the stability-plasticity spectrum — these carry numbers, and numbers can be measured and tuned. The plainest test of all: that important thing you learned last week, with every document shut, can you still state its mechanism? If not, the understanding is still sitting at the recognition layer.
When the mechanism is clear, use it as a model. "Reconstruction must fill gaps, and filling gaps can fill them wrong" yields no number, but it does make predictions, and the predictions can be checked. A direct one: once you accept that false memory and hallucination are two exits from one mechanism, "just make the model more careful and hallucination goes away" is clearly the wrong direction. What can be improved is not contaminating the input, not inflating confidence, and keeping source separate from content — not hoping that reconstruction turns into playback. That's exactly what the retrieval page is saying: without the right document, no amount of caution helps.
The rest is rhetoric. Nothing wrong with rhetoric; plenty of good sentences come from it. Just don't build on it.
Keeping the word straight is worth the trouble, and not in order to correct anyone's usage. It's that both of these systems have paid dearly for what they know: it took decades for people to accept that forgetting is part of the design and that certainty isn't accuracy. The machine side is walking the same road again, and a few stretches of it no longer have to be walked.