Agent-memory field comparison: where Synapse is ahead, behind, and should adapt

Executive summary

The field validates Synapse’s four load-bearing bets: invalidation-not-deletion, provenance + reversibility, deterministic non-ML trust, and local-first Markdown-as-truth, and several are being independently rediscovered as necessary in the 2025–26 literature. It also exposes a handful of concrete, low-risk improvements we should adopt. The single most important reframing: operation-level benchmarks now measure that auto-extraction and auto-update are where memory systems corrupt (extraction accuracy <62 %, correct-update rate <26 %: HaluMem). That is exactly the stage Synapse’s human-accept gate sidesteps, but only if we reframe the gate from “a human approves every write” (friction the market rejected) to “auto-apply the reversible majority, gate only the costly minority”, which ADR-022 already half-encodes. The five highest-leverage adoptions are below; none requires abandoning the thesis.

1. Context and premisses

Synapse is a local-first, single-user, Markdown-as-truth knowledge graph (Rust; CLI + MCP). Markdown files are the source of truth; a disposable SQLite index holds FTS + vectors + a typed graph. The moat is governance: AI proposes a fact → a human accepts it; accepted facts carry inline provenance + a history chain; an append-only, tamper-evident, git-anchored audit; reversibility via git and at <ref>. We have just repositioned the brand around provenance + reversibility + tamper-evidence (not the gate) and applied a roadmap cut list. This brief asks: given that positioning, what has the rest of the field figured out that we should learn from, and what have we gotten right that the field is still catching up to?

2. Market scan

2.1 Temporal model: valid-time vs transaction-time

The mature pattern is a four-timestamp bitemporal fact, not a two-timestamp one: valid-from/valid-until (when it was true in the world) and recorded-at/expired-at (when the system believed it). The two axes are decoupled on purpose; a job change that happened in March may be learned in June. “Currently true” resolves to valid-until IS NULL AND expired-at IS NULL; historical queries filter the valid axis, audit queries the transaction axis. A heavier variant reifies time itself as graph nodes (Timestamp/Interval) for native “during/overlaps/before” reasoning: overkill for a personal KB.

What this means for Synapse: ADR-027’s plan (valid-time in frontmatter, transaction-time derived from git) is the good half of the mature model, but deriving “when we stopped believing it” purely from git commit boundaries is fragile under batch commits (a commit that both adds B and closes A collapses both transaction-times). We should store an explicit belief axis (x-recorded-at / x-invalidated-at) on the fact and reserve git for the tamper-evident audit axis where it is uniquely strong. Adopt three deterministic supersession rules: new-after-old → close old; older-than-known → born already-expired (out-of-order ingestion); disjoint intervals → keep both, no contradiction. Materialise a current flag in the index so the hot read path is an indexed lookup, not an interval scan.

2.2 Contradiction detection: structural → semantic candidates → judge

The disciplined approach is layered, cheapest-first: (a) structural match (same subject+predicate, different object) with an exact-normalised-text short-circuit for pure duplicates; (b) semantic candidate retrieval: hybrid search nominates the top-K related facts as invalidation candidates (catches reworded contradictions like “lives in Berlin” vs “moved to Munich” that a same-field check misses); (c) an LLM-as-judge over only that small candidate set returns duplicate and contradicted index lists. The brittle anti-pattern is a single LLM call emitting ADD/UPDATE/DELETE/NOOP that fuses detection and resolution, over-deletes, and has no temporal axis. Cosine distance should nominate candidates, never decide.

What this means for Synapse: SYN-242 should be: structural + exact-dedup (deterministic, no model) → semantic candidate retrieval → escalate to the pending queue with the candidate set attached rather than auto-adjudicate. The human gate is the right home for the expensive, non-deterministic judgment the field tries (and fails, <26 %) to automate. Once a human confirms supersession, the interval-closing is pure date arithmetic.

2.3 Decay, forgetting, consolidation

