MnemoverseDocs

Appearance

Edward Izgorodin·Published Jul 23, 2026

Bitemporal memory records when — and drops who ​

Most agent memory systems can answer a question like "What was Alice's address last March?" But they cannot answer a different one: "What did you believe Alice's address was on March 1st, and when did you learn it?" The first asks about the world. The second asks about the system's own record-keeping. In database engineering the distinction has been settled for decades. In agent memory it is almost entirely absent.

TL;DR

  • Bi-temporality — tracking when a fact was true and when the system learned it — is a roughly 40-year-old idea, standardized in SQL:2011. Among the agent-memory systems reviewed here, exactly one ships it.
  • Every temporal benchmark reviewed here tests valid-time reasoning only. The transaction-time question — what an agent previously believed, and when it learned it — is untested across all seven.
  • Date arithmetic on the measured models is too fragile to compensate: 13.5–16% accuracy, with the most common error a miss of exactly one day. Date math must be executed, not generated.
  • Bi-temporality records the when of an assertion and discards the who. Once several writers share one memory, that missing axis becomes a correctness problem, not a modelling nicety.

Valid time vs transaction time ​

Valid time is the period during which a fact was true in the represented world. Transaction time is the period during which the system stored that fact as current. They are independent axes. Suppose an agent learns on Friday that a contract ended on Monday: the valid-time boundary is Monday, the transaction-time boundary is Friday. Collapse them into one field and the memory can no longer distinguish a late update from an event that happened late. A bi-temporal store preserves both timelines.

The idea is not new. Snodgrass and Ahn sketched the taxonomy in the mid-1980s; the TSQL2 language effort ran through 1995; in 2011 it entered the SQL standard as system-versioned tables for transaction time and application-time period tables for valid time (Kulkarni & Michels, SIGMOD Record 41(3), 2012). The query pattern is shipping infrastructure, not theory — XTDB serves SQL:2011-conformant clauses (XTDB docs):

sql
FOR VALID_TIME AS OF :world_time
FOR SYSTEM_TIME AS OF :recorded_time

Datomic provides transaction time natively; valid time can be modelled in user attributes. The capability that matters is not attaching a timestamp — it is reconstructing the store as it stood along either axis.

Which AI memory systems ship bi-temporal storage? ​

Among the agent-memory systems reviewed for this piece (July 2026), the landscape is uneven. A broader vendor comparison lives in AI memory solutions, Q3 2026; the table below covers only temporal semantics.

SystemValid-time axisTransaction-time axisWho asserted it
Zep / Graphitit_valid, t_invalidt'_created, t'_expirednot modelled
Mem0ᵍ— (LLM invalidation, no separate axes)—not modelled
Cogneedate-range filtering over tagged timestamps (temporal_cognify)—not modelled
Supermemoryhand-built string tags (user_{id}_2024_q1)—not modelled
Typical mainstream store—single created_at-style timestampnot modelled

Zep/Graphiti is the exception that measures the gap: the only agent-memory system in this set with a paper-documented bi-temporal model. Each graph edge carries a valid-time interval and a transaction-time interval, and the invalidation procedure is explicit: "When the system identifies temporally overlapping contradictions, it invalidates the affected edges by setting their t_invalid to the t_valid of the invalidating edge" (arXiv:2501.13956) — invalidation rather than deletion, so you can ask what the graph believed before a correction and when the correction arrived.

Mem0's graph variant also detects conflicts, but its paper describes LLM-driven invalidation rather than two independent axes (arXiv:2504.19413). Cognee's documented time-awareness is date-range filtering — asking "before 1980" or "between 2000 and 2006" over tagged event timestamps — not a second axis for the store's own history. And Supermemory's documented recommendation — segment time with tags like user_{id}_2024_q1 — is direct evidence that the need is felt and unmet: engineers are hand-rolling a time axis out of strings.

For every system that packs history into one created_at field, "created on Friday" cannot say whether the fact became true on Friday, was discovered on Friday, or merely migrated on Friday.

None of seven benchmarks tests the transaction-time question ​

Time-awareness has measured value on the valid-time side: LongMemEval reports a +6.8–11.3% gain in temporal recall from time-aware retrieval scoping (LongMemEval, ICLR 2025). Whatever benefit the other axis carries sits entirely outside the measured envelope — because none of the benchmarks reviewed here measures it.

A review completed on 2026-07-23 covered TimeQA, TempReason, TRAM, Test of Time, ChronoSense, LongMemEval, and LoCoMo. Every one tests valid-time understanding — when events occurred, what was true at time T. None isolates questions such as:

  • What did the agent believe about this entity last month?
  • When did the agent first acquire this claim?
  • Which correction was available at the moment a given decision was made?

These are not ordinary temporal questions; they query the history of the memory store itself. A system can ace event dating while remaining unable to reproduce the knowledge that was available to an earlier action — which is precisely what an audit of an agent's past decision needs. (LoCoMo, a benchmark several of the reviewed vendors quote, carries an additional flag: an independent audit found 99 score-corrupting answer-key errors in 1,540 questions and a judge that accepted 62.81% of deliberately wrong answers (Penfield Labs) — see how to read memory benchmarks.)

Prompting didn't compensate in the measured models ​

