Agent Memory Is Three Systems, Not One. Five Papers Prove the Split

Three papers arrived on November 5 and 6, 2026, all about the same question: how should an agent remember? MEMOIR, a training-free memory lifecycle, landed November 5. Decision Context, a system for persistent behavioral learning, landed the same day. A paired evaluation of fact compaction against retrieval landed November 6. Two anchor studies frame them: AgentMemBench, a systematic comparison of five memory strategies submitted in June, and Memanto, a typed semantic memory system from April. Read together, the five papers do something none of them does alone. They split memory into three jobs with three different winners, and they show that the usual way of buying memory, one system, one store, one retrieval call, is solving the wrong problem three times over.

The three jobs are easy to confuse because they share a database. First, factual recall: given a question about something said many sessions ago, find the right turn. Second, behavioral memory: given a correction a human made last week, do not repeat the mistake. Third, cost: pay for the first two in as few tokens and milliseconds as possible, because memory that costs more than the task is a feature nobody ships. Every paper below scores well on one job and badly on another. That is the point.

Finding 1: at long horizons, only dense retrieval is still standing

AgentMemBench, by Ahmed Cherif, is the cleanest comparison in the set. Five memory strategies under identical conditions: in-context windowing, an external key-value store, graph-based episodic memory, compression-based summarization, and web-augmented memory. Three datasets, LoCoMo, MultiDoc2Dial, and MSC, 491 annotated question turns, one small model doing both generation and judging, Qwen2.5-7B-Instruct in 4-bit, greedy decoding for determinism.

The headline result is a sweep. The key-value store, which is dense retrieval over stored turns, dominates on every quality axis: macro Recall@5 of 0.792, MRR 0.677, Answer F1 0.156, Faithfulness 0.354. Those absolute numbers are low. Faithfulness of 0.354 means the judge found most answers unfaithful to the retrieved evidence, and an F1 of 0.156 means answers rarely matched the reference. The sweep matters more than the level: the same setup, the same model, and one strategy wins every column.

The decisive case is the long-range one. On LoCoMo, where the gold turn lies many sessions back, the window, the web memory, the graph, and the summary all retrieve almost nothing: Recall@5 of 0.005 or below. The key-value store alone reaches 0.573. Recency windows, summaries, and entity graphs collapse at long horizons. Only dense retrieval scales, because only it searches the whole store instead of a slice of it.

The cost is real and the paper states it plainly. The key-value store's recall advantage carries a footprint of about 5,100 tokens against about 300 for the window and web strategies, roughly a 17x difference. Compression-based summarization is the runner-up on retrieval at 0.556, and it is the obvious compromise candidate. The benchmark also ran two published systems, MemGPT/Letta and HippoRAG, against the same harness, so the comparison is not limited to the five toy strategies.

One caveat before building on this. Everything was measured with a single 7B model in 4-bit. A small quantized model may punish exactly the strategies that need strong reasoning, like graph traversal and summary-based recall. The ranking could shift with a frontier model. The long-range collapse is so total, 0.005 against 0.573, that the qualitative conclusion survives that worry. The exact gap does not.

Finding 2: consolidation is where evidence dies, and a judge at the merge saves it

MEMOIR, by Anand, Raj, Jha, and Saha, starts from a failure mode the other papers walk past. Memory systems compress old turns into summaries to save space, and compression silently destroys the evidence a future question needs. The paper's fix has two halves: a judge that screens every merge for evidence preservation before it happens, and retrospective attribution that updates retrieval priority after each query based on what actually helped.

The headline number is a gain of 11.92 percentage points in evidence recall at rank 5 over bare cosine retrieval, measured on 1,905 deduplicated LoCoMo question-answer pairs. The audit numbers are the ones that make the claim believable. The judge-gated merge moved text-evidence recall from 58.82% to 59.08%, shrank the active store by 1.42%, and produced zero observed losses across 100 independently audited merges, with a one-sided 95% upper bound on the loss rate of 2.95%. Confidence-gated feedback added 1.50 points. An oracle variant, which is not deployable, added 1.84 points overall and 8.05 on multi-hop, which bounds the headroom left in attribution alone.

The honest part of the paper is the comparison against LiCoMemory on the full LoCoMo set. MEMOIR scores 58.70% accuracy and 61.20% recall against LiCoMemory's 62.99% and 64.51%. It loses on both, and wins on cost: 84.6% fewer prompt tokens, 0.2k against 1.3k, and query latency down from 1.55 seconds to 1.18. On LongMemEval-S it wins outright, 81.20% accuracy and 85.10% recall, beating LiCoMemory by 12.00 and 12.71 points. The online write path needs no LLM call and takes 6.8 milliseconds median. Read as a whole, MEMOIR is not the most accurate memory system in the set. It is the one that proves compression does not have to destroy evidence, and it does so at a token budget a production system can afford.

