Memory systems for LLM agents

Cognitive-science vocabulary is the shared language. CoALA (2023) separates working memory from three long-term stores: episodic (what happened), semantic (facts), procedural (how to act).¹⁴ Zhang et al. (2024) reduce the operations to writing, management and reading.¹⁶ Du et al. (2025) list six: consolidation, updating, indexing, forgetting, retrieval, compression.¹⁵ The surveys of December 2025 and January 2026 add two axes: the form of the memory (tokens, parameters, latent state) and its subject (the user or the agent itself).^17,18

Your six requirements map onto that vocabulary. Retaining facts is semantic memory plus indexing. Connections are the structure of the store and the retrieval operation over it. Temporal data is the timestamp schema on each memory plus time-aware retrieval. Decay is the forgetting operation. Updates are consolidation with history. Figure 1 places each of them in one architecture.

Every production system runs the same loop. A turn arrives; an LLM extracts candidate memories; a resolver compares them with the top-k existing memories and decides what to write; the store indexes them; a query pulls a small set into the context window; a background job cleans up. MemGPT framed it as an operating system in 2023: core memory in context, recall and archival stores outside, the model editing its own memory through tool calls.⁹ The differences between systems are the decisions each stage makes.^1,2,77,79

Two choices dominate cost. Hot-path extraction adds one or two LLM calls to every turn; Mem0’s 2026 pipeline uses a single ADD-only call, LangMem and Memobase buffer and flush in the background, Letta and OpenAI compute memory at “sleep time”.^25,42,43,52 Verbatim versus extracted storage is the other: a controlled ablation found verbatim chunks beat extracted memories by 15.9 points on LoCoMo and 22.0 on LongMemEval-S, so keep the raw episodes even when you extract.⁸³ Reinforcement learning now trains the write decision itself: Memory-R1 reports a judge score of 62.7 against 45.7 for Mem0 with the same 8B model.⁵⁶

Retention starts with the resolver. Mem0’s paper retrieves the ten most similar memories and asks an LLM to emit ADD, UPDATE, DELETE or NOOP per candidate.¹ Google Memory Bank records CREATED, UPDATED or DELETED per consolidation; AWS AgentCore emits AddMemory, UpdateMemory or SkipMemory and updates only when the new fact has higher confidence.^77,79 LangMem patches or, if enabled, deletes contradicted memories.⁴³

The update decision is where history is won or lost. Overwrite policies (legacy Mem0 UPDATE, Memobase profile replacement, Letta block edits, AgentCore consolidation) keep one current value.^41,52,79 Invalidate policies (Graphiti, Supermemory versions, Memory Bank revisions, Cloudflare keyed facts, Hindsight observations) keep the old value with an end date.^{4,47,77,81,91} In 2026 Mem0 adopted a third policy: ADD only, both facts survive, and ranking plus a background Dream job decide which one the agent sees.^25,82

Fact Knowledge-update questions expose the difference. On LongMemEval-S, Zep scored 83.3 on the knowledge-update category against 78.2 for full context with gpt-4o.² A June 2026 study of bounded, self-maintained memory found a 15-point loss on the same category even with a frontier model, because the agent overwrote facts it later needed.⁸⁴ A study that penalises answers built on invalidated memories found agents reuse stale facts often enough that memory systems gave only marginal gains.³⁵

Vector search returns memories that sound like the query. Multi-hop questions need memories that are linked to the answer, which is a different relation. HippoRAG builds an OpenIE knowledge graph and runs Personalized PageRank from the query’s entities; HippoRAG 2 adds passage nodes and reports a 7% gain on associative memory tasks over the best embedding model.^11,12 Graphiti combines cosine similarity, BM25 and breadth-first traversal, then reranks with reciprocal rank fusion, maximal marginal relevance, node distance from a focal node, episode mentions or a cross-encoder.⁵

Three link models are in use. Entity graphs with typed edges: Graphiti, Cognee, and Hindsight’s entity, temporal, semantic and causal links.^46,89,91 Note-to-note links generated by an LLM, as in A-MEM’s Zettelkasten, where a new note also rewrites its neighbours’ tags.¹⁰ Spreading activation, the 1975 Collins and Loftus model, implemented in 2026 by SYNAPSE with lateral inhibition and temporal decay.^60,66 Mem0’s paper measured its graph variant at +1.6 points overall on LoCoMo, helping temporal and open-domain questions and hurting single-hop ones, and Mem0 then removed graph storage from its open-source SDK in 2026.^1,25

Inference Use a graph when questions chain through entities: who decided, what depends on what, what changed after an event. Use vector plus keyword search when questions are about a single fact. Every strong 2026 system runs both and fuses the lists with reciprocal rank fusion.^5,33,81

Temporal data needs two clocks. Valid time says when a fact was true in the world. Transaction time says when the system learned it. Graphiti stores both on every edge as valid_at, invalid_at, created_at and expired_at, resolves relative phrases such as “last month” against the episode’s reference time, and answers “what was true on date X” and “what did we believe on date X” with filters.^3,6 Hindsight keeps occurred_at next to created_at; Supermemory keeps eventDate next to documentDate; Cloudflare resolves relative dates with arithmetic rather than an LLM.^48,81,91

Most other systems keep one clock. Mem0 stores created_at and updated_at, bakes absolute dates into the memory text, and offers a platform-only reference_date filter and a temporal reasoning add-on.²⁸ Memory Bank, AgentCore, LangGraph and Letta expose creation and update times but no validity interval.^41,44,76,78 Cognee builds a separate event timeline when temporal_cognify is on.⁴⁵