Three shapes dominate: write-time reconciliation (forgetting as a side effect of an LLM add/update/delete verb: its named failure mode is catastrophic forgetting: silently overwriting still-valid facts); background consolidation (“sleep-time” passes every N episodes that cluster and abstract old detail into compact gist: destructive of originals unless archived); and genuine time-decay as a retrieval-rank multiplier (Ebbinghaus/ACT-R curves; retrieval reinforces, disuse fades), usually with importance tiers and a TTL only on the long tail. Notably, several systems fence destructive forgetting behind explicit confirmation, and one keeps automated time-decay as a paid/hosted-only feature its open SDK refuses, a tell that automated forgetting is considered risky.

What this means for Synapse: Non-destructive (advisory stale, never deletes) is the correct, under-marketed call; the field is painfully relearning that destructive consolidation corrupts memory. Two reversible gaps to close: (1) a compaction path that writes a new summary fact linking to (not replacing) its sources: bounded retrieval cost without losing reversibility; (2) ensure decay actually moves retrieval rank, not just a list: stale and ranking must share one decay function (ADR-029 already specifies the curve; wire it into fusion, see §2.8). The “profile vs log” distinction (current-state-overwrite vs append-and-enrich) maps cleanly onto per-type policy (SYN-248).

2.4 Write governance / human-in-the-loop

Essentially no shipped agent-memory system gates memory writes behind human approval; the category’s whole value is frictionless capture. The closest analogue gates tool calls generically (requires_approval → pause/persist/resume), which validates the mechanism but positions it as an optional safety guardrail, not the default. Where there is no human, bad writes are prevented by machinery: dedup-before-write, write-time contradiction resolution, confidence thresholds, periodic “memory reviewer” hygiene passes, and (in the recent governance literature) an explicit write-validation gate as a truth-maintenance system that auto-rejects a write failing an NLI contradiction check. So the governance idea is being independently rediscovered as necessary; Synapse is early, not wrong.

What this means for Synapse: An absolute every-write human gate is friction the market rejected; keep ADR-022’s tiered auto-apply and push it further: auto-apply the reversible majority (git + at <ref> make a wrong write cheap to undo, which removes the main justification for blocking), and reserve the gate for new entities, irreversible/identity changes, and contradictions of high-trust facts. Add a syn-native memory-hygiene review (surface duplicates/contradictions/stale/low-confidence into the pending queue): it converts the field’s “reconcile-later” into our accept-gate idiom and gives the gate high-value work. Messaging matters: lead with “every AI write is auditable and reversible,” not “AI proposes, human disposes.”

2.5 Provenance / audit / attribution / reversibility

In shipped memory systems the ceiling is a per-fact actor_id + role + created/updated_at and a plain mutable history table: captures who/when/what-changed, but not which-model/why, and is not tamper-evident (an ordinary table a compromised process can rewrite). The Markdown-native siblings stamp frontmatter lineage but have no history chain, no signing, no audit log, no undo command. Cryptographic, tamper-evident provenance (signed receipts, hash-chained custody, content-hash manifests, external witnesses) is an active theme in the adjacent agent-governance and content-authenticity literature, but is absent from shipped agent-memory products.

What this means for Synapse: Our stack (hash-chain + ed25519 signed checkpoint + git Merkle DAG + identity-bound commit signing + portable signed receipts + audit verify) matches what the governance literature prescribes and exceeds what any memory product ships. The moat is real but time-boxed; the right framing is “Synapse already ships what the governance papers are still writing,” and durability comes from binding it to local-first Markdown + identity, not from the crypto alone (which others can copy).

2.6 Storage model

Three camps: graph-DB-backed (max query power: native multi-hop, community detection: at the cost of a DB dependency and no human-editable artifact); pluggable vector-store + metadata (max operational/multi-tenant flexibility, but the store is a black box with no inspectable truth); and Markdown-as-truth + disposable index (ours). The mature Markdown analogue’s own trajectory is the warning sign: to stay correct under concurrency it bolted on a server/Postgres index path and a cloud bidirectional-sync layer with git-style conflict modes; i.e. multi-writer is exactly where files-as-truth breaks, and the fix is to stop being files-as-truth.

