Skip to content

2026 agent-memory best practices — research synthesis (for Argus)

Deep-research run 2026-06-20 (multi-agent fan-out: 6 angles, 23 sources fetched, 108 claims extracted, 25 adversarially verified by 3-vote, 22 confirmed / 3 killed). Confidence is uneven and stated per finding. This is directional validation of Argus's design, not a definitive survey — see the Gap section.

Bottom line

The 2026 literature converges on exactly the principles Argus was built on: verifiability-first, fail-loud, hybrid RRF over pgvector, no LLM on the capture hot path, and inspect-via-audit-log + linter. The work we shipped this week (recall floor observability, calibration histogram, system-turn hygiene) is squarely on the recommended path. There is little to change and a few things to add.

Confirmed findings (high confidence)

  1. Silent failure is THE failure mode. A wrong eviction or a stale/missing recall produces "no exception, no log entry, no obvious signal." The mitigation is to log every memory op with enough context to replay it, and to start with a simple architecture and graduate complexity only on data. (arXiv 2603.07670) → Argus's audit tables (gate_rejections, dedup_log, segment_checks, injections) and the immutable raw_items replay spine are exactly this.

  2. Hybrid keyword + vector via RRF with recency/importance scoring, a relevance gate with a drop-threshold, and ~0.8 dedup — and pgvector is sufficient for it at personal scale. (claude-hooks, total-agent-memory) → This is Argus's hybrid.go (RRF k=60 + type-prior + project boost + floor) and dedup.go (0.80) essentially verbatim.

  3. Capture = append NDJSON per session, no LLM on the hot path; re-inject on SessionStart after compaction. The named anti-pattern: hooks that exit 0 on failure (silent). (claude-hooks, Khoury) → Argus capture is LLM-free and fail-loud; recall re-injects at SessionStart. Match.

  4. Inspectability = a dashboard + a linter. Lint the knowledge store for orphans, contradictions, and staleness; use bitemporal facts and multi-representation embeddings; verify recall by atomic-fact grounding (Ragas-style). (total-agent-memory) → Argus has the dashboard (/ui/*), bitemporal valid_from/valid_to, and write-gate grounding. The linter is the gap (see below).

Refuted (killed in verification — do NOT adopt)

  • "An LLM reading a structured index beats vector search at personal scale." Killed 0–3. Don't replace pgvector recall with index-reading.
  • "Component inspectability is solved via OpenTelemetry traces + mocking + assertions." Killed 1–2. Aspirational, not established practice in 2026.
  • "The central failure mode is injection/recall, not storage." Killed 1–2. Overstated; storage correctness still matters.

What to steal vs avoid (for the Postgres + pgvector hub)

Steal (and mostly already have): - Hybrid RRF on pgvector + a calibrated relevance gate — have it; just made it observable + tunable (ARGUS-18/19/20). - Append-only NDJSON capture, no LLM on the hot path — have it. - Bitemporal validity (valid_from/valid_to) so "what was true when" is queryable — have it. - Audit-everything: every op leaves a replayable row — have it. - Hold-until-approved for risky merges instead of silent overwrite — have it (dedup review queue).

Steal (don't have yet — candidate work): - A memory linter — a scheduled check for orphan notes, contradictions, and staleness, surfaced as a report. This is the one clear gap vs the 2026 recommended practice. Natural M7+ task. - Atomic-fact grounding for recall quality (Ragas-style): sample recalls and score whether the injected notes actually grounded the answer — turns "is recall good?" from vibes into a metric.

Avoid: - LLM-as-router/index-reader for retrieval at this scale (killed). - Learned/holographic tiering and decay jobs that run blind every few minutes — the exact memory-os anti-pattern; only graduate to complexity on data (confirmed). - Treating OpenTelemetry tracing as a substitute for domain audit logs (unproven).

Framework reputations — GAP, not delivered

The run was asked to compare Letta/MemGPT, Mem0, Zep/Graphiti, A-MEM, cognee, txtai. Those head-to-head claims did not survive 3-vote verification (sourced mostly from vendor blogs and listicles) and were dropped. We do not have a trustworthy 2026 framework comparison — do not infer one from this doc. If that comparison matters, it needs a dedicated run scoped to primary sources (benchmarks, the projects' own docs) with allowed_domains set, not open web search.

Caveats

Primary sources were two single-author, non-peer-reviewed arXiv surveys plus practitioner READMEs (claude-hooks, total-agent-memory, claude-memory-compiler). The findings are directionally strong and self-consistent with Argus's design, but this is a 2026 snapshot of a fast-moving field, not settled science. Trust the confirmed findings; verify anything load-bearing before acting.

Sources (selected)

  • arXiv 2603.07670 (silent-failure / start-simple) · arXiv 2502.12110 (framework survey)
  • github.com/mann1x/claude-hooks · github.com/vbcherepanov/total-agent-memory · github.com/coleam00/claude-memory-compiler
  • mem0.ai/blog/state-of-ai-agent-memory-2026 · digitalapplied.com hybrid-search refs