MnemoverseDocs

Appearance

Edward Izgorodin·Published Jul 23, 2026

Provenance in agent memory: the missing who ​

A memory system can preserve every relevant timestamp and still lose the information needed to judge a claim.

TL;DR

  • Provenance in agent memory is the source context attached to an assertion: who made it, under which identity, from what evidence, and by which derivation method.
  • Bi-temporal memory records when a fact was valid and when the store learned it. Neither timestamp identifies the asserter.
  • Four mature bodies of prior art — PROV-O, nanopublications, AGM belief revision, truth maintenance — already make the missing pieces first-class: responsibility, attached provenance, revision policy, justifications. None of the systems reviewed in the companion piece explicitly adopts any of them.
  • Record source identity, evidence, and derivation at write time, and preserve them after invalidation — that converts silent overwrite into an auditable decision.

The gap stays hidden while one process owns every write. "The system learned this" and "someone asserted this" appear to mean the same thing. They stop meaning the same thing as soon as several agents, accounts, or documents write into one shared memory. At that point a contradiction is not a temporal event. It is a conflict between assertions.

Bi-temporal memory answers when, not who ​

The companion article on bi-temporal memory for AI agents splits time in two. Valid time asks when a claim held in the world. Transaction time asks when the store came to hold it. Among the systems reviewed there, exactly one ships that model, and none of seven temporal benchmarks tests the second axis. Both axes are needed to reconstruct change. Neither says who caused the store to accept the claim.

Consider a memory entry: Alice lives in Berlin. A bi-temporal record can state when Alice lived in Berlin and when the system learned it. But the learning event had a source — an agent extracted the claim, a user stated it, a document supplied it. The timestamp keeps the event's place in time and drops the identity behind it.

With one writer, that omission is easy to miss: the sole writer is implicitly responsible for every assertion. Shared memory removes the shortcut.

Multi-agent memory conflicts are assertion conflicts ​

Suppose one writer stores Alice lives in Berlin, and a different writer later stores Alice lives in London. The later timestamp establishes sequence. It does not establish truth.

The second writer may have newer evidence. It may also have copied an outdated document, misread a message, or written under the wrong account context. The first writer may be an authoritative system of record. Either claim could outrank the other — for reasons no timestamp can represent. Recency answers "which assertion arrived last?" Conflict resolution needs a different question: whose assertion should the system accept, and why?

This exposes the deeper limitation. Bi-temporality is a degenerate provenance model: it preserves the when of an assertion event and discards the who. "Degenerate" has a precise role here — a transaction timestamp keeps exactly one coordinate of the assertion event and drops the responsible party, the supporting evidence, and the derivation chain needed to evaluate it.

One shipped invalidation pattern makes the gap concrete. Zep/Graphiti resolves temporally overlapping contradictions by closing the older edge's validity window (arXiv:2501.13956; the mechanism is quoted in full in the companion piece). To its credit, the graph keeps extraction provenance — edges and their source episodes hold bidirectional indices. But the invalidated edge records only a temporal boundary: nothing says whose assertion won the conflict, or why. An operational answer without an epistemic explanation.

The prior art the reviewed systems forgot ​

None of the reviewed systems needs to adopt an existing knowledge-representation framework wholesale. They need to stop throwing away the asserter — and four established bodies of work already name the missing concepts.

W3C PROV-O: responsibility belongs in the model ​

PROV-O is the W3C provenance ontology for representing entities, activities, and the agents responsible for them. The Recommendation, dated 30 April 2013, defines three core classes: prov:Entity, prov:Activity, and prov:Agent — an agent is something that bears responsibility for an activity or entity. Responsibility is a primitive modelling concept, not an after-the-fact annotation. For agent memory the lesson is modest: represent responsibility instead of inferring it from write order.

Nanopublications: assertions travel with their provenance ​

A nanopublication is a publishable knowledge unit composed of an assertion graph, a provenance graph, and a publication-information graph. The model makes provenance structural: the smallest publishable unit contains all three named graphs, so the assertion cannot travel alone. The systems reviewed in the companion piece invert this — the fact is the unit, and source context is optional metadata, if it is kept at all.

AGM belief revision: contradiction needs a policy ​

AGM belief revision is a framework for changing a belief set through three operations — expansion, contraction, and revision — under rationality postulates (Alchourrón, Gärdenfors & Makinson, Journal of Symbolic Logic, 1985). Contraction forces a choice: which belief to surrender. The postulates constrain that choice. A memory system that invalidates a claim on contradiction is already doing belief revision. Without an explicit policy, "newer wins" becomes an accidental rule rather than a justified one — and no record exists of what was surrendered, or on what grounds.

