How corrections propagate through retained memory

Type: types/note.md

Question and scope

When retained information is corrected, invalidated or withdrawn, which dependent representations—and which future consumers—reflect the change?

The answer is route-specific. Graphiti wires temporal invalidation and graph withdrawal, but those operations do not establish repair of every summary or conversation copy. Hindsight wires explicit dependency cleanup and a route toward repairing standing documents, with asynchronous and manually owned gaps. Mem0's inspected Python engine connects ID-preserving replacement and retrieval-index maintenance, while separate raw messages, history and delivered context can survive. None of these findings establishes complete forgetting.

This comparison selects three systems for contrasting mechanisms, not as a representative sample. Mem0 adds direct replacement, secondary-index maintenance and independent extraction-context routes to the Graphiti/Hindsight contrast. The landscape supplies orientation, not a substitute for reading the selected analyses. Evidence here is their complete accepted sets at repository commit 99a6997705964e29dc38c3ef285045223b171485; source revisions and applicability cutoffs differ:

System and retained boundary	Frozen source revision	Cutoff; inspection boundary	Analysis run
Graphiti	964bb11d1e7020e3cc67fab244268b0736b6c219	2026-10-12; whole-system boundary, selective inspection	AAS-2026-10-12-graphiti-1d535ca565a4-01
Hindsight	610c135b6f2d0d8b972da94146ae635943f36271	2026-10-14; complete artifact, partial loop	AAS-2026-10-14-hindsight-34c2ca821edf-01
Mem0	0724291bd864cf807e88ee8981c8226644e8fb42	2026-10-14; complete artifact, partial loop	AAS-2026-10-14-mem0-5b642a1731b4-01

All three sets are code-grounded. Claimed means declared behavior; wired means inspected code connects the operation to its consumer; observed would require an execution trace. Measured would require an executed assessment with recorded outcomes; causal evidence would additionally isolate what produced an effect. The correction mechanisms below reach wired, not observed, measured or causal support. Attributed reports and evaluator source do not close those gaps. This article uses retained records only, without new external sourcing or target execution.

Architectural distinctions

An update replaces an identified record's content. A temporal invalidation can instead retain the assertion while ending its validity interval. A contradiction is a relationship between assertions, not proof that the newer one is correct. A replacement is the subsequent disposition of records; it need not follow automatically from detecting contradiction.

Source deletion withdraws an input. Dependent-record cleanup removes or marks representations associated with that input. Index rebuilding changes how remaining content can be selected. Derived knowledge repair revises prose or claims constructed from the input. These operations answer different questions. Re-embedding corrected text does not itself retract a summary that incorporated the old text.

A final boundary is the consumer. A later fresh query can see changed store contents while a running conversation still contains an earlier result. A provenance pointer can identify a dependency without triggering repair. Multiple source IDs can represent repeated or derivative assertions rather than independent corroboration. Consequently, neither deletion nor a support count establishes that a proposition is forgotten, false or independently supported.

Concrete implementations

Graphiti: temporal disposition, path-specific deletion, separate summaries

Graphiti publicly describes changed facts as invalidated rather than deleted, enabling temporal queries. The inspected ingestion route retrieves selected comparison candidates, obtains duplicate/contradiction judgments and applies index and time checks. It can write invalid_at and expired_at while retaining the old edge. A newer contradictory candidate can also expire an incoming older assertion. Candidate retrieval is not exhaustive, and normalized-text/endpoint reuse can bypass model contradiction checking. This is conditional temporal reconciliation, not a newer-input truth rule (comparison, temporal disposition).

Whether future readers exclude invalidated edges is another question. The retained memory account finds empty default search filters and date predicates conditional on supplied filters in the inspected fallback. Temporal fields therefore do not establish globally current-only search. MCP fact formatting retains dates and episode references; the shipped notebook sends bare fact strings instead. That notebook consumer loses the metadata needed to distinguish historical from current assertions unless the distinction survives in the text (withdrawal and filtering, delivery).

