SuperLocalMemory V2 - Local AI Memory for Agents

TL;DR

TL;DR: SuperLocalMemory V2 is an AGPL-3.0 local-first AI memory system that achieves 74.8% on the LoCoMo benchmark without any cloud dependency — outperforming Mem0’s zero-LLM baseline by 10.6 percentage points. It wraps Claude, Cursor, and 14 other coding agents in seconds via a proxy, MCP, or skill surface.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: superlocalmemoryv2.com
• Source repository: github.com/varun369/SuperLocalMemoryV2
• License: AGPL-3.0 (verified via GitHub API license.spdx_id)
• HN launch thread: news.ycombinator.com/item?id=46926968 (Feb 2026)
• Benchmarks: arXiv:2603.14588 (LoCoMo evaluation, Apr 2026)
• Source last checked: 2026-06-29 (commit varun369/SuperLocalMemoryV2, version v3.6.18)

What Is SuperLocalMemory?

Every hosted AI memory platform — Mem0, Zep, Letta, EverMemOS — sends your conversation data to cloud LLMs by default. After August 2, 2026, those cloud paths become a compliance question under the EU AI Act.

SuperLocalMemory V2 takes a different approach: it uses differential geometry, algebraic topology, and stochastic analysis instead of cloud compute. The result is a memory system that runs entirely on your machine, requires no API keys, and still outperforms hosted alternatives on the zero-LLM retrieval benchmark.

The tool publishes three research papers on arXiv (2603.02240, 2603.14588, 2604.04514) and supports three integration surfaces so it works regardless of how your agent is configured.

Benchmark Results

Evaluated on LoCoMo, the standard long-conversation memory benchmark (April 2026 publication):

| System | Score | Config | Cloud LLM required? | Open Source | |:-------|:-----:|:-------|:-------------------:|:-----------:| | EverMemOS Cloud | 93.05% | Cloud (proprietary) | Yes | Core only | | Hindsight (LoCoMo10) | 92.0% | Cloud | Yes | No | | Mem0 (token-efficient) | 91.6% | Hybrid (Cohere/OpenAI) | Yes | Partial | | SLM V2 Mode C | 87.7% | Local + optional LLM | Optional | Yes (AGPL-3.0) | | Zep v3 Cloud | 85.2% | Cloud | Yes | Community deprecated | | SLM V2 Mode A | 74.8% | CPU-only, zero-LLM | No | Yes (AGPL-3.0) | | Mem0 (zero-retrieval-LLM) | 64.2% | Local baseline | No | Partial |

Important caveat from the README: Scores from different papers use different LoCoMo splits, judge models, and prompt variants. The only apples-to-apples comparison is Mode A 74.8% versus Mem0 zero-retrieval-LLM 64.2% (+10.6pp) — both are zero-LLM configurations. Mem0’s 91.6% and EverMemOS’s 93.05% both use cloud LLMs.

Mode A delivers a +12.7 percentage point average improvement from its mathematical compression layers across 6 conversations (n=832 questions), with gains up to +19.9pp on the most challenging dialogues.

Three Integration Surfaces

SuperLocalMemory V2 exposes memory through three interfaces:

1. Proxy — slm wrap claude starts a local proxy and sets environment variables, then launches the agent. Every subsequent prompt checked against the local cache first.
2. MCP tools — add slm_compress to your MCP config to expose memory as tools. Works with any MCP-native agent.
3. Skill — zero-config skill for agents that support custom skills.

Setup Workflow

Step 1: Install

# npm (recommended)
npm install -g superlocalmemory

# pip
pip install superlocalmemory

Step 2: Configure

slm setup       # Choose mode: A (CPU-only), B (local LLM), or C (local + optional cloud)
slm doctor      # Verify the setup is working

Step 3: Choose a Mode

