v0.2 · research preview · Browser-first · Rust-native

Memory for AI agents,
measured in tokens.

Smriti is a memory engine, not a memory model. The LLM is your agent's reasoning layer, not Smriti's. Replace your LLM, the engine is unchanged. Replace your vector store with Smriti, your agent gains confidence verdicts, causal trajectory replay, salience-aware decay, and federated sync — primitives no vector store can offer.

Built for

Memory that has to be private, portable, and cognitive enough to abstain when it doesn't know. The same Rust core runs in the browser, on edge servers, and on small devices — no embedding model required.

91.7% abstention on adversarial queries 127 KB WASM Zero-ML default · embeddings optional Open SMRP/1.0 protocol
Install Smriti Try the live demo →
smriti recall "what is the auth approach?"
budget 500 tokens
✓ The auth module uses JWT RS256 with 1-hour expiry Confident
✓ Authentication uses public/private key pairs over TLS 1.3 verdict
2 hits · 79 tokens used / 500 budget · verdict: Confident
0%
Intrinsic recall (zero-ML, 500 mems)
0%
Token budget saved per query
0%
Adversarial abstention rate
0
ML models required
Why Smriti

Core design principles of the Smriti engine.

01

Zero ML dependencies

Most memory engines require a dense embedding model. Smriti doesn't. Our HDC binary hypervectors run at billions of XOR/popcount ops per second. No GPU, no model download, no inference latency.

02

Two stores, like the brain

The hippocampus learns fast and forgets. The neocortex consolidates slowly and remembers. McClelland's 1995 dual-system theory has been quoted in 12,000 papers. Smriti finally brings this cognitive architecture to production.

03

Algebra, not search

Bind two concepts with XOR. Bundle 50 facts into one 256-byte hypervector. Recover any of them with deconvolution. This is composition, not lookup. Our moat is mathematical.

04

Open wire protocol

Instead of proprietary APIs, Smriti speaks SMRP/1.0, a simple line-oriented spec anyone can implement. We believe in open standards over vendor lock-in.

05

Token efficiency, by design

Memory should be inexpensive. By utilizing zero-ML retrieval and rigorous token budgeting, Smriti reduces LLM context window costs dramatically without sacrificing retrieval accuracy.

06

One binary, runs anywhere

Native Linux/macOS/Windows. WASM-ready architecture for the browser. SQLite single-file persistence. No Docker required. No Postgres required. Smriti is a 5 MB file that does memory.

Benchmark

What Smriti measures, on real corpora.

All numbers below are reproducible from a clean clone with one cargo command. Methodology and per-category breakdowns live in benchmarks/results/REAL_DATASETS_REPORT.md.

bench-500 · 500 memories, 47 + 12 abstain queries

