SuperLocalMemory 4.0: The Governed Memory Operating System for AI Agents

Arun Pratap Bhardwaj; Garima Singh; Varun Pratap Bhardwaj

REVIEW 3 major objections 3 minor 31 references

SuperLocalMemory 4.0: The Governed Memory Operating System for AI Agents

T0 review · 3 major / 3 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that a local-first memory layer for AI agents can enforce a governing write-time invariant — one authenticated actor, one profile generation, one policy decision, one durable receipt, one verifiable completion state —…

desk verdict Scrupulously honest agent-memory engineering with a load-bearing gap: the headline write-path invariant is supported by component tests plus code inspection, not by any end-to-end HTTP-level test, but the paper itself says so. read the letter →

arxiv 2608.08253 v1 pith:RYIC7ZA3 submitted 2026-08-08 cs.AI cs.IR

Varun Pratap Bhardwaj , Garima Singh , Arun Pratap Bhardwaj This is my paper · ORCID

classification cs.AIcs.IR

keywords agentmemorylocal-firstgovernanceverifiabletransactionscompletionmanifestgenerationfenceverifiederasurefault-injectionevaluation

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

SuperLocalMemory 4.0 is presented as a local-first memory operating system for AI agents: one control plane that unifies five retrieval channels, a learning-and-behavior brain, bi-temporal recall, multi-tenant isolation, and compliance controls, with no cloud provider required in the memory path in its default modes. The paper's central claim is that the primary write path can be governed by a single admission invariant — one authenticated actor, one profile generation, one policy decision, one durable receipt, and one verifiable completion state across the three registered projection stores (BM25, temporal, vector). The evidence for the claim is eleven fault-injection and mechanism scenarios, each repeated 200 times, with all 2,200 repetitions upholding their scoped component properties, and a directly measured in-process overhead of 1.687 ms at the median and 2.728 ms at p99 over the ungoverned write path. The authors are explicit that this is component-level evidence, not an end-to-end multi-process or retrieval-accuracy benchmark, and that transport, multi-process, mesh, and long-lived deployment fault-injection remain future work.

What carries the argument

The carrying mechanism is the V4 reliability spine: generation-fenced admission (a process-local, TTL-bounded map from (profile_id, idempotency_key) to a generation epoch that rejects stale writes with WriteCoordinatorError before any projection write), verifiable memory transactions (a transactional obligation ledger with per-projection owners — Bm25Owner, TemporalOwner, VectorOwner — implementing apply/verify/compensate/erase/prove_erased, with SHA-256 checksums), a hash-checkable CompletionManifest (COMPLETE when every obligation is terminal-success, DEGRADED when at least one failed after compensation, FAILED when the canonical write failed; sealed with installation-key HMAC-SHA256 on current schemas), and cross-store verified erasure with live physical re-queries and tamper-evident receipts. This bundle turns an ordinary remember call into an auditable, bounded transaction across heterogeneous local stores.

What would settle it

Run the same eleven scenarios against the real HTTP daemon with the full end-to-end path — HTTP auth, ActorContext, journal, generation fence, projection owners, obligation ledger, completion manifest, and the ANN index — and require 200/200 per scenario; any stale-epoch write that reaches a projection owner, or any ERASE after which an ANN or other registered projection footprint remains, would falsify the invariant as stated.

Watch

Extended reading notes

Core claim

The central claim is that a memory layer for AI agents can make reliability a physical-store property rather than an application-layer hope: the central systems contribution is a hash-verifiable projection-obligation and completion-manifest protocol across heterogeneous local stores under scoped admission. On every canonical write through the HTTP/remember route and internal ingestion, the runtime atomically commits the canonical fact, a durable receipt, and projection obligations for three registered owners (BM25, temporal, vector); each owner then proves its own apply/verify/compensate/erase, and a hash-checkable CompletionManifest reports COMPLETE, DEGRADED, or FAILED from canonical presence and obligation evidence. A generation fence rejects stale writes from a superseded profile epoch before any projection owner runs, and erasure returns all_erased=True only after each owner's live re-query confirms absence. The paper presents this as the enforced design of the write path and the target architecture for all surfaces, not a property already enforced on every transport, and it reports 2,200 of 2,200 deterministic repetitions upholding the scoped component properties.

