Why does AI memory go stale, and can it forget on purpose?

The cases

What does stale memory look like?

From people who looked inside their own memory stores, all read on 20 October 2026:

• A team ran a self-hosted, open-source Mem0 for 32 days (one AI agent, one person, a small local model on default prompts for 20 days, then Claude Sonnet 4.6), then audited all 10,134 entries: 224 survived, and only 38 without a rewrite. “97.8% junk across the entire collection.” More than half the junk was the agent’s own startup instructions, re-extracted every session. Mem0 closed the issue in June, citing decay, temporal reasoning and deduplication shipped since, and calling extraction permissiveness and feedback-loop prevention “ongoing areas of improvement.”
• A user of Mem0’s open-source v3 pointed out that “Works at Company A” and, three months later, “Works at Company B” both stay stored, and that a question about where the user works can rank Company A first “because the scoring signals don’t incorporate recency.”
• A Claude Code user asked for auto memory to decay: “A memory saved three months ago is presented to the agent with the same authority as one saved yesterday.” Memories “should decay over time unless reinforced by use. This mirrors how human memory works.” It was closed automatically as inactive in June 2026.
• Another Claude Code user mentioned once that they were close to their usage limit, and it became a standing rule: from then on Claude “keeps talking about ‘cost’” in every review. “I feel like I have to spend time almost every day deconstructing rules it has written down this way.”
• Two memories kept themselves wrong. Claude Code wrote a hallucinated warning into auto memory, and every new session was primed by it until the user deleted the note. A Honcho user deleted, by hand in the database of a local install, the document a baseless conclusion came from, and the conclusion came back: “discussing the bad memory increases Honcho’s confidence in the bad memory.”

OpenAI says the same of its own first design: saved memories “tend to go stale over time and eventually become incorrect or irrelevant.”

The mechanisms

Why does AI memory fill with stale, wrong and duplicate facts?

Too much goes in, and what comes out goes back in

Most systems have a model pull facts out of the conversation, and a model told to find facts finds them everywhere. Switching the audit’s extractor to Sonnet stopped the invented people but not the volume: its batch was still 89.6% junk, against 95 to 98.5% before, because “A better model follows the extraction prompt more faithfully, which means it extracts more indiscriminately.” Duplicate checks catch less than they seem to. Honcho compares a new observation only with its single closest match, at 95% similarity, so paraphrases slip through, and one user found 300+ near-duplicate observations in context by session 32. Mem0’s platform merges duplicates as they’re added.

A memory brought back into the conversation also looks, to the extractor, like something just said. In the same audit one hallucinated preference (“User prefers Vim”) was stored, recalled and extracted again until 808 entries said it. “Nobody in the system uses Vim.” claude-mem closed this loop for its own tools in v13.35.0: “Retrieval no longer re-observes its own output.”

Little leaves, and search can’t tell old from new

Of the thirteen systems our directory rates, five let unused memories fade on their own (two of them only on some plans or once you switch it on), three do some of it, four don’t, and one doesn’t say. In the rest, a note from March weighs the same as one from this morning. How human forgetting works, and why it helps, is on the Field Guide’s forgetting page.

