What Is Memory Supersession?
Memory supersession is how an AI agent's long-term memory handles facts that change: when a newer value replaces an older one (a user moves, a price changes, a plan is revised), the agent must answer from the current value and stop asserting the superseded one. Memory systems implement it by overwriting or deleting the old entry, or by marking it invalid from a point in time and keeping it as history. The hard part is noticing that a new statement supersedes an old one, because real updates are rarely phrased as updates.
Updated
What is memory supersession?
Vedant Patel names the ability in Supersede: Diagnosing and Training the Memory-Update Gap in LLM Agents (arXiv, June 2026), a preprint under review: "We call the correct handling of such updates supersession." His example is an assistant told that a user lives in Detroit, and later that they moved to the suburbs, which "must answer a subsequent location question with the current value."
Supersession is a different problem from recall. Recall asks whether the agent can find a fact; supersession asks whether it picks the right version when several were recorded. LongMemEval includes a knowledge-update question type for this. StateMemBench (Fan et al., 2026) scores each answer as reflecting the current state, the superseded state, or neither. For memory shared across a fleet of agents, Margalit et al. (2026) list temporal supersession as one of four primitives, with scoped retrieval, provenance tracking and policy-governed propagation.
How memory supersession works
Three common designs, from simplest to most auditable:
- 1.Delete the contradicted entry. Mem0 picks one of four update operations per new fact, including "DELETE for removal of memories contradicted by new information."
- 2.Invalidate it at a point in time, and keep it. Zep stores when each fact held true; when a new fact contradicts an old one, it sets the old fact's end of validity to the new fact's start.
- 3.Mark it superseded, and flag what depended on it. StateMem sets the replaced unit to superseded, so it "stays in the store for auditability but is inactive," and marks dependent units for recheck.
Once an update is recognized, storing it is simple. A minimal SQL version of invalidate-and-keep:
CREATE TABLE facts (
id bigint PRIMARY KEY,
subject text NOT NULL,
predicate text NOT NULL,
value text NOT NULL,
valid_from timestamptz NOT NULL,
valid_to timestamptz, -- NULL while current
superseded_by bigint REFERENCES facts (id) DEFERRABLE INITIALLY DEFERRED
);
-- at most one current value per single-valued fact
CREATE UNIQUE INDEX one_current_value
ON facts (subject, predicate) WHERE valid_to IS NULL;
BEGIN;
UPDATE facts SET valid_to = now(), superseded_by = 102
WHERE subject = 'user:rachel' AND predicate = 'lives_in' AND valid_to IS NULL;
INSERT INTO facts (id, subject, predicate, value, valid_from)
VALUES (102, 'user:rachel', 'lives_in', 'the suburbs', now());
COMMIT;Reads filter on valid_to IS NULL, and the old value stays queryable. The hard part is upstream: recognizing that a new statement replaces an old one. Patel found explicit, templated updates too easy to be informative, since with the full history in context frontier models scored 100% on them by scanning for the last mention. Real conversational updates are implicit and paraphrased.
Why memory supersession matters in real-time systems
The measured failure is large. On LongMemEval's knowledge-update questions, Patel found that replacing an agent's full context with a bounded, self-maintained memory dropped accuracy from 92% to 77% on gpt-5.4. With gpt-4.1-mini, a conversation 24 times longer at the same memory budget cut accuracy from 68% to 28%, on a sample of 25 questions. His reading: "The bottleneck is therefore memory maintenance, not comprehension." Fine-tuning a 3-billion-parameter open model on the Supersede environment raised held-out accuracy from 9.0% to 16.7%, in a single training run.
Ordering inside the memory service matters too. In a production multi-agent memory service, Margalit et al. found that a synchronous near-duplicate gate can reject contradictory writes before the asynchronous contradiction detector ever evaluates them, because "X is A" followed by "X is B" looks like near-identical text. One fix they propose is to run the structural contradiction check first.
For an agent that acts, a superseded fact is a stale read with consequences: shipping to the old address, quoting the old price, applying a limit that has since changed. When a store keeps contradictory memories, the same paper notes, "Downstream agents that read both have no principled way to choose between them." Memory should settle which value is current before the model reads it. How stale memory differs from context that lags its source is covered in context rot vs. context lag.
FAQ
Related terms
Context lag is the delay between a fact changing at its source and the system an automated decision reads from reflecting it. Also called stale context.
Lost in the middle is the tendency of language models to use information at the start or end of a long prompt better than information placed in the middle.
Event sourcing stores application state as an append-only log of immutable events; current state is derived by replaying them. Covers mechanics and trade-offs.
Cache invalidation is the process of removing or updating cached data when the underlying data changes. Covers TTL, write-through, and event-driven strategies.
Live context is decision context kept close to current: reads hit the latest committed data, and derived state refreshes incrementally, typically every few seconds.
Eventual consistency is a distributed-systems model guaranteeing all replicas converge to the same value once updates stop. How it works, and its trade-offs.
Semantic memory is long-term memory for facts and concepts. In AI agents it is the store of facts an agent keeps about the world, its users and itself.
Temporal RAG is retrieval-augmented generation that accounts for when facts were true, so a model gets evidence from the moment the question is about.