• Mode A (CPU-only) — SQLite storage, zero cloud calls, zero API keys. Best for privacy-sensitive work and offline use. Scores 74.8% on LoCoMo.
• Mode B (local LLM) — Adds an optional local LLM (Ollama) for richer semantic compression. Achieves higher recall on complex multi-turn conversations.
• Mode C (local + optional cloud) — Same configuration as Mode B but can optionally delegate to a cloud LLM when local resources are insufficient. Achieves 87.7% on LoCoMo.

Step 4: Wrap Your Agent

# Wrap Claude — your first repeat prompt is a CACHE HIT and costs $0.00
slm wrap claude

# Wrap Cursor
slm wrap cursor

# Check savings
slm optimize savings --since 1

Practical Evaluation Checklist

What it does well:

• Zero cloud dependency in all modes — no data leaves your machine
• No Docker, no graph DB, no separate server process required
• Works across 16+ coding agents including Claude Code, Kiro, Cursor, Windsurf, Continue.dev, Cline, and others
• EU AI Act design-compliant out of the box
• Mathematical compression layers provide measurable token savings

What to verify for your stack:

• Which specific agent versions are supported — the README lists 16 agents but exact version compatibility should be checked before committing to Mode B or C
• Mode B and C require Ollama to be installed for the local LLM option — confirm your hardware supports it
• Multi-repository memory across 17+ coding agents works via gortex integration — if you use a different agent, the skill surface may be the only integration path

Known limitations:

• Mode A’s CPU-only approach trades some recall accuracy for privacy and speed — at 74.8% on LoCoMo it beats Mem0’s zero-LLM baseline but sits below cloud-LLM systems
• The AGPL-3.0 license has copyleft implications if you modify the code and distribute it — evaluate for commercial use cases
• Memory is local to the machine — no built-in sync across machines without additional configuration

Security Notes

• No telemetry by default — the README explicitly states telemetry is off unless you configure an endpoint
• DO_NOT_TRACK environment variable is respected
• All memory stored in local SQLite (Mode A) or local database with optional Ollama — no third-party data transmission
• EU AI Act design compliance documented — relevant if you operate in EU-regulated environments

FAQ

Q: Does this work with Claude Code directly? A: Yes. Use slm wrap claude to start a proxy that intercepts prompts and checks the local memory cache. The first repeat prompt costs $0.00 because it hits the cache.

Q: How is this different from Mem0? A: SuperLocalMemory V2 uses mathematical compression (differential geometry and algebraic topology) instead of cloud LLM retrieval. In the zero-LLM configuration (Mode A), it scores 74.8% on LoCoMo versus Mem0’s 64.2% — a 10.6 percentage point advantage. Mem0’s higher scores require cloud LLM calls.

Q: What hardware is required? A: Mode A runs on CPU-only with SQLite — any machine that runs Node.js or Python is sufficient. Mode B and C optionally use Ollama for local LLM inference, which benefits from a GPU but is not required.

Q: Can I use this with a self-hosted LLM? A: Yes, Mode C supports Ollama as a local LLM backend. This keeps all data local while still allowing the agent to use a local model for memory operations.

Q: Is the EU AI Act compliance real? A: The README documents it as a “design compliance” claim. It means the architecture avoids cloud LLM calls in Mode A, which sidesteps certain EU AI Act data-processing requirements. For regulatory certainty in your specific context, consult the full text of the regulation and, if needed, a legal advisor.

Conclusion

SuperLocalMemory V2 is a locally-first, mathematically-grounded memory layer for AI coding agents. Its Mode A configuration — CPU-only, zero cloud, AGPL-3.0 — is the most differentiated claim: it beats Mem0’s zero-LLM baseline by 10.6 percentage points on the LoCoMo benchmark while keeping all data on your machine.

If you use Claude, Cursor, or any of the 14 other supported coding agents and want persistent conversation memory without a cloud dependency, slm wrap takes under a minute to set up. Mode A requires no API keys, no GPU, and no cloud account.

The research-backed approach (three arXiv preprints) and active development (v3.6.18 as of June 2026) suggest this is a substantive project rather than a weekend prototype. Evaluate it against your privacy requirements and agent stack before committing.