When a new fact contradicts an old one, many systems keep both, some on purpose. Closing two requests for conflict resolution in its open-source v3 (#4896, #4904), Mem0’s team wrote: “Both memories being stored is intentional — the historical record has value, and the retrieval layer is designed to prioritize the most relevant (typically newest) memory.” Users in #4956 have since reported that the open-source ranking function, score_and_rank, has no recency term; one who checked the code in September found “zero matches.” (Psychology calls this clash interference.)

Retrieval by meaning ranks the old fact and the new one almost equally, because they are about the same thing. A self-hosted Mem0 user wrote that “vector search returns them sorted by similarity rather than recency,” without timestamps, so the model “receives multiple conflicting ‘truths’ and gets confused” (#5352). A LangChain user whose agent rebuilt a cache in an abandoned database wrote: “Retrieval returned both memories, correctly. The agent just picked the older one because it was written more confidently.”

The distinction

Should a memory change at once, or slowly?

It depends on the kind of memory, and much of the argument comes from treating two kinds alike.

Facts should be replaced the moment they change. The user moved city, changed jobs, switched databases, pushed the deadline back. One clear statement is enough, and a memory that weighs “I moved to Denver” against months of “lives in Portland” is wrong. Builders who ask for instant replacement, with the old fact kept as history, are right. Zep is designed around this: each fact has a window when it was true, so you can ask what is true now or what was true in March.

Beliefs and identity should settle slowly. Who someone is, what they value, how a working relationship goes, what the assistant itself is like: one remark on a bad day shouldn’t rewrite these. The Claude Code user above saw the opposite happen, when a passing comment about a usage limit became a rule for every session.

Counterparts is designed to change its core, what it holds about who it is with you, slowly: a change you declare moves a core memory in about three days of saying so, and a plan held there leaves at once when it’s done. Its design document states the wider rule, “world-state should flip on one clear correction; identity should not,” but the fact and belief rules that would apply it aren’t wired in yet; today an ordinary memory changes when Claude settles it as changed or corrected. The hard part is the line between the kinds. “Prefers short answers” might be a passing mood or a lasting trait, and in every system we read that sorts memories by kind, whoever writes the memory, usually a model, makes that call. For how people rewrite a recalled memory, see the Field Guide on reconsolidation.

Open problems

What is still unsolved?

Telling a change from a contradiction. “Works at Acme” and “runs Acme’s GitHub” are both true; “works at Initech” usually means a job change, and sometimes a second job. Supermemory sorts the pair into updates or extends, Mem0’s platform into supersede or merge, Cognee into current, superseded or conflicting, Counterparts into changed or corrected; ChatGPT takes your word that something is “incorrect or outdated,” and Engram waits for you or the assistant. Either a model guesses or a person decides, and none of the systems we read publishes how often the guess is right. In one public measurement, in a Graphiti bug thread, a contributor ran 120 test pairs past its judge (deepseek-v4-flash), which resolved none of the 30 contradictions and none of the 30 renames in either version of the code tested. Counterparts used to fade an older memory a little as soon as a new one looked like its update. Since 0.3.27, as an experiment, it only marks the older one “may be out of date” until the nightly pass confirms, because “the guess was wrong too often to cost the older memory anything before then.”

Knowing what to forget. Fading clears out trivia, and the same rule lets go of what matters but rarely comes up: an allergy, a constraint you need once a year. Engram never fades some kinds at all (“A production constraint that only matters during one migration a year later is exactly as trusted on that day as when you wrote it”). Mem0’s decay is “a soft ranking bias, never a filter.” Counterparts archives a faded memory rather than deleting it. None of them can know in advance which quiet memory will matter.

When a decision was made, not when it was written. The LangChain user above built a recency resolver that “worked exactly one time,” because “the ‘recency’ of a decision isn’t the same as the recency of the write.” They settled on one shared store, a product the post recommends, where “the newest explicit write wins.” Zep is built to order facts by when they were true rather than when they arrived.

Whether a benchmark can see any of this. LongMemEval tests five abilities, one of them knowledge updates: after a fact changes, does the system give the new one? Such a question checks one changed fact in a test history, not a store after months of daily writes, which is where the audit’s 97.8% came from. Our benchmarks page breaks another benchmark, BEAM, down ability by ability, keeping up with updates and resolving contradictions among them, with every setup named; those conversations are test histories too.

What helps today

How do I stop my agent’s memory filling with junk?

Each step comes from someone who did it.

• Keep the extractor from saving what it was just shown, the audit’s first fix: “Mark recalled memories so the extraction step doesn’t re-extract them.”
• Show the model each memory’s date. The #5352 workaround prefixes fetched memories with date and ID; Claude Code records when each note was written.
• Give the agent update and delete, not only add. Mem0 has both in either version; the #5352 workaround exposes them mid-session.
• Run a scheduled cleanup that merges near-duplicates and lets the newer date win. On a 90-fact store, #5352’s script removed 8 duplicates and merged 6 on its first run.
• If what you store is mostly facts, pick a system that handles a changed one for you (table above).
• Look at it. In Claude Code, /memory opens the auto memory folder, and /doctor prompt-audit checks your CLAUDE.md files for outdated or conflicting instructions. More in our Claude Code memory guide, and the add-ons people use are compared in the guide to memory plugins.

FAQ

Questions people ask