Deletion differs even between shipped services. MCP calls core episode removal, which selects an edge when the removed episode is its first episode reference. For references [A, B], removing A selects the edge despite B. That code-derived counterexample conflicts with the MCP description promising preservation of multiply supported facts. Nodes use mention counts. REST instead directly deletes the episode node without invoking that core cleanup; backend incident-edge effects are not fully inspected (removal route).

Surviving summaries form another dependency layer. Entity summaries can append fact strings literally or use model generation. Communities derive from entity summaries; explicit community rebuilding removes old communities before generating replacements. Sagas incrementally combine a previous summary with newly selected episodes. None of these capabilities establishes a deletion-triggered rebuild of surviving summaries. Rebuilding communities from unrepaired entity summaries would not, by itself, establish correction either. The inspected removal body does not regenerate entity, community or saga prose or retract notebook checkpoints (summary production, maintenance, withdrawal scope).

Hindsight: withdraw dependent observations, then repair standing pages

Hindsight distinguishes extracted raw facts, consolidated observations and persistent mental-model documents referenced by knowledge-tree pages. “Raw” means pre-consolidation, not necessarily verbatim source text. Its public descriptions of evidence-backed beliefs and settled knowledge are claims; source associations and persistence do not certify them (public claims).

The inspected PostgreSQL withdrawal path does more than delete the outgoing fact. It identifies observations referencing any outgoing source, removes those observations and their history, and resets consolidation markers on the other contributing sources. Future consolidation can reconstruct an observation from what remains. This conservatively removes the whole mixed-source derivative rather than assuming its remaining prose is still supported. Multiple supports therefore do not preserve the old observation automatically; surviving sources preserve a route to reconstruction (source withdrawal).

Explicit raw-memory curation also supports editing, archive-based invalidation and restoration. Invalidated facts move out of live recall into an archive retaining text, optional reason and restoration descriptors, but not embeddings or search vectors. Restoration recomputes retrieval representations. This is reversible withdrawal from live retrieval, not physical erasure, and restoring a source does not restore every former derived byte (curation, archive).

Standing-page repair has a further wired route. Refresh reads accumulated based_on grounding, checks source existence and can request removal of unsupported prose. Full refresh rebuilds grounding; delta refresh retains historical grounding and prunes retracted IDs only when the retraction pass is handled. Pending consolidation can defer retraction to avoid unsaying a replacement still being processed. Named refresh failures preserve the previous document and refresh progress marker rather than installing an incomplete candidate (page maintenance).

This route is not immediate universal repair. Post-commit refresh nudges cover automatic pages, catch scheduling failures and can defer behind pending work; manual pages require owner action. The full edit/retraction executor and scheduler were not exhaustively inspected. Stored pages can remain stale until maintenance succeeds. Page delivery can expose current/stale indications, but already delivered prose remains a separate copy. The filesystem mirror adds another boundary: successful synchronization can prune removed pages and overwrite drift, whereas failed fetch returns before pruning (curation scheduling, page delivery, mirror).

Mem0: explicit replacement repairs local retrieval, not every retained copy

At this frozen revision, ordinary inferred Python addition is additive, despite broader add/update/delete docstring wording. Existing facts guide extraction and bounded deduplication; the route does not automatically replace an old assertion merely because new text contradicts it. Explicit update is a separate operation (inferred addition).

Python update preserves the record ID, replaces text and its embedding, refreshes hash and lemmatized matching terms, writes history and attempts entity unlinking/relinking when text changes. That connects correction to several retrieval representations, not just readable text. Entity links contribute ranking boosts, not a proposition-level dependency graph. Cleanup is best effort, and vector, history and entity changes are not one cross-store transaction. The OpenClaw tool's atomic-update description is therefore stronger than the inspected local route; hosted atomicity is unknown (mutation annotation, entity index, atomicity claim).

Deleting the vector record writes old text to history and does not delete the separate recent-message tail. History has a requested inspection route, not an established automatic answer reader. Recent messages, however, are explicitly reloaded into later extraction. Their survival leaves old source text available to that consumer; it does not prove actual re-extraction. Expiry is narrower still: default public search hides expired payloads, while direct ID reads and extraction's private vector lookup are counterpaths (retained messages and history, extraction annotation).

