A memory system can preserve every relevant timestamp and still lose the information needed to judge a claim.
The gap stays invisible while one process owns every write. "The system learned this" and "someone asserted this" look like the same sentence. They stop being the same sentence the moment several agents, accounts, or documents write into one shared store. At that point a contradiction is not a temporal event. It is a conflict between assertions, and no clock can adjudicate it.
What follows is the part I find uncomfortable: four mature bodies of work already named the missing piece, the oldest of them in 1979, and none of the agent-memory systems I have read adopts any of them explicitly.
Bi-temporal memory answers when, not who
The good version of temporal memory splits time in two. Valid time asks when a claim held in the world. Transaction time asks when the store came to hold it. Both are needed to reconstruct change, and most systems do not even ship the second one.
Now take a record: Alice lives in Berlin. A bi-temporal store can say when Alice lived in Berlin and when the system learned it. But the learning event had a source. An agent extracted the claim, or a user stated it, or a document supplied it. The timestamp keeps that event's place in time and drops the identity behind it.
With one writer, the omission is easy to miss, because the sole writer is implicitly responsible for everything. Shared memory removes the shortcut.
Suppose one writer stores Alice lives in Berlin, and another 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.
Recency answers "which assertion arrived last?" Conflict resolution needs a different question: whose assertion should the system accept, and why?
Which gives the compact form of the problem. Bi-temporality is a degenerate provenance model. It preserves the when of an assertion event and discards the who. "Degenerate" is doing real work in that sentence: 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.
What a shipped implementation actually keeps
This is not a thought experiment. Zep and Graphiti resolve temporally overlapping contradictions by closing the older edge's validity window (arXiv:2501.13956).
Credit where it is due: that graph does keep extraction provenance. Edges and their source episodes hold bidirectional indices, which is more than most.
But the invalidated edge records only a temporal boundary. Nothing in it says whose assertion won the conflict, or on what grounds. It is an operational answer without an epistemic explanation, and it is one of the better ones in the field.
Four fields that already named the missing piece
None of these has to be adopted wholesale. The point is narrower and, to me, more damning: each one already makes first-class the thing agent memory keeps discarding.
W3C PROV-O, Recommendation dated 30 April 2013. It defines three core classes: prov:Entity, prov:Activity, and prov:Agent, where an agent is something that bears responsibility for an activity or entity. Responsibility is a primitive modelling concept, not an annotation added afterwards. The lesson for agent memory is modest and specific: represent responsibility instead of inferring it from write order.
Nanopublications. A nanopublication is a publishable knowledge unit composed of three named graphs: assertion, provenance, and publication information. Provenance is structural rather than optional, because the smallest publishable unit contains all three, so the assertion cannot travel alone. Agent memory inverts this. The fact is the unit, and source context is metadata, if it is kept at all.
AGM belief revision (Alchourrón, Gärdenfors and Makinson, Journal of Symbolic Logic, 1985). Three operations on a belief set: expansion, contraction, revision, under rationality postulates. Contraction forces a choice about which belief to surrender, and the postulates constrain that choice. Any memory system that invalidates a claim on contradiction is already doing belief revision. Without an explicit policy, "newer wins" is not a decision. It is an accidental rule with no record of what was surrendered or why.
Truth maintenance systems. Doyle introduced justification-based TMS in 1979. De Kleer's assumption-based variant followed in 1986, tracing contradictions back through the justification network instead of recomputing from scratch. A belief survives only while at least one justification stays valid. That justification slot records why a statement is believed and what supports it, which 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 with the justifications removed.
Taken together the four make the design choice plain. A memory record should not contain only a proposition and its clocks. It should retain the assertion event that put the proposition there.
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, and the derivation method.
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. That single rule converts a silent overwrite into an auditable decision, and it lets a later review reverse the call without excavating context that no longer exists.
Identity and authority are two different systems
This is the distinction that took me longest to hold steady, and it is the one that makes the rest tractable.
Identity is stored evidence about who wrote. Authority is the decision about whose claim should prevail.
They fail differently. A system without identity cannot attribute an assertion at all, so no policy can run, however good the policy is. A system with identity but no authority rules can attribute both sides of a contradiction and still cannot explain which one it accepted.
The useful consequence is that they can be built in that order. Recording who wrote does not require agreement on a universal authority ranking, and it is the prerequisite for any ranking arriving later. What the memory layer owes a future policy is not the policy. It is enough preserved information for one to operate.
The part I do not have
I am not going to pretend the second half is solved. Deciding whose assertion outranks whose, across agents that were never designed together, under accounts with different trust levels, is an open problem and I have not seen a convincing shipped answer to it.
What is not open is the first half. The prior art runs from thirteen to forty-seven years old, it is well documented, and it says the same thing four different ways: keep the asserter.
Losing it is a choice, not a constraint.
Disclosure: I work on Mnemoverse, a memory engine for AI agents connected over MCP, so weigh the argument accordingly. Every source above is linked and dated, and the longer version with the full citations is on the original page.
Top comments (0)