What this means for Synapse: Markdown-as-truth is a strength for our single-user, auditable, git-friendly thesis and a genuine differentiator (every claim traces to a diffable, revertible file), and the multi-writer tax that tears the seam is a cost we do not incur by design. The standing weakness is query power: relations resolved as lazy forward-references and deep traversal simulated in SQL rather than native. The portable lesson from the field’s sync engines: a naive “scan tree, diff checksums” loop is what feels O(n²); the principled fix is a persisted scan watermark + mtime → size → checksum gating (checksum only when mtime/size already differ) + content-hash move/rename detection. This directly extends the reindex work in §2.9.

2.7 Typed / open schemas

Four designs: typed-model-as-schema (custom types as typed classes; field annotations declare which fields are embeddable/indexed and which are identity fields that deterministically derive the node id via a namespaced hash: free, lookup-less dedup); frontmatter-bag + parsed body (open vocabulary of categories/relations expressed in prose, indexed via a JSON bag: low friction, no validation, no fast typed columns); reference-ontology overlay (validate against an external RDF/OWL vocabulary: powerful for real taxonomies, heavy for a personal KB); and fixed memory blocks with char limits (an anti-pattern for an open typed graph).

What this means for Synapse: Our closed-core + EAV-side-table + open-frontmatter-bag (ADR-028) is sound and injection-safe, and binding field names as values (never interpolating) is the correct invariant. The single idea worth adopting: identity fields → deterministic hashed id: declaring which fields define an entity’s identity and hashing them to a stable id gives free dedup/merge, directly useful for contradiction detection (SYN-242) and merge-safe multi-author segments (SYN-249). “Typed observations in the body” is a lower-friction capture path worth considering, but it trades away validation.

2.8 Retrieval / ranking

Plain RRF (k=60) is a respectable, recall-leaning floor, not the ceiling. k is a precision/recall dial (low k rewards the top hit; high k rewards cross-list consensus). The well-trodden upgrades, cheapest first: weighted RRF (per-source weights); additive normalised scoring (semantic + sigmoid-normalised BM25 with query-length-adaptive steepness + entity-match boost: strictly more expressive, at the cost of per-signal normalisation, which is the brittleness RRF dodges); graph rerankers (anchor/node-distance: “things near your focal entity rank higher”; mention-frequency as a corroboration proxy; MMR for diversity); and a cross-encoder final stage (SOTA precision, ~80–120 ms for ~20 docs, but its marginal gain shrinks once stage-1 hybrid is already good, which ours is). A no-new-dependency variant uses a general LLM as a boolean relevance classifier and reads the logprob of the “true” token as the rerank score.

What this means for Synapse: The single cheapest precision upgrade is to fold ADR-029’s deterministic trust score into the fusion step as a per-candidate boost: it currently lives only in blame/display, and the field stores importance on the record and uses it in ranking. Next: an anchor-distance graph reranker for focal-entity queries (we already fuse a graph signal; promoting it is dependency-free). Expose k / per-signal weights. Treat a cross-encoder (or the LLM-logprob variant via MCP) as an opt-in final stage only: its gain over good hybrid is real but bounded.

2.9 Indexing / scale

Consensus: flat vector search is genuinely fine exactly where Synapse lives (thousands to low-hundreds-of-thousands of vectors); it gives deterministic, linearly-growing latency and only becomes painful around 10⁵–10⁶. HNSW adds build cost, recall-tuning params, and non-determinism for no gain below ~100k, a post-100k lever, not a now-lever. Ingestion is kept sub-linear by change-set work, not clever indexes: watermark + incremental scan, cheap-op-gating before checksums, batch + bounded concurrency, embedding in one batched pass over only content-changed entities, and separating FTS indexing from embedding (index text now, vectorise later) so a missing model doesn’t fail or re-scan everything.

