On Context
Everyone's building memory. Nobody's building forgetting. The hard problem isn't helping AI remember. It's helping it forget well.
You love Adidas. You’ve told your AI this. It’s in the memory, saved, timestamped.
Then your shoes fall apart. You’re frustrated. You switch to Puma.
Next time you ask for sneaker recommendations, the AI says Adidas. Confidently. Because it remembers.
It remembered perfectly. And it got it completely wrong.
Everyone’s Building Memory
The race to give AI memory is on. ChatGPT has it. Claude has it. Every startup in the agent space is building some version of it.
Mem0 offers managed memory as a service. Letta lets agents edit their own memory. Zep builds temporal knowledge graphs that track how facts change over time. Supermemory, LangMem, AWS AgentCore. The list keeps growing.
Memory is table stakes now. If your AI can’t remember what you told it yesterday, it feels broken. Users expect continuity. Developers are building it.
But remembering turns out to be the easy part.
What Happens When Memory Goes Wrong
In February 2025, a backend update at OpenAI wiped years of ChatGPT user data without warning. As one report described it, creative writers lost entire fictional universes built over months. One user reported losing eight months of a therapeutic relationship. “It was like losing a trusted counselor.”
Air Canada’s chatbot told a customer about a bereavement fare discount that didn’t exist. The customer booked based on this. Air Canada’s defense in court, that the chatbot was a separate legal entity, was rejected as “a remarkable submission.” They paid.
Users of Replika, the companion AI, experienced mass personality resets when developers pushed updates. People who’d built emotional relationships over months woke up to a stranger. “Some people felt like they’d lost a friend.”
And one of the most common complaints across every AI platform with memory?
“I already told you this.”
More Memory Makes Things Worse
The problem isn’t that memory systems need to be more complete. More memory actively degrades performance.
Think about your own brain for a second. You don’t remember every meal you’ve ever eaten, every conversation you’ve ever had, every article you’ve ever read. Your brain aggressively forgets. That’s not a bug. It’s what lets you think clearly. The stuff that matters sticks. The noise fades.
If you remembered everything with equal weight, you’d drown in irrelevant detail.
Turns out, AI has the same problem.
A January 2026 paper called FadeMem applied this directly. Modeled AI memory on the same forgetting curves psychologists have studied in humans since the 1880s. The result: 45% less storage, better retrieval quality. Not a tradeoff. An improvement.
Chroma Research tested 18 frontier models. GPT-4.1, Claude 4, Gemini 2.5, Qwen3. Every single one degraded as context length increased. In some cases, halving performance going from 10k to 100k tokens.
The “Lost in the Middle” paper showed 30%+ degradation when relevant information sits in the middle of a long context. Models are best at the beginning and end. Everything in between? Dead zone.
The wildest part: even when the model can perfectly retrieve all evidence, 100% exact match, performance still drops as context grows. The noise drowns the signal.
More information is always better? The research consistently says no.
Three Problems Wearing a Trenchcoat
When people talk about “the forgetting problem” they’re actually talking about three different things.
Truth decay. Facts that were true become false. Sarah worked at Microsoft. Now she works at Anthropic. Your AI doesn’t know.
Relevance decay. Information that mattered stops mattering. Last Tuesday’s meeting notes were critical on Wednesday. By next month, they’re noise.
Context rot. The accumulated effect of the first two, left unchecked. Think of it like a house nobody maintains. Any single day of neglect is invisible. But over months the roof leaks, the paint peels, and one day you realize the whole thing is falling apart. That’s what happens to AI systems swimming in stale context. Slow, silent, no error messages.
Different problems. Different solutions.
Truth decay needs temporal tracking. Knowing when facts change. Zep does this with four timestamps per fact. When it was true in reality, when it stopped being true, when the system learned it, when the system learned it was outdated. You can query “What was true on March 1st?” and get a different answer than “What’s true now?”
Relevance decay needs some version of forgetting. Decay functions that reduce the weight of older, less-accessed memories. FadeMem borrows from those same human forgetting curves. Memories that get accessed regularly stick around longer. Casual notes fade in days. Critical information persists for months.
Context rot is harder. It’s the interaction between the first two at scale. There are attempts: sparse attention mechanisms try to make models more efficient with long contexts, and techniques like attention sinks help models handle streaming inputs. But these solve efficiency, not the underlying degradation. According to industry analysis, roughly 70% of enterprise RAG deployments fail within a year. Nobody has a production-ready answer for why.
Zep handles truth. FadeMem handles relevance. The emergent interaction between them remains an open problem.
The Detection Gap
Every current memory system operates on the same assumption: it will be told when facts change. Contradiction detection fires when new information explicitly conflicts with what’s stored.
But in reality? A user changes jobs without mentioning it. A library releases a breaking change. A restaurant closes. A relationship ends.
Nobody tells the system. The old fact stays “current” forever.
We have sophisticated ways to represent “this fact was true from T1 to T2.” We have no good way to detect that T2 has arrived.
Detection, not representation. That’s the actual bottleneck.
“I’m pregnant” doesn’t update “drinks wine regularly.” “I got promoted to VP” doesn’t update “reports to Sarah.” “My company was acquired” doesn’t invalidate dozens of organizational facts.
These are causal chains. One fact implies changes to others. No production system models them.
Knowledge graphs are a step in the right direction. They store relationships between facts, not just isolated entries. But even inference-capable knowledge graphs only derive what their rules explicitly define. “Pregnancy affects alcohol consumption” has to be encoded as a rule. The system won’t figure that out on its own. For domain-specific implications, you still need someone to map the causal web by hand.
The model doesn’t know what it doesn’t know. It’ll give you an authoritative answer from outdated information with the same confidence it brings to everything else.
The Stuff That Matters Until It Doesn’t
There’s a whole category of context that’s even harder: ephemeral information. What’s on your screen right now. Your open tabs. The Slack conversation you’re in the middle of. The meeting that just ended.
Relevant right now. In an hour? Maybe not. Tomorrow? Almost certainly not.
Two philosophies have emerged.
Capture everything, search later. Rewind’s bet. Record your entire screen. OCR everything. Make it searchable. They raised at a $350M valuation. Then the product ate 20-40% of your battery, the recording pendant created social awkwardness, and the whole thing collapsed. Meta acquired the team. Product’s dead.
Process immediately, discard raw data. Granola’s bet. Record meeting audio, transcribe it, generate notes, delete the audio. The meeting ends, the raw context is gone. They raised $43M at a $250M valuation with 10% weekly growth.
The tool that tried to remember everything? Dead. The tool that deliberately forgets? Thriving.
The pattern: tie capture to natural events (a meeting starts, a meeting ends), process at the boundary, throw away the raw input. It’s the most sophisticated approach to ephemeral context. And it’s the simplest.
But Granola only works because meetings have natural boundaries. Start, end, done.
What about the stuff that doesn’t? Your browsing session. Your research rabbit hole. The project you’re halfway through. When does that context stop being relevant?
No tool has an answer. Screenpipe keeps everything forever. Windows Recall keeps everything forever. The decay patterns exist in theory. Zero production tools implement them.
Why Forgetting Is Inevitable
Even if you don’t care about quality, even if you think more context is always fine, four forces are converging to make forgetting unavoidable.
The economics.
Every word in an AI’s context has to be compared against every other word. Double the context, quadruple the compute cost. That’s not a metaphor. It’s how the attention mechanism actually works.
Anthropic’s engineering team found that tool definitions alone consumed 134,000 tokens before optimization. Context eaten before the conversation even starts.
Per-token costs dropped 280x since 2022. But that just means more tokens get used. When something gets cheaper, people use more of it, not less. Remember-everything is economically impossible at scale.
The law.
GDPR’s right to erasure doesn’t have an exception for “but we put it in a knowledge graph.” California’s AB 1008, effective January 2025, is among the first laws to explicitly require deletion from AI model weights.
It gets worse. There’s a standard technique for making models smaller and faster called quantization. Basically rounding the model’s internal numbers to use less precision. An ICLR 2025 paper showed that models which appear to have “forgotten” data through unlearning recover 83% of that knowledge after this standard compression step.
Virtually all production deployments use quantization. Current machine unlearning may be an illusion.
You legally must forget. You technically can’t.
Security.
Palo Alto Networks’ Unit 42 demonstrated that indirect prompt injection can permanently poison AI memory, persisting across sessions. Separate research (AgentPoison) measured 80%+ success rates for memory poisoning vectors.
Once planted, the compromise is invisible during normal interactions. A system that can’t forget is a system that can’t recover from poisoning.
Multi-agent amplification.
Staleness is contagious. When one agent’s context goes stale, it contaminates every agent it interacts with. Like one team member working from an outdated brief and spreading wrong assumptions to everyone they talk to.
The MAST taxonomy at NeurIPS 2025 found that roughly a third of multi-agent failures stem from agents operating on different versions of the truth. And Manus discovered that with a 100:1 input-to-output token ratio, most of what agents consume is redundant retrieval and re-explaining context that shouldn’t need re-explaining.
Four independent directions, all pointing the same way: you have to forget.
What You’d Actually Need to Build
A system that handles temporal context well needs six layers. Nobody has built all six. But knowing what they are tells you what to look for, and what’s missing, in any tool you evaluate.
Layer 1: Temporal knowledge graph. Track when facts are true in reality and when the system learned them. Detect contradictions. Never delete. Mark as expired. Back to the Adidas example: the system wouldn’t just know “likes Puma.” It would know “liked Adidas from January to June, switched to Puma in July.” Zep and Graphiti are building this. Exists and works.
Layer 2: Decay-based relevance. Adaptive forgetting modulated by importance. Memories accessed regularly decay slower. Casual notes expire in days, critical info in months. Compress before you delete. Your sneaker preference? High decay, preferences change. Your name? Near-zero decay. Exists in research, barely in production.
Layer 3: Context economics. Just-in-time retrieval instead of loading everything upfront. Don’t stuff the AI’s context with your entire history when you just want sneaker recommendations. Pull in the relevant slice. The Manus team found that cache efficiency is the single most important metric. With that 100:1 input-to-output ratio, good caching gives you 10x cost reduction. Exists and well-understood.
Layer 4: User-facing transparency. Memory you can read and edit. ChatGPT lets you view and delete memories. Claude lets you view, edit, and delete. Gemini is more opaque, with personal context that’s largely automatic. The principle matters: if you can’t see what the AI “knows” about you, you can’t correct what’s wrong. Most major assistants have some version of this now, but the depth varies.
Layer 5: Architectural resilience. Session boundaries that respect degradation curves. Task decomposition. Periodically re-grounding agents against their original instructions so they don’t drift. Circuit breakers for cascading failures. Understood, inconsistently applied.
Layer 6: Active monitoring. Connection to live data sources for automatic invalidation. Periodic re-verification. Confidence scoring that distinguishes “probably still true” from “definitely outdated.” Imagine the system pinging you: “You told me you work at Microsoft eight months ago. Still true?” Or checking LinkedIn automatically and updating without asking.
This layer does not exist. Nobody has built it. It’s the gap between current systems and systems that would actually work.
What You Can Do Right Now
You can’t wait for these systems to get built. Your AI has memory today, and it’s accumulating stale context today.
Audit your AI’s memory. Open ChatGPT’s memory panel, or check Claude’s memory settings. Read what it “knows” about you. You will find things that are wrong, outdated, or weirdly specific. Delete what’s stale. Five minutes. Immediately improves every future conversation.
Be the detection layer. No system can detect when your facts change, so you have to. Changed jobs? Tell your AI. Moved cities? Tell your AI. It won’t figure it out on its own, and it won’t ask.
Test for causal reasoning. Tell an AI two related facts. “I’m vegetarian” and “I love cooking with butter.” Then update one: “I’ve gone vegan.” Ask for a recipe. Does it still suggest butter? You’ll learn fast how isolated its memory actually is.
Explicitly expire context. When a project ends, a decision is made, or a situation changes, tell the system. “That meeting is over, you can forget the details.” “We went with Option B, Option A is no longer relevant.” Don’t let old context pile up. It’s not free, and it’s actively making things worse.
Evaluate tools by their forgetting. When choosing an AI tool, don’t just ask “what does it remember?” Ask “how does it forget?” Does it have decay? Can you edit memory? Can you delete? A tool that can’t forget well will degrade over time.
The Question
The question isn’t whether AI systems will forget. They already do. Every context window has a limit, every session eventually ends, every system hits the point where it has to throw something away.
The question is whether they’ll forget well.
Right now, forgetting happens by accident. Truncation. Token limits. Crashes. Memory wipes. The system hits a wall and something gets lost and nobody chose what.
The research says something different is possible. Selective forgetting that improves retrieval. Temporal tracking that knows when facts expire. Decay curves borrowed from how human memory actually works.
Everyone’s building memory. The hard problem, the one that will separate the systems that work from the ones that don’t, is building forgetting.
Intentional, principled, well-architected forgetting.