Load-bearing premise

The load-bearing premise is that component-level, in-process fault-injection results generalize to the real runtime: the paper states that no single scenario exercises the full end-to-end path and that transport, multi-process, mesh, and long-lived deployment fault-injection are future work.

Editorial extensions

If this is right

If the invariant holds, every canonical write can be audited by its manifest: a DEGRADED state records exactly which projection owner failed, and no degraded write is ever promoted to COMPLETE.
A deleted-and-recreated profile cannot be contaminated by a replayed stale write, because the generation fence rejects the stale epoch before any projection owner executes.
A right-to-erasure request with all_erased=True means each registered owner re-queried its physical tables and found no residue at finalize time; partial residue forces all_erased=False.
Governed writes cost about 1.7 ms at the median and 2.7 ms at p99 more than ungoverned writes in-process, so the governance envelope is cheap enough to leave enabled.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A decisive next test would run the same fault-injection scenarios over the real HTTP daemon with a separate process, since the paper's own scope note says no single scenario exercises the full end-to-end path; the invariant's strongest form depends on those untested transport and multi-process paths behaving like the in-process harness.
Because the completion-manifest layer is physical-store projection consistency, it could plausibly sit beneath belief-level or logical-state transaction layers for agent memory, composing into a stack of transaction types rather than a single transaction winning.
Because the erasure evidence currently covers embedding metadata rather than the ANN index itself, a direct check of whether ANN entries survive an ERASE operation would extend the erasure claim to the vector projection's full footprint.
The carried-forward retrieval results come from the prior V3 architecture and do not testify to V4 retrieval quality; an end-to-end V4 benchmark against the same long-conversation tasks would show whether the reliability spine changes retrieval behavior in practice.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

What you should know: this is a rarity — an engineering report on an agent-memory runtime that repeatedly disclaims novelty, pins down its own scope limits, ships the harness, and reports 2,200/2,200 deterministic fault-injection runs. The genuinely new-looking piece is the projection-obligation ledger with a hash-checkable CompletionManifest over BM25/temporal/vector owners, plus the generation-fenced admission. The reader's conditional verdict is about right.

What it does well: the paper is explicit that individual mechanisms are prior art — Graphiti for bi-temporal storage, Mem0 for retrieval, MemTX/MemTxn for other transaction layers — and the claimed novelty is the integration into one local-first runtime with a physical-store reliability spine. That is a defensible, well-scoped claim. The fault-injection methodology is careful: positive controls, fail-loud harness, per-experiment disclosures about synthetic stand-ins vs. real owners, and a runner with a test asserting every experiment is reachable. That is real reproducible evidence and should be credited. The limitations section is unusually candid.

Where the soft spots are: the stress-test note lands, and it is the load-bearing one. All 2,200 repetitions are component-level; none exercises the full HTTP/remember chain. The paper states this plainly — no scenario covers HTTP auth through ActorContext, journal, fence, owners, manifest, and ANN — so the claim that the invariant is "enforced" on the primary write path rests on code inspection plus separately verified components. An integration bug, like the HTTP handler failing to derive ActorContext from the session, would break the invariant without any of the eleven experiments noticing. The paper itself lists an end-to-end HTTP probe as future work, so this is a scope-to-claim gap, not an internal contradiction. It is still load-bearing, because the headline contribution is enforcement on the primary write path.

Minor but real: the overhead numbers are floor figures on a fresh store, the ungoverned baseline is a different code path, the sqlite-vec ANN index is out of scope for the erasure experiments, and the LoCoMo numbers are V3 carried forward, not rerun on V4. All of these are disclosed honestly; none is a fatal flaw.