Fact Temporal reasoning is the weakest category on every benchmark. In the Mem0 paper’s harness, temporal questions scored 55.5 for Mem0 and 58.1 for its graph variant, against 72.9 and 75.7 on open-domain questions.¹ Zep’s paper reports 62.4 on LongMemEval temporal reasoning against 45.1 for full context.² A January 2026 method that indexes memories on a semantic timeline instead of dialogue order reports up to 12.2 points absolute gain.⁶¹

Forgetting in agent memory is a scoring problem. The systems that do it well never delete: they lower a memory’s rank until it stops being retrieved and keep the record for audit and for “as of” queries. Generative Agents added a recency term of 0.995 per hour to relevance and an LLM importance score.⁷ MemoryBank used the Ebbinghaus curve R = e^−t/S and raised S by one on each recall.⁸ MemoryOS promotes segments by a heat score that sums visits, interaction length and an exponential recency term.¹³

Cognitive science offers better-fitted curves. Human forgetting follows a power law rather than an exponential.⁶⁵ ACT-R’s base-level activation, the log of summed power-law decays over every past access, captures recency and frequency in one number and has been ported to LLM agents.^63,95,96 FSRS, the spaced-repetition scheduler, gives a closed-form retrievability with stability in days and is the natural model for a memory that should stay retrievable after rehearsal; no agent system uses it yet.⁶⁴ Figure 6 compares the four.

Fact In production code, decay appears as TTLs and rank multipliers, and it is off by default everywhere. The table lists what each system ships. Two 2026 papers measure the payoff: Oblivion gates the read path by retention and reports 90.6 on LongMemEval-S against 89.0 without gating, with up to 73% fewer tokens at 120K context; FadeMem reports a 45% smaller store with better multi-hop reasoning.^58,59 No study yet isolates decay-based pruning against retrieval precision on a shared benchmark, so treat these as promising rather than settled.

Two benchmarks carry most claims. LoCoMo is ten long synthetic conversations with 1,986 questions, of which vendors score 1,540 after dropping the adversarial category.¹⁹ LongMemEval-S is 500 questions over about 115k tokens of history and tests five abilities: extraction, multi-session reasoning, temporal reasoning, knowledge updates and abstention.²¹ Chroma’s context-rot study explains why memory beats context stuffing: all 18 models tested scored higher on a 300-token focused prompt than on the 113k-token full history.²²

Fact LoCoMo is saturated and partly wrong. Penfield’s April 2026 audit found 6.4% of the answer key incorrect and the published judge accepting up to 63% of intentionally wrong answers, which puts the honest ceiling near 93.6%.²⁰ Zep’s own experiments say LoCoMo stops discriminating above about 80%.⁸⁸ One system spans 36 points depending on who ran it: Zep scored 58.4 when Mem0 re-ran it, 75.1 when Zep ran it in 2025, and 94.7 with gpt-5.4 in 2026.^29,30,31 A public attempt to reproduce EverMemOS’s 93.05 reached 38 to 52.⁵⁵

Inference Three results are more informative than the leaderboards. MemoryAgentBench, with four competencies including selective forgetting, placed every commercial system below a long-context GPT-5-mini baseline.³⁵ MemDelta showed that swapping only the embedding model moves accuracy by 6.2 points and that Mem0 and a plain cloud RAG were statistically tied at about fifty times the cost.³⁶ A June 2026 study of twelve systems across five workloads concluded that no single architecture dominates.⁸⁷ BEAM extends histories to 10M tokens, where the best reported scores are 60 to 64 against 25 for plain RAG, so that frontier still discriminates.^32,37 Mem0’s own 2026 advice is to read every score paired with its token cost.^85,98

Scores are 0 to 3 per requirement, from documentation and source code read on 2 September 2026, not from benchmarks. 3 means the mechanism is built in and documented with field names; 2 means partial or opt-in; 1 means a workaround; 0 means absent. Hover a cell for the reason, click a row for the evidence. Not scored: MIRIX (little activity since February 2026), Memori (conflict handling undocumented), EverMemOS (public reproduction failed).^34,55,93

The decision criterion is which requirement you cannot work around later. Temporal correctness and history need a bi-temporal store; that is not a feature you add after the first million memories. Connections need a graph or link model in the store. Decay and expiry can be added in the read path of any system. Production readiness you can only buy or wait for. Consumer assistants settled the user-facing side in 2026: categorized, editable, user-visible memory with sensitive topics off by default.^73,92

What to build yourself, whichever store you pick

• Stamp every memory with four times: valid_at, invalid_at, created_at, expired_at. Resolve relative dates against the message time at write time.^3,81
• Keep the raw episodes. Extraction loses information; verbatim retrieval beat extraction by 16 to 22 points in a controlled ablation.⁸³
• Score reads as relevance plus recency plus importance, with a power-law or exponential recency term and a floor so nothing disappears silently.^7,26,50
• Run consolidation off the request path: merge duplicates, mark superseded facts, write a new version rather than editing in place. Rewriting the whole store in one pass is how context collapses.^42,57,69,82
• Keep always-loaded instructions short and separate from learned notes; keep the prompt prefix stable so caches hit.^70,71,72
• Hard-delete on user request and on expiry policy. Invalidation and soft forgetting do not satisfy erasure obligations.^27,47
• Evaluate on your own traffic: a LongMemEval-S subset plus hand-written knowledge-update and temporal cases, reported with tokens per query.^21,85