What this means for Synapse: Our reindex O(n²) fix (prepare_cached + insert-only bulk path + single bulk FTS rebuild) is the same instinct and already paid off (10k full reindex 7.9 s → 0.4 s). The remaining wins, in order: (1) batch the embedding call across all content-changed entities and only re-embed when an embeddable field changed (tie to §2.7’s indexed-field declaration so a frontmatter-only edit skips re-embedding); (2) watermark + mtime/size-before-checksum scan (the structural fix for scan cost at scale); (3) content-hash move/rename detection so a renamed note keeps its id and links; (4) hold HNSW until SYN-227 budgets actually cross the threshold: they won’t at single-user scale.

2.10 Extraction: and why “agent proposes, no auto-extraction” is mostly right

The field’s dominant pattern is a two-call extractor (extract atomic self-contained facts → reconcile against existing memory with an add/update/delete verb), governed by enormous prompts encoding hard-won rules: atomicity, pronoun/speaker resolution, specificity preservation (“416 pages”, not “about 400”), no-echo (don’t re-extract the assistant’s restatement), no-meta-extraction (store the content, not “user shared a document”), and observation-date grounding (resolve “last week” to an absolute date at write time). HaluMem now measures the failure: extraction recall <60 %, accuracy <62 %; update correctness <26 %; the system misses real facts and fabricates them, and the update stage is the weakest link. Root causes are structural: recall-maximising “when in doubt, extract”, speaker misattribution, echo, and meaning-inversion (“used to love hiking” stored as present-tense).

What this means for Synapse: By not running an auto-extractor, Synapse structurally avoids the stage where the whole field scores <62 %. The human gate is a precision filter no competitor has, and the benchmarks now validate it. But there are two honest gaps: (1) the work doesn’t vanish, it moves to the MCP client agent; if that agent runs a naive extractor we inherit the <62 % before the human sees it, and the gate just makes a human triage noise. We should publish a proposal-quality contract / prompt-guidance doc for client agents encoding the field’s extraction craft; this raises the floor on what reaches the gate without building an extractor. (2) Human-gated capture does not scale to “ingest 10k chat turns”; capture/ambient-git are the pressure valves, and precision-over-recall-at-scale is the right trade for governed memory.

2.11 Dedup / merge on ingest

Three strategies; the best layer them: LLM-as-reconciler (the <26 % stage, a single judgment that can DELETE, unrecoverable without versioning); deterministic-first, LLM-as-fallback (the strongest idea: exact-normalised match → MinHash/LSH fuzzy match over character-n-gram shingles, gated by a Shannon-entropy filter so short/low-entropy names skip straight to the model → LLM only on true ambiguity: most dedup never touches an LLM); and ADD-only + link, defer merge (never merge on ingest; store new facts with linked_memory_ids, resolve later: trades storage for never silently destroying a memory).

What this means for Synapse: When SYN-242 ships, internalise deterministic-first-LLM-last tiering and invalidate-don’t-delete: both align with our existing NER/mention-linking and ADR-027, and both avoid the destructive auto-merge the benchmarks punish. The identity-hash idea (§2.7) is the deterministic backbone for the first tier.

2.12 Evaluation

The public benchmarks measure auto-extract-and-auto-answer pipelines: LoCoMo (end-to-end QA over multi-session dialogue; single/multi-hop, temporal, adversarial), LongMemEval (extraction, multi-session + temporal reasoning, knowledge updates, abstention), HaluMem (operation-level hallucination: extraction/update/QA scored separately). Documented criticisms: LoCoMo conversations are short enough (~16–26k tokens) that “memory” is partly just long-context reading; gold labels are sometimes wrong; SOTA claims are contested and configuration-sensitive (critique); and the deepest flaw is the wrong unit of measurement: QA scores “did the model answer given context”, not “did the memory store/retrieve correctly”, letting systematic storage failures hide behind decent QA.