Who this is for: anyone working on agent-memory infrastructure, governance for local-first AI, or reliability evaluation for AI systems. It deserves a serious referee — the evidence bundle is reproducible and the claims are scoped, which is more than most papers in this area manage. Recommendation: send it to peer review, conditionally. Require either an end-to-end HTTP-level test of the governed write path, or retitle the central claim to "component-level reliability spine" and move the write-path enforcement claim to target-architecture status. Either way, the paper has real value as an honest engineering report.

Referee Report

3 major / 3 minor

Summary. SuperLocalMemory 4.0 is a local-first memory runtime for AI agents that combines multi-channel retrieval, governance, temporal memory, mesh coordination, and a new reliability spine consisting of generation-fenced admission, a transactional obligation ledger with per-projection owners, a hash-checkable completion manifest, and cross-store verified erasure. The governing invariant—one authenticated actor, one profile generation, one policy decision, one durable receipt, one verifiable completion state—is presented as enforced on the canonical HTTP/remember route and internal ingestion, with other transport surfaces adopting the gateway incrementally. The paper reports eleven deterministic fault-injection and mechanism scenarios, each repeated 200 times (2,200/2,200 held), together with in-process performance measurements of the governed write envelope (1.687 ms p50 / 2.728 ms p99 overhead) and carried-forward V3 LoCoMo retrieval results explicitly scoped as not a new V4 benchmark.

Significance. The manuscript is a serious engineering-systems contribution. Its main technical content—a projection-obligation ledger, per-owner verify/apply/compensate/erase protocol, and a hash-sealed completion manifest with an honest DEGRADED state—is a concrete, plausible design for making agent-memory write paths auditable and verifiable. The evaluation practices are a strength: the fault-injection tests are bracketed with positive controls, the repetitions are correctly framed as deterministic flakiness checks rather than statistical samples, the harness is released with a single runner, and the paper repeatedly states what it did not exercise. The authors are unusually candid about the component-level scope of the evidence. However, the headline claim is that the admission invariant is 'enforced' on the HTTP/remember write path, and no integrated test exercises that path end-to-end; the evidence is composition of separately tested components plus code inspection. This is a scope-to-claim gap rather than an internal contradiction, and it is load-bearing because the invariant on the primary write path is the paper's central systems claim.

major comments (3)

[§10.1, VDI 7.3, §11] The central claim that the admission invariant is enforced on the HTTP/remember primary write path is not directly measured. Section 10.1 states: "No single scenario exercises the full end-to-end path (HTTP auth→ActorContext→journal→fence→owners→obligation ledger→manifest→ANN); transport, multi-process, mesh, and long-lived deployment fault-injection are future work." VDI 7.3 similarly establishes the HTTP RBAC middleware by code inspection and lists an end-to-end unauthorized/authorized HTTP probe as future work. Because every experiment in Table 3 drives production modules in-process, an integration defect in the FastAPI handler—for example, failing to derive ActorContext from the session, or capturing the fence epoch at the wrong point relative to journal.prepare—would not be detected by any of the 11 scenarios. The honest scope disclosure does not by itself close the gap between "enforced design of the write path" and "component-level tests pass." The minimal remedy is an end-to-end HTTP-level test of the full chain, including an unauthorized/authorized probe, or an explicit reframing of the invariant as a target architecture rather than an enforced property.
[§10.1 (exp1, exp2b), VDI 7.4, §6.3] The "cross-store verified erasure" guarantee is incomplete for the vector projection. The abstract and Contribution C4 present erasure over the three registered projection owners, including VectorOwner, but Section 10.1 states that the sqlite-vec ANN index is not loadable in the harness environment and that exp1's vector erasure is scoped to the embedding_metadata SQL table. exp2b repeats that the VectorOwner runs in embedding_metadata metadata mode with the ANN index out of scope. The live physical re-query proof in VDI 7.4 therefore covers the metadata table, not the actual vector index. If deployed configurations treat the ANN index as part of the vector projection, an all_erased=True receipt could be truthful for embedding_metadata while leaving the ANN index intact. This needs to be addressed by either including the ANN index in the experiment or narrowing the invariant itself to "vector metadata erasure," not just the experiment disclosure.
[§10.2] The governed write-envelope overhead is presented in the abstract as "per governed write" and "control-plane overheads of 1.687 ms at p50 and 2.728 ms at p99," but Section 10.2 makes clear that the measurement is in-process, excludes HTTP transport and request parsing, runs on a temporary filesystem, and is a floor number. This is disclosed in the body, yet the abstract wording could be misread as an end-to-end cost. Because the overhead figure is one of the paper's headline numbers, the abstract should carry the same qualifier (e.g., "in-process, excluding HTTP transport"), and a loopback-HTTP side measurement, even if small and informal, would anchor the floor and help readers judge deployment cost.