Finding 3: compact the facts, keep the transcript for the wording

The paired evaluation by Edogun, Obigwe, and Mehmood asks the most practical question in the set, and answers it with the strongest design. Two ways for a conversational agent to remember past turns: keep the raw transcript and retrieve from it, or compact each turn into atomic facts and search those instead. Both arms answered all 1,985 LoCoMo questions in one window, against the same stores, with the same generator and judge, and both predictions on one row, which licenses McNemar's exact test on the 512 questions where they disagreed.

On the four categories comparable work reports, compaction scores 71.4% against 64.6% for retrieval, a lead of 6.8 points with p equal to 5.5e-08, at 34% fewer prompt tokens. That is a real, significant, cheaper win. Then the paper does the thing most papers skip: it includes the adversarial set that comparable work drops. On all five categories, the lead falls to 2.0 points and stops being significant, because the baseline leads the adversarial set by 14.6 points.

The loss has a structure, and the authors show it. Their lead falls as the reference answer demands more source wording: 9.6 points ahead when the answer is one or two reference words, 3.1 points behind past eight words, with token overlap moving the same way. The judge is not the cause. Compaction keeps what a fact asserts and discards how it was said, so it wins where the answer is a value and loses where the answer is a phrasing. The paper also reports four negative results with power calculations, which is rare and worth noting.

The design lesson is direct. If your agent answers questions whose answers are values, dates, names, or decisions, compact the facts and save a third of your prompt tokens. If it must reproduce wording or quotes, keep the transcript searchable. Most production agents do both, which means they need both stores and a router that knows which question is which.

Finding 4: behavior is not a fact, and rules beat retrieval

Decision Context, by Vahdat and Vaezipoor at Georgian AI Lab, is the paper that justifies the three-way split on its own. It argues that agents fail to learn from corrections because memory systems store what is true, not how to behave. The system, Forge Decision Context, captures behavioral signals from human corrections and self-assessed tool-call failures, compiles them into imperative rule directives, and injects them at the decision points where they apply.

The test is DC-Bench, 71 scenarios across nine behavioral dimensions, built from real executed agent traces in a deterministic mocked-tool environment, in financial analysis and customer support settings. Forge Decision Context reaches 95% compliance, up from 55% with naive retrieval, while injecting roughly 10 times fewer tokens per query. Compliance holds between 93% and 97% across six frontier models from Anthropic and OpenAI.

The comparison that matters is against the memory systems teams actually deploy. The external memory baselines, mem0 and Zep, sit at 12% and 15% compliance. Factual-memory systems in general score 12 to 15%, procedural-memory baselines 34 to 49%. A system that stores facts and retrieves them cannot learn a correction, because a correction is not a fact to retrieve. It is a rule about what to do next time, and it has to arrive as an instruction at the decision point, not as a paragraph in the context window. The paper was accepted at the NeurIPS 2026 workshop on personalized, aligned, long-term memory, which is a workshop acceptance, not a main-conference peer review, and worth stating as such.

The limits are substantial. The authors built DC-Bench, its grading rubrics, all five of their own systems, and the evaluation, and the scenarios cover two domains with mocked tools. Self-evaluation on a self-built benchmark is the weakest evidence in this set. Within those bounds, the 40-point gap over naive retrieval and the 80-point gap over mem0 are too large to be a grading artifact alone.

Finding 5: the graph may be optional

Memanto, by Abtahi and colleagues, is the oldest paper in the set, submitted in April 2026, and the most contrarian. It challenges the assumption that high-fidelity agent memory needs a knowledge graph. Instead it uses a typed semantic memory schema, thirteen predefined memory categories, an automated conflict resolution mechanism, and temporal versioning, all on top of a vector search engine with deterministic retrieval under 90 milliseconds and no ingestion delay.

The reported results are 89.8% accuracy on LongMemEval and 87.1% on LoCoMo, which the authors present as state of the art against the hybrid graph and vector systems they evaluated, achieved with a single retrieval query, no ingestion cost, and much lower operational complexity. A five-stage ablation quantifies each component's contribution.

Treat the headline with care. The numbers are the authors' own, on their chosen suites, and the search engine underneath is the authors' employer's product. The claim that matters is architectural: if typed storage plus one good retrieval query matches graph systems, teams can skip the entity extraction pipeline and spend that budget on the judge at the merge or the rule at the decision point instead. AgentMemBench's graph result, Recall@5 of 0.005 or below at long range, points the same way.

