For a long-horizon LLM agent, the memory question is not what was once recorded but what currently holds. Most designs answer it only indirectly: every interaction is stored, and the present is reconstructed at query time by retrieving and reconciling records, so stale values re-enter and the same conflicts are re-litigated. Committing the current value at write time avoids this, but existing write-time (CRUD) memories overwrite, so a wrong update is unrecoverable and prior state is lost. We take the missing combination---commit on arrival while retaining what is displaced---and formalize it as Memory of Memory (MoM): memory tracks not only content but the provenance, status, and history of its own entries. We instantiate MoM as Provenant Memory (P-Mem), a typed provenance graph whose active frontier exposes one current value per resolved key while displaced values are retained as provenance; typed operations decide whether a new observation supports, supersedes, contests, rejects, revokes, or resolves an existing value. P-Mem's decisive gain is validity rather than accuracy: its turn-level read matches the strongest retrieval memory in accuracy at ∼4× fewer read tokens---a retrieval-granularity effect---while graph-guided turn pruning cuts the knowledge-update stale-answer rate (19.4%→10.9%); on revision chains it stays at 100% where query-time reading collapses to 25%, and, because displaced values are retained rather than overwritten, it recovers committed errors a CRUD memory cannot (100% vs.\ 0%).
Figures & tables
Figure 1: One knowledge update across three memory designs. (a) The archive returns the stale value; (b) CRUD memory cannot undo a mistaken update; (c) MoM reads the current value and restores it on retraction.
staleness re-entry; conflicts re-litigated, sometimes inconsistently
CRUD memory (Mem0-style banks)
on arrival
erased (overwritten / deleted)
mis-updates irreversible; history unanswerable
Bitemporal KG (Zep / Graphiti)
on arrival
retained (valid-time intervals)
timestamp-arbitrated; no open conflict, no reversal
MoM (ours)
on arrival
retained as provenance
residual: wrong until revisited (§ 4.2 )
Table 1: Memory designs along two axes: when the current value is settled (on arrival vs. query time) and whether the displaced value is retained or erased. MoM commits on arrival yet retains what it displaces as typed provenance; bitemporal KGs share that corner but arbitrate by timestamp, leaving conflict implicit and commits irreversible.
Figure 2: P-Mem overview. A typed temporal provenance graph turns passive interaction records into an evidence-grounded active frontier of currently valid values, while preserving displaced values as provenance.
Annotation
Head after
Other version(s)
accept
new value (active)
superseded
reject
new value (active)
contradicted
contest
incumbent (contested)
incoming kept as alternative
revoke
predecessor, else empty
revoked (tombstoned)
resolve
promoted alternative (active)
others contradicted
noop
unchanged
unchanged
Table 2: How each typed annotation (§ 3.2 ) lowers onto version-status changes. Head after is the cell’s current value once applied; every other version is retained, retyped as listed.
Accuracy ↑
Stale rate ↓
oracle
_s
oracle
_s
MemoryOS
66.7
60.3
22.6
19.4
P-Mem, turn read
75.6
69.2
19.6
23.6
P-Mem, turn read + prune
76.9
65.4
5.4
10.9
Table 3: Knowledge-update subset: accuracy and stale-answer rate vs. MemoryOS retrieval on both haystack regimes
Overall
superseded
aggregation
single
(500)
(75)
(92)
(333)
No memory
4.0
2.7
0.0
5.4
Long-context
27.0
40.0
5.4
30.0
Mem0
39.4
37.3
35.9
40.8
MemoryOS
45.8
53.3
19.6
51.4
HippoRAG-v2
50.8
58.7
33.7
53.8
Table 4: All 500 LongMemEval-s questions, accuracy by susceptibility class.
Context tokens ↓
Accuracy ↑
Acc. per 1k tok ↑
Long-context
∼ 106k
27.0
0.25
MemoryOS
∼ 11k
45.8
4.2
P-Mem (turn read)
∼ 3k
52.6
17.5
Table 5: Token efficiency on LongMemEval-s (mean context tokens per query). P-Mem reads ∼ 4 × fewer tokens than MemoryOS retrieval and yields ∼ 4 × more accuracy per token.
Accuracy (%)
Context (chars)
L
Commit
Raw (top-10)
Raw + recon.
Raw +[t] tags
Raw (oracle order)
commit / raw
1
100.0
100.0
100.0
100.0
100.0
30 / 591
2
100.0
72.9
94.3
97.9
100.0
30 / 621
4
100.0
42.9
59.3
80.0
98.6
30 / 640
8
100.0
25.0
40.0
64.3
94.3
30 / 641
Table 6: Current-value accuracy as revisions accumulate ( n=140 per L , 5 interleaved objects, top-10). Commit stays flat; the raw read must reassemble order and collapses; reconstruction and [t=i] tags recover part; the arrival-order oracle recovers 94–100%.
Single-hop acc. ↑
Multi-hop acc. ↑
Stale rate (sh) ↓
6k
64k
262k
6k
64k
262k
6k
64k
262k
Long-context (full stream)
32%
31%
0%
2%
6%
0%
79.7%
–
–
MemoryOS retrieval (chunks)
41%
28%
16%
8%
2%
0%
39.1%
15.9%
16.9%
Mem0 (CRUD memory)
36%
45%
30%
5%
4%
2%
43.8%
46.4%
59.2%
HippoRAG-v2 (graph RAG)
69%
47%
39%
11%
3%
6%
35.9%
24.6%
22.5%
Graphiti/Zep (bitemporal KG)
15%
32%
12%
1%
1%
4%
18.8%
10.1%
15.5%
Table 7: MemoryAgentBench FactConsolidation at three history lengths ( n=100 per cell; stale rate on identifiable chains, n=64 – 71 ). Dashes: long-context stale omitted where accuracy collapsed.
Appendix figures & tables4 assets
Supplementary material from the paper’s appendix.
Appendix
Recovered ↑
Wrong
Lost
v1 in store
d=0
d=32
( d=32 )
Commit + retention
100%
100%
0%
0%
100%
Commit, no retention
0%
0%
0%
100%
0%
Raw top-10 (archival)
97.9%
92.0%
6.6%
1.5%
100%
Graphiti/Zep
0%
0%
93.8%
6.2%
100%
Appendix
Table 8: Reversibility under retraction ( n=140 , outcomes over committed cases only): recovered =v1 , wrong =v2 , lost = neither. The two commit arms differ only in retention. Graphiti/Zep commits only 16 errors at d=32 , a small base for its row there.
Gate
Overall ↑
Agg.
Single
Superseded
Stale ↓
Pruned
Ungated raw read
52.6
29.3
56.8
62.7
27.4
0
Prune always
45.6
15.2
51.4
57.3
12.9
100
Class-oracle gate
51.8
29.3
56.8
57.3
12.9
15.0
Intent gate (4B)
51.2
29.3
55.6
58.7
25.8
17.2
Question-only router (4B)
47.8
22.8
52.0
60.0
16.1
68.8
Question-only router (35B)
51.8
29.3
55.3
64.0
17.7
22.2
Appendix
Table 9: Gating the provenance prune on all 500 LongMemEval-s questions (%). Per-class accuracy over the judge-assigned classes; the stale rate is over the 62 stale-scoreable superseded questions of this run, a different subset from the 78-question knowledge-update set of Table 3 . Pruned = fraction of questions the gate routes to the pruned read.
Accuracy ↑
Stale ↓
Facts/cell
Turn read, raw
69.2
24.1
—
Turn read + provenance prune
65.4
9.3
—
Materialized state, 4B writer
52.6
33.3
1.17
35B extractor
61.5
20.4
1.12
35B extractor, merge 0.70
57.7
13.0
1.76
Appendix
Table 10: Write-time materialization on the _s knowledge-update subset ( n=78 ; stale rate over the 54 stale-scoreable updates of this judging pass). All arms share the 4B reader; write-time arms read the full materialized state. Facts/cell measures whether supersession chains form (1.0 = every fact its own cell).
4B writer
35B extractor
Extraction LLM calls
47.5
47.5
Calls per committed fact
0.15
0.18
Write tokens (prompt + completion)
157k
146k
Ingestion wall time
13.1 s
10.8 s
Committed facts
325
258
Materialized cells
278
231
Appendix
Table 11: Write-side cost per history on the _s knowledge-update subset (78 histories, 47.5 sessions each), measured from per-request logs.
LLM agents rely on long-term memory to retain and reuse information when performing tasks over long horizons. Existing methods provide limited support for handling memories that become outdated as new observations or domain evidence arrive. Such outdated memories may remain semantically relevant, continue to affect dependent records, and retain value as historical evidence. This calls for two capabilities: dependency tracking to identify downstream effects and historical preservation to retain useful past records. We propose Provenance-Aware Cascading Memory Invalidation (PACMI), a framework that represents memories and new evidence in a provenance graph with typed dependency edges. PACMI assigns records to a four-state validity lattice, propagates validity changes to dependent memories, and uses the resulting states for retrieval and stale-premise detection. We also introduce a diagnostic benchmark with 100 cases and 300 queries across five domains. The evaluation separates node, context-, and answer-level performance. PACMI achieves the highest final-answer accuracy on this benchmark, and its paired difference from the strongest baseline is significant under an exact McNemar test. The premise checker achieves perfect precision, recall, and F 1 on the controlled query distribution. Cascading propagation primarily improves memorystate correctness: removing it increases final-answer errors from 3 to 11, but the paired difference does not reach the 0.05 significance threshold. Code and data will be made publicly available.
Yiqi Wang, Jiaqi Liu, Jiaqi Zhang +4
University of Southern Queensland · Southern University of Science and Technology · Jiangsu University +2
A memory can be outdated for present-day reasoning yet indispensable for reconstructing the past. Relevance-based retrieval overlooks this tension: semantic relevance, evidence-grounded validity, and query-specific eligibility are distinct. We propose CALM, a conflict-aware lifecycle memory governance framework that decouples persistent memory preservation from query-time admission. CALM converts heterogeneous records into evidence-grounded memory cells, updates validity and lifecycle states using support, conflict, and dependency signals, and admits query-appropriate evidence through training-free or learned gating informed by temporal applicability. Across LongMemEval-S and LoCoMo with Qwen and GPT backbones, CALM outperforms state-of-the-art baselines, achieving the best overall accuracy. Compared with simple filtering and reranking, query-conditioned admission further improves evidence selection. Conflict-blocking and robustness analyses show CALM suppresses erroneous retrieved memories while retaining useful evidence. Historical-reconstruction experiments demonstrate that preserving superseded records supports accurate earlier-state reasoning without compromising current-state answers.
Persistent memory allows an LLM agent to carry experience across conversations, but it also turns a local reasoning mistake into a durable one. During deliberation, an agent may consider a plan, simulate a tool result, report another speaker's belief, and then reject all of them. If memory retains only the resulting sentences, those once-useful possibilities can later return as facts. The record is neither fabricated nor irrelevant; it has simply been detached from the context in which it was valid. We identify this missing context as discourse ownership: the world, branch, or speaker that licenses a proposition. Our first finding is counterintuitive. Language models already carry a causally active signal for ownership, yet conventional memory interfaces discard it when they convert reasoning into records. We introduce CASK (Causally Anchored Scoping Keys), a commit rule that preserves this signal so that shared-world facts enter durable memory while provisional content remains available only within its original scope. Our second finding is that the most obvious way to preserve the signal---storing the discovered internal coordinates---is unreliable because equivalent representations need not keep the same coordinates. CASK instead preserves the stable relations that express ownership. Controlled long-conversation conflicts and tool-agent traces show that this design improves memory admission and prevents provisional content from contaminating later answers while complementing runtime provenance. The resulting commit boundary lets agents explore more possibilities without granting every intermediate sentence authority over future behavior.
Hongyu Gu, Xinchang Li
University of Science and Technology of China Hefei, China