minor comments (3)

[Figure 11 (page 23)] The figure title says "10 Deterministic Property Scenarios" and the caption says "All 10 scoped properties held," but Section 10.1 and Table 3 report eleven scenarios and 2,200 repetitions; exp2b is missing from the overview figure. This count discrepancy should be fixed, and exp2b should appear in the taxonomy because it is the primary real-owner evidence.
[§11, Availability section] The reproducibility statement is slightly inconsistent: Section 11 notes that retained result artifacts record package version and platform but not a source commit or wheel hash, while the Availability section says the exact audited build is pinned at release. For a paper whose evidence is deterministic repetitions, pinning the source SHA and wheel hash of the evidence bundle would make the released records more auditable.
[Figure 2 caption] The caption contains a typo: "skill evolution pipeline in SLM 4.04.0" should read "SLM 4.0."

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the reliability claims are tested against the shipped code itself, with disclosed scope limits; prior-work self-citations are not load-bearing.

full rationale

SuperLocalMemory 4.0's central claims concern the behavior of its own write path and transaction spine (generation fence, obligation ledger, completion manifest, erasure receipts). These are evaluated by direct fault-injection against the installed package: Section 10 states 'Each experiment imports the installed superlocalmemory package and drives production code paths' and explicitly brackets the claims as 'scoped component and mechanism measurements.' The Section 7 invariants are labelled 'Verified Design Invariants' established 'by an implementation trace and measured directly—not a formal theorem deduced from axioms,' so the tests check the shipped artifact rather than an independent prediction. No fitted parameter is renamed as a prediction: the governed-write overhead (1.687 ms p50 / 2.728 ms p99) is measured against an ungoverned baseline, not fitted, and the monotonicity checks verify a stated mathematical function rather than deriving a new empirical result. Prior self-citations (V3 LoCoMo retrieval, information-geometric substrate, Living Brain lifecycle) are explicitly carried forward and not used to support the new reliability-spine claims; the paper states the V3 LoCoMo evidence is 'protocol-scoped, not a new V4 benchmark.' The main limitation—'No single scenario exercises the full end-to-end path (HTTP auth→ActorContext→journal→fence→owners→obligation ledger→manifest→ANN)'—is a scope-to-claim gap about evidence coverage, not a circular derivation: it does not show any claim is equivalent by construction to its input. Accordingly no circular step is identified.

Assumptions & free parameters 3 free parameters · 4 assumptions · 3 invented entities

The central reliability claims rest on software mechanisms (obligation ledger, manifest, generation fence) tested only in-process by the authors' own harness. The paper has few fitted parameters in the reliability spine; the main free parameters are in the retrieval/temporal stack and are secondary to the central claim. The axioms are mostly honest scope limitations rather than hidden assumptions.

free parameters (3)

Ebbinghaus decay constant S (per-fact or global) = not explicitly given in paper
The production Ebbinghaus function R(t)=e^{-t/S} in ebbinghaus.py has a decay constant S that is parameterized; the paper states S>=S_min>0 but does not disclose whether S is fitted, chosen, or per-fact. This parameter shapes the temporal recency model, though it does not appear in the central reliability claims.
RRF fusion constant k = 15
Section 3.2 states 'a single-pass Weighted RRF step (k=15)'. This is a hand-chosen constant in the retrieval fusion, a standard RRF parameter, not fitted to the central reliability claims.
Demotion score factors = 0.25 for superseded facts, 0.5 for half-open validity
VDI 7.5 states system-invalidated facts receive score factor 0.25 and validity violations apply a 0.5 factor. These are hand-chosen constants in the temporal demotion mechanism, tested for the monotonicity property, not for optimality.