Metric Zero-ML + fastembed (optional)
Intrinsic Hit % (engine retrieved gold) 95.7% 95.7%
Top-1 % (gold ranked #1) 63.8% 70.2%
Shipped Hit % (after Confident=2 truncation) 78.7% 89.4%
Adversarial abstention (12 queries with no gold) 91.7% 91.7%
Avg tokens / 500 budget 79 81
Recall p95 latency 1.6 ms 3.7 ms

Reproduce: cargo run --release --bin smriti-bench-500 (zero-ML) or SMRITI_BENCH_EMBEDDINGS=1 cargo run --release --bin smriti-bench-500 --features embeddings (with embeddings).

Public benchmarks · LLM-as-judge (Llama-3.3-70B)

Dataset / category Substring eval LLM judge
LongMemEval-S · single-session-user (n=8) 100.0% 100.0%
LongMemEval-S · knowledge-update (validates supersedes) 62.5% 62.5%
LongMemEval-S · stratified across 6 categories (n=48) 50.0% 47.9%
LOCOMO · mixed categories (n=80) 2.5% 21.9%

The LOCOMO substring 2.5% → judge 21.9% (+19.4pp lift) confirms Smriti retrieves real signal that string matchers cannot credit. Datasets: xiaowu0162/longmemeval-cleaned (HuggingFace), snap-research/locomo (GitHub). Judge harness: benchmarks/judge_results.py. Methodology, per-entry verdicts, and reasons in benchmarks/results/REAL_DATASETS_REPORT.md.

Capabilities a vector store cannot offer

Capability Vector store Smriti
Confidence verdicts (Confident / Ambiguous / Abstained) — ✅ 91.7% adversarial abstention
Causal trajectory replay (typed-edge BFS) — ✅ recall_trajectory()
Salience-aware decay bypass (auto-PPR-seed) — ✅ Salience::Critical
Goal-pinned persistent priming — ✅ MemoryKind::Goal
Supersede chains with audit trail re-embed (history lost) ✅ chain preserved, recall hides old
Federated sync (LWW, P2P) server-coupled ✅ export_sync_state / import_sync_state
WASM / browser deployment — ✅ 127 KB gzipped
Zero-ML mode — ✅ 95.7% intrinsic hit, no embeddings

A head-to-head LLM-judged comparison against Mem0, Letta, and Zep on LongMemEval and LOCOMO is on the v0.3 roadmap — the harness already runs against any system that exposes (corpus, query) → context.

Science

The six papers we built on.

1885
Forgetting Curves
Ebbinghaus
Memory traces decay exponentially. We use per-kind half-lives: events fade in 14 days, decisions in a year.
1988
Sparse Distributed Memory
Kanerva
High-dimensional binary vectors are nearly orthogonal by accident. The math behind our HDC layer.
1995
Complementary Learning Systems
McClelland, McNaughton, O'Reilly
Hippocampus + Neocortex. Fast learning + slow consolidation. We literally implemented their architecture.
1995
Holographic Reduced Representations
Plate
Bind, bundle, permute. Our compositional memory operations come straight from VSA theory.
1978
Minimum Description Length
Rissanen
The optimal store minimizes length(store) + length(input given store). Our predictive coding filter.
2005
Free Energy Principle
Friston
Only store prediction errors. If your existing memory predicts the new input, don't store it. Information theory at work.
Live Demo

Try Smriti right now — in your browser, on your data.

This is the real Rust engine, compiled to a 127 KB gzipped WebAssembly module and running entirely in your browser tab. No backend, no embedding model, no network call after the first load. The same binary ships natively at 95.7% intrinsic recall on bench-500.

🔒 Your data never leaves this tab. Every visitor runs their own private WASM instance — we cannot see what you type, even if we wanted to. There is no shared store, no server-side session, no telemetry on the demo. Hit Reset any time to wipe this tab's memories.

$ smriti remember "Bob is the lead engineer"
$ smriti recall "who leads engineering?"
Click Remember/Recall above to see Smriti at work.
0 memories stored · 0 recalls run · 0% avg token efficiency
Capabilities

Cognitive primitives, not just search.

Everything listed here works without an LLM in the loop. Smriti performs the graph algebra natively, keeping your agent fast and deterministic.

01

Confidence Verdicts

Smriti knows when it doesn't know. It returns a verdict (Confident, Ambiguous, Unsupported, Abstained). In our benchmarks, it correctly abstains on 91.7% of adversarial queries instead of hallucinating nearest-neighbors.

match verdict {
    Confident => hit,
    Abstained => "I don't know",
}
02

Causal Trajectory Replay

Memories aren't isolated. They are connected by typed edges (CausedBy, Before, Supersedes). You can reconstruct episodic narratives exactly as they unfolded via graph traversal.

smriti.recall_trajectory(id, Causal)
03

Salience & Decay Bypass

Not all memories are equal. Trivial facts decay exponentially. Memories marked as Critical bypass decay and act as permanent PageRank seeds, keeping related context warm.

memory.salience(Salience::Critical)
04

Goal-Pinned Priming

Memory isn't just past events. By storing a MemoryKind::Goal, the engine actively routes spreading activation towards nodes that help satisfy the agent's current objective.

smriti.remember("Fix bug").kind(Goal)
05

Contradiction & Supersede

When facts change, the old memory isn't deleted—it's gracefully superseded. The contradiction is preserved in the graph as an audit trail, but standard recall only surfaces the live truth.

smriti.supersede(old_id, "Use OAuth2")
06

Predictive Coding (MDL)

If your existing memory already predicts the new input, Smriti refuses to store it. This Friston-style surprise filter prevents redundancy and keeps the graph dense and fast.

// Filtered if redundant
smriti.consolidate()
MCP

Native memory for Claude Code, Cursor, Zed.

Smriti speaks the Model Context Protocol natively. Drop the server into your agent's MCP config and the engine's primitives become first-class tools. No wrapper, no glue code, no embedding pipeline.

One-line config

// ~/.config/claude-code/mcp.json
{
  "smriti": {
    "command": "smriti-http",
    "args": ["--mcp", "--db", "~/.smriti/global.db"]
  }
}

Restart your agent. smriti_* tools appear in the tool palette immediately.

13 tools, all deterministic

  • smriti_remember — store with attributes + tags
  • smriti_recall — verdict + confidence-graded pack
  • smriti_supersede — graceful contradiction
  • smriti_reconsolidate — usage-driven plasticity
  • smriti_link — typed edges (CausedBy / Before / …)
  • smriti_recall_trajectory — narrative replay
  • smriti_clear_activation — topic-switch reset
  • smriti_suggest_clusters + smriti_merge — sleep summarization
  • smriti_consolidate, smriti_vacuum, smriti_stats, smriti_forget

None require an LLM. The agent provides structured input; Smriti does the graph algebra.

Explore all capabilities ↑
Install

Get started in 60 seconds.

1

Install

cargo install smriti --features http
2

Remember something

smriti remember "JWT RS256 with 1h expiry" \
  --tags auth,security \
  --kind fact
3

Recall it

smriti recall "how does auth work" \
  --budget 500
Star on GitHub View Capabilities →