Introduction After publishing Part 1, a comment came in that changed how I think about agent memory entirely. "One thing that's missing from the comparison space: memory decay. All the tools you've listed treat memory as an append-only store." That one line exposed a quiet assumption baked into every tool I covered — Mem0, LangMem, AWS AgentCore, and even the manual implementation. They all append. None of them forget. This post is about fixing that. Why Never Forgetting Is Actually a Bug Imagine a customer support agent that has been running for 6 months. Every conversation, every user preference, every trivial question — all stored forever. Here is what starts to go wrong: Problem What Happens Stale context User changed their stack from React to Vue 3 months ago. Agent still recommends React. Retrieval noise Searching "user's project" returns 50 results — half of them outdated. Conflicting memories User said they are a beginner in January. They are now a senior dev. Agent still treats them as a beginner. Storage bloat Every small talk, every typo correction, every one-off question — all stored forever. The root problem is the same in all cases: memory was never designed to forget. The human brain solves this naturally. You remember important things for years. You forget what you had for lunch three Tuesdays ago. That selective forgetting is not a flaw — it is how the brain stays relevant and focused. AI agents need the same mechanism. The Idea Behind Intelligent Forgetting The core concept is simple: Not all memories are equally important. A user's allergy should persist forever. A casual question about syntax should fade in days. Memories should weaken over time if they are not accessed or reinforced. Memories that are used frequently should actually get stronger, not weaker. When memory gets too weak, it should be pruned automatically — no manual deletion needed. This is the philosophy that separates append-only memory from decay-aware memory. What the Research Says The Ebbinghaus Forgetting Curve Back in the 1880s, psychologist Hermann Ebbinghaus studied how human memory fades over time. His finding was simple: memories decay exponentially unless reinforced. The more time passes without revisiting something, the weaker the memory gets. The key takeaway for AI agents is not the math — it is the insight: Forgetting is not a failure. It is how a memory system stays clean, fast, and relevant. Modern AI memory research has started applying this exact idea to agent systems. FadeMem (2026) — The Most Complete Implementation Paper: FadeMem: Biologically-Inspired Forgetting for Efficient Agent Memory (arXiv:2601.18642) FadeMem is the most rigorous research paper on decay-aware agent memory to date. Here is what it proposes and why it matters: What it does: FadeMem splits memory into two layers: Long-term Memory Layer (LML) — for high-importance facts. Things like user preferences, critical context, long-standing goals. These decay very slowly. Short-term Memory Layer (SML) — for lower-importance memories. Casual interactions, one-off questions, context that was relevant once but probably won't matter again. These fade faster. Every memory gets an importance score based on three things: how relevant it is to recent conversations, how often it has been accessed, and how old it is. Over time, unimportant and old memories naturally drop out. Why it matters: After 30 days of continuous interaction, FadeMem tested against Mem0 on a standard benchmark: Metric Mem0 FadeMem Critical Fact Retention 78.4% 82.1% Storage Used 100% 55% FadeMem retains more of what matters while using 45% less storage. The reason: it is not holding onto noise. How to use it today: FadeMem is a research paper, not a production library yet. But the architecture it describes — dual layers, importance scoring, decay-based pruning — is something you can implement yourself. We will do exactly that in the code section below. YourMemory — Open Source MCP Server with Decay Built In GitHub: cognitive-ai-memory YourMemory is a practical open-source MCP server that bakes the Ebbinghaus forgetting curve directly into how memories are retrieved and stored. What it does: Every memory has an importance score assigned at the time it is stored. When you search, results are ranked by both relevance AND recency. A highly relevant but 6-month-old memory scores lower than a slightly less relevant but recent one. Memories that are accessed frequently get stronger automatically. Stale memories decay and disappear without any manual cleanup. Stack it runs on: PostgreSQL + pgvector + Ollama (local embeddings, no API cost) + FastAPI How to use it: If you are building Claude-based agents or any MCP-compatible agent, you can plug YourMemory in as your memory server. Three tools are exposed: store_memory — st