assumptions (4)

domain assumption Deterministic repetitions of component tests are evidence for reliability of the scoped mechanisms
The entire 2,200/2,200 evidence base is deterministic, and the paper explicitly says repetitions are flakiness checks, not independent Bernoulli trials. The assumption that these repetitions support the stated reliability claims is load-bearing and stated in Section 10.
domain assumption In-process measurements with a fresh temporary filesystem bound the real-world governed write overhead
Section 10.2 measures the governed envelope in-process on a fresh store on a temporary filesystem, calling the results floor numbers. The assumption that real deployments will see overhead near these numbers is not tested.
domain assumption Authorization-layer isolation is an acceptable security boundary
The threat model explicitly excludes a single OS user with direct disk access. The paper labels this 'authorization-layer control, not cryptographic multi-tenancy'. This is a stated scope assumption, not a flaw.
standard math HMAC-SHA256 unforgeability holds with installation-key secrecy
VDI 7.2 relies on standard cryptographic assumptions for the completion manifest seal; the paper correctly notes that an attacker holding the installation key is outside the model.

invented entities (3)

Projection obligation ledger and CompletionManifest
purpose: New protocol data structures to track and verify per-projection write completion across BM25, temporal, and vector stores.
These are internal software artifacts introduced by the paper; they are tested in the shipped harness but have no falsifiable handle outside the paper itself, only inside the system's own semantics.
Generation fence epoch map
purpose: Process-local TTL-bounded map to reject stale-epoch writes after profile recreation.
An internal mechanism; the only evidence is the fault-injection test exp7 on the shipped code, with no independent external validation.
Ebbinghaus recency model with memory decay
purpose: Temporal ranking of memories based on exponential decay.
A standard psychological model; the paper tests monotonic decay and uses it for ranking, but the parameter S is not independently justified or externally benchmarked in this paper.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SuperLocalMemory 4.0: The Governed Memory Operating System for AI Agents." pith.science (2026). https://pith.science/paper/RYIC7ZA3

@misc{pith2026260808253,
  author       = {Pith},
  title        = {Pith review of: SuperLocalMemory 4.0: The Governed Memory Operating System for AI Agents},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RYIC7ZA3}},
  note         = {Machine review of arXiv:2608.08253}
}

read the original abstract

AI agents are becoming shared infrastructure, yet durable memory is commonly assembled from separate retrieval, governance, and operational components. We present SuperLocalMemory 4.0, a governed, local-first memory operating system for AI agents. The system combines dense semantic, BM25 lexical, temporal, Hopfield-associative, and spreading-activation retrieval through reciprocal-rank fusion; a governed learning and behaviour layer; bi-temporal recall; multi-scope personal, shared, and global memory; role-based access control; GDPR-oriented export and verified erasure; audit trails; and a deployment-context EU AI Act checklist. V4 introduces a reliability spine for its primary write path: generation-fenced admission, a policy registry, verifiable memory transactions with per-projection apply, verify, compensate, and erase owners, and hash-checkable completion manifests. The runtime is available through CLI, MCP, an HTTP daemon, a dashboard, editor integration, and framework adapters, and supports fully local, local-with-on-device-model, and provider-assisted modes. We evaluate eleven fault-injection and mechanism scenarios, each repeated 200 times. The released evidence bundle reports 2,200 of 2,200 deterministic repetitions upholding their scoped component properties. The governed write envelope measured 3.522 ms at p50 and 5.297 ms at p99, versus 1.835 ms and 2.569 ms for the ungoverned baseline, corresponding to in-process control-plane overheads of 1.687 ms at p50 and 2.728 ms at p99. These are scoped component and mechanism measurements, not an end-to-end multi-process or external retrieval-accuracy benchmark. The paper consolidates prior SuperLocalMemory work on privacy-preserving multi-agent memory, information-geometric retrieval, and the V3.3 Living Brain lifecycle.