Truth maintenance: beliefs need surviving justifications ​

A truth maintenance system keeps justifications for beliefs, and a belief survives only while at least one justification stays valid. Doyle introduced justification-based TMS in 1979. De Kleer's assumption-based variant (ATMS, 1986) traces contradictions back through the justification network instead of recomputing from scratch. The justification slot records why a statement is believed and what supports it. That is exactly where an agent-memory source belongs: the writer, the evidence, the dependency chain. "Invalidate on observed contradiction" without that slot is truth maintenance without justifications.

Taken together, the four make the missing design choice plain: a memory record should not contain only a proposition and its clocks. It should retain the assertion event that placed the proposition into memory.

What to record at write time ​

A shared-memory write should attach a typed source link to each assertion. At minimum: the writing agent's identity; the account or principal context; a document pointer or other evidence reference; the derivation method. A compact record could look like this:

yaml
assertion: "Alice lives in London"
source:
  agent: "research-agent"
  principal: "account-context"
  evidence: "document-reference"
  derivation: "extracted-from-source"
decision:
  status: "active"
  reason: "accepted under source policy"

The field names are implementation choices. The persistence rule is not: source context must survive conflict resolution. When a later assertion wins, keep the losing one — its author, its evidence, and the reason it lost. Silent overwrite becomes an auditable decision, and a later review can reverse it without digging for lost context.

This does not require every agent to agree on one universal authority order. It requires the memory layer to preserve enough information for a policy to operate. Identity is stored evidence about who wrote. Authority is the decision about whose claim should prevail. A system without identity cannot attribute an assertion; a system without authority rules can attribute both sides but cannot explain which one it accepted.

Mnemoverse Rooms: identity ships; authority remains open ​

Mnemoverse Rooms, currently beta, are shared memory spaces: several agents, under different accounts, writing to one membership-checked pool. That is the setting where provenance stops being optional. Rooms already ship the identity half — returned items include a domain field and, for authored atoms, provenance, and reads accept author filters (author_principal, author_agent, author_client_env, author_is_external). The authority half remains open: when writers conflict, whose assertion should outrank whose? Mnemoverse does not ship trust ranking or automated authority resolution; the open question stands.

The same distinction runs through our graph memory and MCP tools comparison, which scores whether systems return provenance inline. Returning the source with the memory item is the prerequisite; deciding how much that source should be trusted is a separate operation.

Where this piece sits ​

This article grew out of the bi-temporal memory thread: separate the two time axes, and the missing third axis becomes visible. But the question is wider than agent memory. Which assertion should prevail when sources disagree has been studied for decades under other names — truth discovery and data fusion in databases, trust and reputation systems, formal argumentation. None of that work is surveyed here. Treat this piece as the first statement of the problem as it appears in agent memory — not the last word on it. Surveying the adjacent art, and what it changes about the answer, is work we are starting now; a follow-up piece will carry it.

Common questions ​

What is provenance in agent memory? ​

Provenance in agent memory is the source context attached to an assertion: who made it, under which account or agent identity, from what evidence, and by which derivation method. Storing it alongside the claim makes conflict resolution auditable rather than a silent overwrite.

Why can't timestamps resolve multi-agent memory conflicts? ​

Timestamps show when assertions entered the store, not which writer had greater authority, stronger evidence, or a more reliable derivation. A conflict between two writers is a clash of assertions, not of timelines — recency cannot decide whose claim should prevail.

What is AGM belief revision for AI agents? ​

AGM belief revision (Alchourrón, Gärdenfors & Makinson, 1985) is a framework for changing a logically closed belief set through expansion, contraction, and revision under rationality postulates. A memory system that invalidates claims on contradiction is already doing belief revision — usually with "newer wins" as an accidental, unexamined policy.

What is a truth maintenance system? ​

A truth maintenance system keeps justifications for beliefs and withdraws a belief when none of its justifications remains valid. Doyle introduced justification-based TMS in 1979; de Kleer's assumption-based variant (ATMS, 1986) traces contradictions back through the justification network instead of recomputing from scratch.

How should shared agent memory record who wrote what? ​

Each assertion should carry a typed source link — agent identity, account or principal context, an evidence or document reference, and the derivation method — and that link must survive conflict resolution, so a defeated assertion still shows who asserted it and why it lost.

Edward Izgorodin · Mnemoverse · 2026-07-23

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