Consumer bookkeeping introduces another possible gap. Coding-agent and Pi recall suppress IDs already shown in a session. Explicit replacement preserving an ID does not, merely by coexisting with that filter, establish refreshed delivery of its changed text. The retained records show no wired correction-notification route connecting those mechanisms. Hosted consumer behavior must not be inferred from local Python mutation semantics; nevertheless, the ID filter makes revision-aware delivery a concrete unanswered question (coding recall, Pi recall).

Comparison and consequences

The comparison yields three different propagation boundaries: Graphiti changes temporal status or selected graph availability; Hindsight removes associated derivatives and schedules further repair; Mem0 explicitly replaces a payload and its local retrieval representations. These are not three grades on one forgetting scale.

Independent support matters differently at each boundary. Graphiti's first-reference deletion can remove a shared edge. Hindsight removes mixed-source observations but retains other contributing sources for reconsolidation. Mem0's inspected entity links are access structures, not a demonstrated multi-source claim-support policy. None establishes that two source identifiers mean two independent reasons to believe a claim.

Fresh reads and stale consumers must also be tested separately. Graphiti's notebook keeps conversation state apart from graph memory. Hindsight's verifier identifies a LangGraph integration that replaces a stable-ID memory message and removes its earlier message on no-memory turns—a specific context-cleanup mechanism, not global revocation. Mem0's recall snapshots and already-shown IDs have their own lifetimes. A server-side mutation cannot be assumed to repair those channels without a connected route (Graphiti checkpoint, Hindsight integration finding, Mem0 recall).

Evidence limitations

These are frozen architectural findings, not current product guarantees. Complete-set reading does not make the underlying inspections exhaustive. Graphiti's backend parity, Hindsight's alternate stores and full retraction executor, and Mem0's hosted backend and language/integration parity remain unresolved. Graphiti's pinned checkout is unavailable here, so its quotations were not freshly checked against source bytes; this comparison relies on retained records and their independent verification.

No correction run was observed or measured, and no causal outcome comparison was supplied. Hindsight's convergence evaluator wires criterion and forbidden-claim checks, but evaluator source is not a passing result or production repair gate (evaluation). Missing repair evidence is not proof that every uninspected route lacks repair. Conversely, coexisting deletion, summarization and retrieval features do not establish that they compose into a correction pipeline.

Open questions and experiments

1. Trace a correction through every representation. Seed an assertion, materialize its summaries/indexes, then correct it. Record IDs, text, temporal fields, vectors, lineage and later retrieved payloads before and after. Separate immediate mutation completion from background convergence.
2. Withdraw one of two supports. Use both genuinely independent sources and a duplicated/derived source pair. Reverse ingestion order. Inspect support IDs and resulting prose separately. Check Graphiti's first-reference behavior, Hindsight's removal/reconsolidation and whether any preserved assertion still has adequate support; do not assume the systems recognize source independence.
3. Exercise failed and delayed repair. Block scheduling, leave consolidation pending, use manual pages and fail mirror fetches. Query between stages. Measure stale-delivery duration and residual unsupported statements, rather than treating mutation success as completion.
4. Keep a consumer alive across replacement. Recall once, correct or withdraw the source, then query in the same session and a fresh session. Inspect copied messages, snapshots and seen-ID state. Test changed text under the same ID separately from a new replacement ID. For Mem0, use a backend/integration pairing with established mutation semantics, not local Python behavior as a surrogate for an opaque hosted update. Record the next model input, not just the integration's returned state.
5. Separate visibility from erasure and semantic repair. Compare expiry, archive invalidation, source deletion and explicit replacement. Inspect private extraction context and history as well as public search. Run independently specified factual checks on repaired summaries; use controlled interventions only when attributing a measured benefit to a particular repair mechanism.

Agent Memory topic · Memory comparisons and data · Read-back mechanisms · Methods & Data