What this means for data and AI practitioners

1. Split memory into three stores with three owners. Factual recall, behavioral rules, and cost budgets are different jobs. One system doing all three will do the second one badly, because it stores facts where rules belong.
2. For long-horizon factual recall, start with dense retrieval over stored turns. It is the only strategy in AgentMemBench that survived the long range, and the margin was 0.573 against 0.005, not a rounding error. Budget about 5,100 tokens of footprint for it, or use summarization as the compromise at 0.556 and accept the loss.
3. Guard every merge with a judge. MEMOIR shows compression without a gate destroys evidence, and a gate costs almost nothing: zero observed losses in 100 audited merges, store down 1.42%. Audit your own merges the same way, on a sample, before trusting a summary store.
4. Compact facts for value answers, keep transcripts for wording answers. The paired evaluation is explicit about the boundary: compaction leads by 9.6 points when the answer is one or two words, and trails by 3.1 past eight words. Route by question type instead of picking one store.
5. Store corrections as rules, not as memories. A correction pasted into a retrieval store scored 12 to 15% compliance with mem0 and Zep. The same correction compiled into an imperative rule and injected at the decision point scored 95%. If your agent keeps repeating a corrected mistake, the store is not the problem. The representation is.
6. Question the graph before building it. Memanto's typed vector approach and AgentMemBench's graph collapse both suggest the entity extraction pipeline is optional for most teams. Spend that engineering time on retrieval quality and merge auditing first, and add a graph only when a measured failure needs one.

Against

The case against the split is that it is an artifact of small benchmarks. AgentMemBench used one 7B quantized model. MEMOIR and the compaction study both run on LoCoMo, which is long dialogue, not tool use. DC-Bench is two domains with mocked tools. Real agents interleave tool calls, multi-step plans, and human interruptions, and none of these papers measures memory under that load. It is possible that in production, with frontier models and long context windows, a single large context plus good retrieval is enough, and the three-way split dissolves.

There is also a simpler reading of the Decision Context result. The 95% may come less from the rule representation than from placement: the rule arrives exactly at the decision point, while naive retrieval dumps a paragraph into the prompt. A retrieval system that injected its best hit at the same point might close much of the gap without any rules. The paper does not run that control.

In favour

The case for the split is that the failures are structural, not statistical. A recency window cannot reach a turn from ten sessions ago, whatever the model. A summary cannot preserve wording it discarded. A fact store cannot express "do not do that again" as an instruction. These are properties of the representation, not of the benchmark, and they show up in five independent papers. The magnitudes help too: 0.573 against 0.005, 95% against 12%, 71.4% against 64.6% with p equal to 5.5e-08. Small effects can be benchmark artifacts. Effects this large usually are not.

What would make me wrong

• A frontier-model rerun of AgentMemBench where graph or summary strategies match dense retrieval at long range. That would show the collapse was a small-model artifact, not a structural one.
• A compaction study on tool-using agents where the value-versus-wording boundary disappears, because tool results are values by nature and transcripts carry little wording worth preserving.
• A retrieval baseline for DC-Bench that injects its best hit at the decision point and scores above 80%. That would show placement, not rules, was the active ingredient.
• A production deployment where one memory system serves all three jobs with measured compliance above 90% and recall above 0.7 at long range. A single counterexample with real traffic would beat five benchmarks.
• A LoCoMo replication failure. If an independent rerun of any of these LoCoMo numbers moves by more than 5 points, the shared-benchmark worry becomes the story.

Sources

• AgentMemBench: A Systematic Benchmark for Evaluating Long-Term Memory Management Strategies in Conversational AI Agents, arXiv:2608.00009
• MEMOIR: A Training-Free Memory Lifecycle for Long-Horizon LLM Agents, arXiv:2611.07631
• Compaction, decay and reinforcement in a two-tier conversational memory: a paired evaluation against retrieval-augmented generation, arXiv:2611.09807
• Decision Context: Persistent Behavioral Learning for AI Agents, arXiv:2611.08644
• Memanto: Typed Semantic Memory with Information-Theoretic Retrieval for Long-Horizon Agents, arXiv:2604.22085

Which of the three jobs is your agent worst at, and what would you measure first to find out?

Related on Everyday Data Science: The Best Models Track State Well. At 10,000 Tokens, They Fall to Chance · A True Tool Result Can Still Be Wrong: ReplayBench Found a 64.9% Error Rate · Switching Agent Harnesses Changed 13% of Tasks. Rerunning the Same One Changed 13% Too