Figures

Figures reproduced from arXiv: 2608.08253 by the authors.

**Figure 2.** Governed skill evolution pipeline in SLM 4.0 4.0. Three trigger conditions (post-session Stop hook; degradation scan; health-check scan) initiate evaluation within a hard budget envelope. Five guarded stages run sequentially: anti-loop screening, confirmation by the configured/lowestcost model, mutation by the configured model, blind verification (information-isolated; the verifier cannot see the generator’s ration… view at source ↗

**Figure 3.** SLM 4.0 system context. The HTTP / internal-ingestion write path reaches the [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗

Figures from the paper (11 more)

**Figure 4.** Figure 4: V4 transaction and policy spine. Transport surfaces reach the Admission Gateway; [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]

**Figure 5.** Figure 5: shows the admission and fence protocol for a canonical /remember call. 1. HTTP /remember: authenticate + RBAC WRITE 2. Deterministic request validation 3. Trust hook evaluation 4. Derive immutable ActorContext + evaluate operation policy 5. Build RememberRequest assign…

**Figure 6.** Figure 6: RBAC decision flow in OperationPolicyRegistry.evaluate(). Kind resolution and the mode-dependent unknown-kind decision precede explicit deny and policy lookup. A registered policy with no required roles denies all actors. Authentication is tested before role authorizat…

**Figure 7.** Figure 7: Profile generation fence (exp7). The fence is a process-local, TTL-bounded map [PITH_FULL_IMAGE:figures/full_fig_p017_7.png]

**Figure 8.** Figure 8: shows the transaction spine [PITH_FULL_IMAGE:figures/full_fig_p018_8.png]

**Figure 9.** Figure 9: Completion-manifest state derivation. A reconcile cycle recomputes exactly one output from canonical presence and the current obligation set: FAILED when the canonical commit is absent or the set is empty, COMPLETE when every obligation is terminal-success (VERIFIED or…

**Figure 10.** Figure 10: shows the mesh topology. Scope: cross-machine features are opt-in; WAN-scale operation, per-device revocation, and fault-injection at scale are future work. SLM-Mesh provides leaderless LWW convergence with fencing-token advisory locking—not linearizable consensus, no…

**Figure 11.** Figure 11: Failure-class taxonomy from Section 10: the ten measured guarantees grouped into five categories that map to SLM 4.0’s five technical areas. Governance & Isolation covers projection-store erasure completeness (exp1), cross-tenant zero-leak with positive control (exp5)…

**Figure 12.** Figure 12: Mixed remember/recall throughput versus concurrency on a [PITH_FULL_IMAGE:figures/full_fig_p028_12.png]

**Figure 13.** Figure 13: Operation-latency percentiles over n=300 warm operations on a 1,232 MB store (Mode B; log scale). Recall latency uses the in-process sentence-transformers provider (nomic-ai/nomic-embed-text-v1.5); the write path without embedding (store-fast) is 42.0 ms at the median…

**Figure 14.** Figure 14: Process resident-set size over 60 s of sustained mixed load on a 1,232 MB store. [PITH_FULL_IMAGE:figures/full_fig_p028_14.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

31 extracted references · 19 canonical work pages

[1]

Chhikara, D

P. Chhikara, D. Khant, S. Aryan, T. Singh, and D. Yadav. Mem0: Building Production- Ready AI Agents with Scalable Long-Term Memory, 2025. arXiv:2504.19413

arXiv 2025
[2]

MemTxn: A Transaction Boundary for Source-Supported Updates and Complete-State Recovery in Agent Memory

H. Cui et al. MemTxn: A Transaction Boundary for Source-Supported Updates and Complete-State Recovery in Agent Memory, 2026. arXiv:2607.27834. 33

work page Pith review arXiv 2026
[3]

Fang et al

J. Fang et al. LightMem: Lightweight and Efficient Memory-Augmented Generation, 2026. ICLR 2026. arXiv:2510.18866

arXiv 2026
[4]

RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search

Jianyang Gao and Cheng Long. RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search. InProc. ACM SIGMOD International Conference on Management of Data, 2024

work page 2024
[5]

B. J. Gutiérrez, Y. Shu, Y. Gu, M. Yasunaga, and Y. Su. HippoRAG: Neurobiolog- ically Inspired Long-Term Memory for Large Language Models, 2024. NeurIPS 2024. arXiv:2405.14831

arXiv 2024
[6]

B. J. Gutiérrez, Y. Shu, W. Qi, S. Zhou, and Y. Su. From RAG to Memory: Non- Parametric Continual Learning for Large Language Models (HippoRAG 2), 2025. ICML

work page 2025
[7]

Polar- Quant: Quantizing KV Caches with Polar Transformation, 2025

Insu Han, Praneeth Kacham, Amin Karbasi, Vahab Mirrokni, and Amir Zandieh. Polar- Quant: Quantizing KV Caches with Polar Transformation, 2025

work page 2025
[8]

MemoryArena: Benchmarking Agent Memory in Interdependent Multi- Session Agentic Tasks, 2026

Zexue He et al. MemoryArena: Benchmarking Agent Memory in Interdependent Multi- Session Agentic Tasks, 2026

work page 2026

Show all 31 references

[9]

J. Kang, M. Ji, Z. Zhao, and T. Bai. Memory OS of AI Agent, 2025. arXiv:2506.06326

2025 arXiv
[10]

Letta.https://github.com/letta-ai/letta

Letta AI. Letta.https://github.com/letta-ai/letta
[11]

Li et al

X. Li et al. MemTX: Transactional Belief Commit for Stateful Agent Memory, 2026. arXiv:2607.23929

2026 arXiv
[12]

Li et al

Z. Li et al. MemOS: A Memory OS for AI System, 2025. arXiv:2507.03724

2025 arXiv
[13]

Maharana et al

A. Maharana et al. Evaluating Very Long-Term Conversational Memory of LLM Agents,
[14]

R. C. Malo and T. Qiu. PROJECTMEM: A Local-First, Event-Sourced Memory and Judgment Layer for AI Coding Agents, 2026. arXiv:2606.12329

2026 arXiv
[15]

Margalit, N

Y. Margalit, N. Cohen-Inger, E. Avram, R. Taig, and O. Margalit. Governed Shared Memory for Multi-Agent LLM Systems (the MemClaw service and the ArgusFleet governance harness), 2026. arXiv:2606.24535

2026 arXiv
[16]

Introducing the token-efficient memory algorithm

Mem0. Introducing the token-efficient memory algorithm. https://mem0.ai/blog/ mem0-the-token-efficient-memory-algorithm, 2026. Vendor technical report describ- ing single-pass extraction, entity linking, multi-signal retrieval, and vendor-reported April 2026 benchmark results;...

2026
[17]

Mem0 (incl

Mem0 AI. Mem0 (incl. the OpenMemory local MCP server).https://github.com/mem0ai/ mem0
[18]

Packer et al

C. Packer et al. MemGPT: Towards LLMs as Operating Systems, 2023. arXiv:2310.08560

2023 arXiv
[19]

V. Pratap. SuperLocalMemory: Trust and Behavioral Foundations for Privacy-Preserving Agent Memory (v2), 2026. arXiv:2603.02240

2026
[20]

V. Pratap. SuperLocalMemory V3.3: The Living Brain, 2026. arXiv:2604.04514. Harvard ADS: 2026arXiv260404514P

2026 arXiv
[21]

V. Pratap. SuperLocalMemory (v3), 2026. arXiv:2603.14588. 34

2026
[22]

Rasmussen, P

P. Rasmussen, P. Paliychuk, T. Beauvais, J. Ryan, and D. Chalef. Zep: A Temporal Knowledge Graph Architecture for Agent Memory, 2025. arXiv:2501.13956

2025 arXiv
[23]

Supermemory — memory API for the AI era (container-tag multi-tenancy; SOC 2 Type 2 / HIPAA / GDPR; Docker self-host).https://supermemory.ai, 2026

Supermemory. Supermemory — memory API for the AI era (container-tag multi-tenancy; SOC 2 Type 2 / HIPAA / GDPR; Docker self-host).https://supermemory.ai, 2026

2026
[24]

H. Taheri. Governed Memory: A Production Architecture for Multi-Agent Workflows, 2026. arXiv:2603.17787

2026
[25]

Wang and X

Y. Wang and X. Chen. MIRIX: Multi-Agent Memory System for LLM-Based Agents, 2025. arXiv:2507.07957

2025 arXiv
[26]

Wu et al

D. Wu et al. LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory, 2025. ICLR 2025. arXiv:2410.10813

2025 arXiv
[27]

Yang et al

N. Yang et al. SF-AMS: Strategic Forgetting for Structured Memory in LLM Agents, 2026. arXiv:2607.22562

2026 arXiv
[28]

QJL: 1-Bit Quantized JL Transform for KV Cache Quantization with Zero Overhead, 2024

Amir Zandieh, Majid Daliri, and Insu Han. QJL: 1-Bit Quantized JL Transform for KV Cache Quantization with Zero Overhead, 2024

2024
[29]

TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate, 2025

Amir Zandieh, Majid Daliri, Majid Hadian, and Vahab Mirrokni. TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate, 2025

2025
[30]

Graphiti.https://github.com/getzep/graphiti

Zep AI. Graphiti.https://github.com/getzep/graphiti
[31]

Zhang et al

J. Zhang et al. Beyond Similarity: Trustworthy Memory Search for Personal AI Agents (MemGate), 2026. arXiv:2606.06054. 35

2026 arXiv

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.

[1] [1]

Chhikara, D

P. Chhikara, D. Khant, S. Aryan, T. Singh, and D. Yadav. Mem0: Building Production- Ready AI Agents with Scalable Long-Term Memory, 2025. arXiv:2504.19413

arXiv 2025

[2] [2]

MemTxn: A Transaction Boundary for Source-Supported Updates and Complete-State Recovery in Agent Memory

H. Cui et al. MemTxn: A Transaction Boundary for Source-Supported Updates and Complete-State Recovery in Agent Memory, 2026. arXiv:2607.27834. 33

work page Pith review arXiv 2026

[3] [3]

Fang et al

J. Fang et al. LightMem: Lightweight and Efficient Memory-Augmented Generation, 2026. ICLR 2026. arXiv:2510.18866

arXiv 2026

[4] [4]

RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search

Jianyang Gao and Cheng Long. RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search. InProc. ACM SIGMOD International Conference on Management of Data, 2024

work page 2024

[5] [5]

B. J. Gutiérrez, Y. Shu, Y. Gu, M. Yasunaga, and Y. Su. HippoRAG: Neurobiolog- ically Inspired Long-Term Memory for Large Language Models, 2024. NeurIPS 2024. arXiv:2405.14831

arXiv 2024

[6] [6]

B. J. Gutiérrez, Y. Shu, W. Qi, S. Zhou, and Y. Su. From RAG to Memory: Non- Parametric Continual Learning for Large Language Models (HippoRAG 2), 2025. ICML

work page 2025

[7] [7]

Polar- Quant: Quantizing KV Caches with Polar Transformation, 2025

Insu Han, Praneeth Kacham, Amin Karbasi, Vahab Mirrokni, and Amir Zandieh. Polar- Quant: Quantizing KV Caches with Polar Transformation, 2025

work page 2025

[8] [8]

MemoryArena: Benchmarking Agent Memory in Interdependent Multi- Session Agentic Tasks, 2026

Zexue He et al. MemoryArena: Benchmarking Agent Memory in Interdependent Multi- Session Agentic Tasks, 2026

work page 2026