What this means for Synapse: Do not adopt these benchmarks; they assume a pipeline we deliberately lack, and chasing them would distort us toward auto-QA. Build a property/invariant harness instead, because governed memory’s quality is verifiable where the field can only estimate: (1) provenance correctness (every fact traces to an accepted proposal; unbroken x-ai-history); (2) reversibility integrity (replaying the audit reconstructs current state exactly; audit ⟷ store ⟷ index agree); (3) no-silent-corruption (no accepted change overwrites a fact without a recorded supersession, the one thing the field fails at <26 % and we can prove); (4) temporal correctness (at <ref>/--as-of return the state that held: deterministic, where the field scores worst); (5) door parity (CLI ⟷ MCP identical); (6) round-trip fidelity (reindex reproduces the index; export→import lossless). The reframing is itself marketing: “we can prove our memory didn’t corrupt; the field can only score whether a judge liked the answer.”

3. Cross-check vs prior hypotheses

4. Highest-leverage adoptions (recommended, ranked)

1. Inject the ADR-029 trust score into retrieval fusion: cheapest precision upgrade, reuses shipped work; trust currently only displays.
2. Reframe SYN-242 contradiction as deterministic-structural + semantic-candidate-retrieval → escalate to the gate (not LLM auto-resolve); pure date-arithmetic supersession on confirm.
3. Batch embedding + watermark/mtime-gate scan + move-detection: extends the reindex fix; the field’s proven sub-linear-ingestion patterns.
4. Proposal-quality contract for MCP client agents: encode atomicity / observation-date / no-echo / no-meta-extraction / attribution; closes our one real extraction gap without building an extractor.
5. Property/invariant eval harness: provenance, reversibility, no-silent-corruption, temporal correctness, door parity, round-trip; makes our quality provable.

Secondary: explicit belief transaction-time axis (§2.1); reversible compaction-with-links (§2.3); identity-hash dedup (§2.7); per-type “profile vs log” decay policy (SYN-248); anchor-distance graph reranker (§2.8).

5. Disruptive bets (a SaaS competitor cannot easily copy)

1. “Provable, not estimated” memory quality. Ship the invariant harness and surface its assertions (audit verify, a doctor-style integrity report). A hosted multi-tenant memory service cannot let a user prove its store didn’t corrupt theirs; we can, because the truth is their files in their git.
2. Reversibility-first governance. “Auto-applied but always reversible, gated only when it matters” is a posture that needs a content-addressed, user-owned substrate, which a server-side store structurally lacks.
3. Git-native bitemporality. Tamper-evident transaction-time from git’s Merkle DAG, uniform across every type and file, bound to identity; the field’s temporal systems store transaction-time as a mutable DB column.
4. The proposal contract as a standard. Publishing the extraction-craft contract for MCP clients makes Synapse the quality bar other agents target, without us running the lossy extractor.

6. Ticket sketch (provisional)

7. Risk register

8. Open decisions

1. Do we add the explicit belief transaction-time axis now (sharpens SYN-223/242) or keep deriving from git for v1.0 and revisit?
2. Is the property/invariant harness a syn verify command (user-facing) or a CI test-suite (internal), or both?
3. Does the proposal-quality contract ship as a doc, or also as a machine-readable schema the MCP server advertises to clients?
4. Per-type “profile vs log” decay (SYN-248): worth the [policy.<kind>] surface, or defer past v1.0?

9. References

• HaluMem: operation-level hallucination evaluation for memory systems (arXiv 2511.03506)
• LongMemEval (arXiv 2410.10813)
• LoCoMo overview
• Temporal knowledge graphs for LLM agent memory (Zep paper)
• “Is Mem0 really SOTA?”: benchmark critique
• Governing Evolving Memory: SSGM framework (arXiv 2603.11768)
• ACT-R-inspired remembering/forgetting in LLM agents (ACM)
• Understanding Reciprocal Rank Fusion in hybrid search
• Weighted RRF (Elastic)
• Search reranking with cross-encoders (OpenAI Cookbook)
• Scaling vector search: flat vs HNSW
• sqlite-vec stable release