If a model could reconstruct temporal relationships reliably from context, the machinery above would be a luxury. The measured models could not. On duration and date arithmetic, Gemini 1.5 Pro, GPT-4, and Claude 3 Sonnet score 13.5–16%; when GPT-4 or Gemini 1.5 Pro erred, roughly 21% and 25% of their answers respectively landed within one day of the truth — the signature of a model approximating a calendar instead of executing one (Test of Time, arXiv:2406.09170). On Allen's interval relations, GPT-4o scores 0.69 zero-shot on Equals against 0.91–0.96 on Before/After, and the Equals score falls to ≈0.45 when real event names are replaced with abstract labels — the model leans on memorized world knowledge, not interval reasoning (ChronoSense, arXiv:2501.03040).

The annotation history carries the same warning from the human side: the MATRES scheme deliberately restricted temporal-relation labels to event start points because interval end-points were a major source of annotator confusion (Ning, Wu & Roth, ACL 2018). A pipeline claiming LLM-extracted full Allen ordering is claiming precision neither the measured models nor trained human annotators could deliver.

The design consequence is one sentence: date math must be executed, not generated. Store normalized intervals; evaluate temporal predicates in code or a database; let the model interpret the request, not improvise the calendar.

Bi-temporality is a degenerate provenance model ​

Provenance in agent memory is the record of who or what asserted a fact, together with the evidence behind the assertion. Here is the turn the temporal story usually skips.

Transaction time records when the store came to hold a claim. It treats the learning event as an assertion without a source — the when of an assertion whose who was discarded. In that precise sense, bi-temporality is a degenerate provenance model.

With one writer, the degeneracy is harmless: "the system learned this" and "someone asserted this" coincide. Shared memory breaks the equivalence. When several agents, users, or services write to one pool under different accounts, a contradiction — "Alice lives in Berlin" vs "Alice lives in London" — is no longer a matter of recency. It is a conflict between two assertions, and resolving it requires knowing whose assertion outranks whose. Timestamps cannot encode trust, authority, or evidence. Every accepted sentence reads as if it came from one anonymous narrator.

The reactive-invalidation pattern exposes the same gap from another side. "Invalidate on observed contradiction" is belief revision (AGM) and assumption-based truth maintenance (ATMS) reinvented at half strength — without justifications. And the justification is exactly where the source, the evidence, and the dependency chain would live. The relevant art has names: W3C PROV-O, nanopublications, AGM, ATMS. Agent memory does not need to reproduce those fields wholesale. It needs to stop discarding the asserter.

What builders should preserve ​

Three moves follow directly.

  1. Keep the two time axes separate, and execute temporal logic in code — the 13.5–16% figure argues against betting on prompting.
  2. Predict staleness at write time. Fact-duration prediction (EMNLP 2023, arXiv:2305.14824) and Temporal Validity Change Prediction (Findings ACL 2024, arXiv:2401.00779) are defined tasks; as of this review, none of the systems reviewed here integrates either. A store that writes an expected-expiry alongside a fact moves from reactive cleanup to maintained correctness.
  3. Record provenance at assertion time for any memory with more than one writer. A typed source link — agent identity, document pointer, account context — survives conflict resolution where a timestamp cannot.

A formal treatment of further time and source dimensions is separate work. The immediate requirement is simpler: preserve enough history to explain what the system knew, when it knew it, and who supplied the claim.

Disclosure: Mnemoverse does not ship bi-temporal storage today. Shared memory spaces (Rooms, beta) are the multi-writer setting that makes this concrete for us — reads there carry authorship (a provenance field plus author filters), which is the identity half of provenance; the authority half, whose assertion outranks whose when writers conflict, is the open problem this article argues for. Our comparison of graph-memory MCP tools scores whether systems return provenance inline.

Common questions ​

What is bitemporal memory for AI agents? ​

Bitemporal memory stores every fact along two independent time axes: valid time (when the fact was true in the world) and transaction time (when the system learned or recorded it). It lets an agent answer both "what was true last March" and "what did you believe last March, and when did you learn it."

What is the difference between valid time and transaction time? ​

Valid time is the period during which a fact held in the represented world. Transaction time is the period during which the system stored that fact as current. They are independent: a system can record a retroactive correction while still remembering what it previously believed.

Which AI memory systems support bi-temporal queries? ​

Among the systems reviewed in July 2026, Zep/Graphiti is the only one with a paper-documented bi-temporal model: t_valid and t_invalid on the valid-time axis, t'_created and t'_expired on the transaction-time axis. Mem0's graph variant invalidates relations via LLM conflict resolution without separate axes; Cognee documents date-range time filtering; most others keep a single created_at timestamp.

Does any benchmark test what an AI agent previously believed? ​

Not among the seven reviewed in July 2026. TimeQA, TempReason, TRAM, Test of Time, ChronoSense, LongMemEval, and LoCoMo all test valid-time reasoning — when events occurred. None isolates the transaction-time question: what the system believed on an earlier date, and when that belief entered the store.

What is provenance in agent memory? ​

Provenance is the record of who or what asserted a fact, with the evidence behind the assertion. Transaction time captures only the when of learning and drops the who — which is why bi-temporality alone cannot resolve conflicts between writers in a shared memory.

Edward Izgorodin · Mnemoverse · 2026-07-23

— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Docs: Getting Started