How a local-first system with mathematical foundations scores 74.8% on LoCoMo — higher than Mem0 — without a single cloud API call.
The Setup
I've spent the last year building SuperLocalMemory V3 — an open-source AI agent memory system that uses information geometry instead of cloud LLMs for core operations. Before I talk about how we compare, I want to be clear: this is not a hit piece on Mem0. They've built something genuinely useful with a great team. This is a factual benchmark analysis for developers choosing an architecture.
The key question: does local-first memory with mathematical foundations perform better than cloud-hosted managed memory?
On LoCoMo (Long Conversation Memory benchmark), the answer is yes.
The Numbers
| System | LoCoMo Score | Cloud LLM Required | Cost |
|---|---|---|---|
| SLM V3 Mode C | 87.7% | Yes (synthesis only) | $0 base (your API key) |
| SLM V3 Mode A | 74.8% | No | $0 forever |
| Mem0 (self-reported) | ~66% | Yes | Subscription |
| Mem0 (independent) | ~58% | Yes | Subscription |
| SLM V3 Zero-LLM | 60.4% | No LLM at all | $0 |
The headline: SLM Mode A (local-only) scores 74.8% — higher than Mem0's best-reported 66% — with data never leaving your machine.
A note on Mem0 scores: they vary across reports. Their self-reported number is ~66%, but independent measurements are closer to 58%. We cite both. Our scores are from our paper: arXiv:2603.14588.
Why Does Local Beat Cloud Here?
Mem0's architecture is straightforward: you send memories to their cloud, they store them, you query via API. It works well for team collaboration and managed infrastructure.
The weakness is retrieval quality. Standard cloud memory systems use cosine similarity over vector embeddings. At thousands of memories, cosine similarity stops discriminating well — everything starts looking similar.
We replaced cosine similarity with three mathematical techniques:
1. Fisher-Rao Geodesic Distance
Instead of treating each memory embedding as a point, we model it as a Gaussian distribution with a mean and variance. The Fisher-Rao distance measures similarity on the curved probability manifold — not through flat Euclidean space.
The key insight: memories accessed more often become more precise (variance shrinks via Bayesian updates). So frequently-relevant memories get geometrically closer to matching queries. Cosine can't do this.
Ablation: removing Fisher-Rao drops multi-hop accuracy by 12 percentage points.
2. Sheaf Cohomology for Consistency
Pairwise contradiction checking is O(n²) and misses transitive contradictions. Sheaf cohomology computes H¹(G, F) — a global consistency measure from local checks. Algebraic, not quadratic. Catches contradictions no pairwise method can.
3. Riemannian Langevin Dynamics for Lifecycle
Instead of "archive after 30 days," we use stochastic gradient flow on the Poincaré ball. The system self-organizes lifecycle states based on actual usage patterns. No manual threshold tuning.
Architecture Differences
| Dimension | SLM Mode A | Mem0 |
|---|---|---|
| Data location | On your device | Mem0's cloud |
| Embedding | Local model (nomic-embed-text) | OpenAI API |
| Retrieval | 4-channel mathematical | Vector similarity |
| Offline | Full | None |
| API key needed | No | Yes |
| EU AI Act | Compliant by architecture | Requires DPA |
| Team memory | Single-device default | Native |
When Mem0 Is Better
Honesty matters here. Mem0 wins on:
- Team collaboration: Native multi-user shared memory. SLM is single-device by default.
- Managed infrastructure: No local model to run, no disk usage, no maintenance.
- Cross-device access: Memory follows you across devices natively.
If you're building a team-facing product where multiple users share memory, Mem0 is probably a better fit today.
When SLM Is Better
SLM wins when:
- Data sovereignty is required: EU AI Act compliance, HIPAA-adjacent data, air-gapped environments.
- Individual developer workflow: Personal coding assistant memory — Claude Code, Cursor, etc.
- Zero ongoing cost: Mode A is free forever. No API costs, no subscription.
- Offline operation: Mode A/B work with no internet connection.
- Explainable retrieval: Every retrieval decision shows 4-channel scores. No black-box LLM.
Installing Both (30 seconds each)
# SuperLocalMemory
npm install -g superlocalmemory
slm setup
slm remember "Factoring auth into shared middleware on the payments service"
slm recall "payments auth"
# Mem0 (Python)
pip install mem0ai
# Then: set OPENAI_API_KEY and call mem0.add(), mem0.search()
Conclusion
The benchmark data is clear: local-first memory with information-geometric foundations outperforms cloud-hosted vector similarity on LoCoMo — by 8+ percentage points in the direct comparison, while requiring zero cloud infrastructure.
This matters because the AI memory field is mostly converging on "use a cloud LLM for everything." We're demonstrating a different path: mathematics as the intelligence layer, cloud as an optional enhancement.
Everything is MIT licensed and open source: github.com/qualixar/superlocalmemory
Paper: arXiv:2603.14588
Varun Pratap Bhardwaj — Independent Researcher
A Qualixar Research Initiative
Top comments (0)