Skip to content

Memory Architecture — Research Findings (M0.5)

Date: 2026-06-09 Method: multi-agent deep-research (6 angles, 27 sources fetched, 125 claims extracted, 25 adversarially verified by 3-vote — 22 confirmed, 3 killed). Purpose: ground the Argus memory-service design in the literature before building (M0.5).

Executive summary

Treat memory as a multi-stage pipeline — capture → distill → store → recall — where each stage is independently observable. The literature shows recall failures originate upstream in extraction/updating, not just at retrieval (HaluMem), and self-poisoning loops form when captured content (including the system's own error text) is compressed into "high-confidence lessons" and re-injected on semantically-similar recall (Mnemonic Sovereignty; SSGM) — exactly the memory-os failure mode, and it's a documented structural mechanism, not an accident.

A single bad write is a recurring hazard: it persists across hundreds of future sessions until manually purged, and in evolving memory errors are cumulative, unlike static RAG where an error is isolated to one retrieval. So cheap purge + provenance tracing is mandatory.

What to STEAL (all verified 3-0 unless noted)

  1. Dual-track store (SSGM, arXiv 2603.11768): an append-only immutable raw layer (the operational source of truth — every captured chat turn / Telegram msg / article / synthesis, never updated) paired with a mutable distilled layer that is always regenerable from raw. Enables asynchronous reconciliation — periodically replay/correct drifted distilled memory against raw. → Postgres: raw_items (never UPDATEd) + distilled_notes (regenerable); a reconcile job diffs distilled-vs-raw and is itself logged.

  2. Grounded, self-questioning extraction (ProMem, arXiv 2601.04463): for each candidate distilled note, generate a verification question, extract only if the raw text answers it, and discard + log anything ungrounded. Attach a source span/quote to every note. → This single write-gate would have blocked memory-os from storing its own API-error text. The surveys note no production system implements this.

  3. A-MEM note schema (arXiv 2502.12110) for inspectability: each note = {content, time, keywords, tags, context, embedding, links} with LLM-generated human-readable attributes at ingest — directly auditable. CAVEAT: disable or version A-MEM's silent "memory evolution" (it rewrites notes post-ingest — a verifiability hazard; if kept, every evolution must be an audited diff).

  4. Bi-temporal validity (Zep/Graphiti, arXiv 2501.13956): valid_from / valid_to / invalid_at columns for staleness ("what was true when"). Steal only the temporal model — NOT a separate graph DB, and NOT Zep's benchmark numbers (refuted in this review). Timestamps + validity columns + explicit staleness flags on distilled facts.

  5. Recall-impact verification (RePCS, arXiv 2506.15513): confirm injected context actually changed model behavior (KL divergence between query-only and query+context outputs; low divergence = the model ignored it). Plus log which memory items were injected per session. Closes the recall-side observability gap. (Mechanism sound; efficacy unproven — treat as a cheap signal, not gospel.)

  6. Resurfacing (Readwise official docs): probabilistic, density-weighted, decay-on-shown — a document's share of total items = its chance of surfacing; each time shown, future probability sharply drops (rotation, no repetition). → Postgres weighted-random draw + shown_count/decay column; fully inspectable (query the exact probabilities + shown-history). Optional FSRS closed-form interval I = stability/FACTOR·(retention^(1/DECAY) − 1) for items wanting true spaced-repetition mastery (e.g. agent-written syntheses worth retaining).

What to AVOID

  • Write-gate validation and post-deletion verification are UNIVERSAL blind spots — absent in Letta/MemGPT, Mem0, Zep/Graphiti, Cognee (Mnemonic Sovereignty, 2-1). We must build them explicitly; no off-the-shelf system provides them.
  • Blind background maintenance — reflection/decay/semantic-dedup running every few minutes without snapshots, version diffs, or forensic traceback leaves no remediation path after a bad write (the memory-os sin). Provenance + audit tooling is the precondition for any remediation.
  • Never let recall output be a capture source without re-grounding; filter API-error/system text at the write gate; don't auto-promote recalled items to higher confidence (that reconsolidation step is the self-poisoning amplifier).
  • Soft-delete with tombstones, not hard DELETE — so post-deletion state is verifiable.
  • Ahead-of-time/static summarization is lossy (drops dates/entities/preferences; ~60% facts lost in compaction studies). Store a tight distilled headline as the default recall payload but always keep raw linked so expand-on-demand never depends on a lossy summary. (Validates "short by default, expand on demand.")

Refuted (do NOT build)

  • Zep's LongMemEval/LOCOMO accuracy figures (1-2; corrected 84%→58.44% by Mem0). Don't cite Zep numbers.
  • A Truth-Maintenance-System logical-contradiction write-gate as the pre-commit check (0-3; overkill for personal heterogeneous notes — use ProMem-style grounding instead).
  • "Single-pass extraction errors persist forever because never re-examined" (1-2; the dual-track reconcile is exactly the re-examination path).

Open engineering questions (literature motivates, doesn't specify — for M1 design/empirics)

  1. Cross-type recall ranking — chat turn vs. article vs. synthesis in one query. No source gives a cross-type function; needs an empirically-tuned hybrid: pgvector + full-text/BM25 + type-priors + recency/validity, fused with RRF (reciprocal rank fusion — the documented pgvector hybrid-search pattern).
  2. Deduplication that collapses true duplicates without the blind-dedup drift failure — likely deterministic hash/near-dup at the raw layer + audited, reversible merges at the distilled layer.
  3. Operator SLOs/metrics that make "it's working" observable solo: capture-rate, grounding-rejection-rate, distill-vs-raw reconcile diffs, recall-injection-used rate.
  4. Reconciliation cadence + auditability — how often the replay/reconcile runs and how its own decisions stay inspectable (so it doesn't become the next blind background job).

Caveats

Literature is very fresh (late-2025→mid-2026 preprints, several not peer-reviewed; a chunk from one lab, MemTensor). Mechanism and design-pattern claims are well-corroborated across independent groups; treat specific quantitative results as provisional. None of these sources directly validate our exact stack (Postgres+pgvector, cross-machine CC/Codex/Telegram ingest, Obsidian export) — they ground the principles, the engineering is ours to validate.

Key sources

  • HaluMem (operation-level hallucination benchmark) — arXiv 2511.03506
  • Mnemonic Sovereignty survey (self-poisoning mechanism, blind-spots) — arXiv 2604.16548
  • SSGM (dual-track storage + reconciliation) — arXiv 2603.11768
  • ProMem (grounded self-questioning extraction) — arXiv 2601.04463
  • A-MEM (structured note schema) — arXiv 2502.12110
  • Zep/Graphiti (bi-temporal validity) — arXiv 2501.13956
  • RePCS (recall-impact verification) — arXiv 2506.15513
  • Readwise resurfacing docs; FSRS algorithm (rs-fsrs)
  • pgvector hybrid search + RRF — paradedb / tigerdata / dev.to guides