Your memory belongs to you.
It stays in your hands.
Open source. Free.
Free for every noncommercial use — commercial licensing is separate. Every line of source is public: audit it, modify it, share it.
Local-first memory for AI coding agents: conversations and mounted files recorded
verbatim in a SQLite vault on your machine, served to every agent through one MCP
tool — recall. No cloud, no vectors, no background LLM calls.
$ curl -fsSL https://github.com/rocareer/rolling-memory/raw/main/install.sh | bash
recall — live, in your browser
These 8 sample records are built into the page, scored with a miniature of the real engine’s lexical statistics — rarity-weighted words, no semantic model. Installed, it searches your actual history, fully offline.
True zero: where does the saving come from?
Free to install is the easy part — the point is that using it costs nothing too. There is no LLM reading your context to extract “facts”, no embedding API metering every sentence, no subscription. And each recall hit saves real money:
Our own most recent audited 24 hours: 33 deduplicated turn-review cards — 6 honestly reported zero saved turns, while 27 pinpointed exact coordinates or past fixes and saved 116 blind-search turns, about 4.3 per hit.
Read the turn-elimination math and the 7-day dogfooding report
What does “zero egress” actually mean?
- Zero requests, by construction
- Saving and searching both run on your CPU. No cloud index, no telemetry, no “anonymous statistics”. Pull the network cable — everything still works.
- One binary, one file
- A zero-dependency single binary plus one SQLite vault file. An attack surface small enough to audit line by line; a backup is a file copy.
- Verbatim, on your disk
- Conversations and code stay as plaintext you own — directory 0700, files 0600. Nobody but you and the agent working for you can read them.
- Yours to carry
- The vault is a file. Back it up, move it, or run the whole tool from a USB drive.
One precise boundary: if your agent talks to a remote LLM API, the passages recall returns travel to that provider inside your prompt — that part is your agent, not us.
Why verbatim records and lexical search — not summaries and vectors?
If your agent can misread context, so can the model summarizing it. Rewriting a possibly-misread conversation with a possibly-hallucinating model is error compounding — and once the original is discarded, the truth is gone for good.
What we store
2026-03-05 09:47 — decided against approach A (polling) for sync; chose WebSocket push because polling burned 3% CPU at idle. Fallback interval stays 30s in sync/config.go:71.
What a summary keeps
“The team chose WebSockets for synchronization.”
— the reason, the CPU number, the fallback value and the file coordinate are gone.
History happened as it happened. We never rewrite, compress, or “polish” a record.
The write tax doesn’t pay either. Summarizing at save time means paying a model to read your whole context on every write, to save a few hundred tokens at read time. Your coding agent already reads well — and it knows the question being asked, which the summarizer never did. We do zero-cost format cleanup and hand it the original.
And in engineering, the facts live in the literal words. Dense vectors smooth text
into a space where err_code_4012 and err_code_4013 are
nearly the same point — above 0.98 cosine. To a lexical index they are simply two
different words. Codenames, ports, version tags, dates, paths: exact anchors are
what coding lookups are made of.
Quality and speed, measured — not promised
Latest local recompute (2026-11-16) on the same retrieval kernel: ATM-Bench (11,034 records) and LoCoMo (1,540 questions), with same-protocol public baselines listed for context.
| Benchmark | Rolling Memory | Published baselines, same protocol |
|---|---|---|
| ATM-Bench Main · official Recall@10 | 82.56% | MemPalace 76.40 · ATM-RAG 68.70 · HippoRAG2 66.40 · Mem0 61.90 |
| ATM-Bench Hard · official Recall@10 | 50.35% | MemoryOS 32.70 · HippoRAG2 31.90 · ATM-RAG 30.40 · Mem0 23.70 |
| LoCoMo · end-to-end judge accuracy | 85.26% | 1,540 questions, full set |
| Retrieval latency, warm cache | 29–42 ms mean | P95 49.7–86.5 ms per query — on CPU, across 11,034 records |
- These are local recomputations under the standard SGM text protocol; an official leaderboard PR has been submitted.
- About one in six Main questions still has no gold evidence in the top 10 — mostly casual speech with zero lexical overlap (nicknames, dropped subjects). Coding sessions, with their consistent symbols and paths, are exactly where lexical statistics shine.
How do I start?
-
Install
$ curl -fsSL https://github.com/rocareer/rolling-memory/raw/main/install.sh | bashPS> irm https://github.com/rocareer/rolling-memory/raw/main/install.ps1 | iexSHA-256-verified prebuilt binaries; no Git, Go, Node or Python required. Prefer no terminal at all? There are macOS .dmg and Windows desktop clients.
-
Let it wire your agents
The installer detects your coding assistants and connects them to one shared vault.
Claude CodeCodexZCodeCodeBuddydshCursorWindsurfClineany MCP host
-
Just chat
Work normally. Whenever you need the past, ask things like “Where did we fix that bug last time?” — your agent calls recall and gets the verbatim record with its coordinates.
Team sharing — without handing over your text?
Local mode is complete on its own. The cloud engine exists for teams: several machines sharing one memory, on an engine built so that it cannot read what you wrote.
Before anything leaves your machine, each sentence is ground into an irreversible fingerprint of integers. The cloud compares fingerprints and returns record IDs — it holds the fingerprint, never the hand. Your text is never uploaded; the originals stay in your local vault and your own client restores them.
Preview access is by application: pick@psychologylake.org.cn
Who builds this?
Rolling Memory is built on the Rolling Autonoetic Memory Engine by the Psychology Lake team. Behind the tool is a seven-volume research series in preparation — on fidelity-first memory, lexical self-explanation, directed explanation algebra, epistemic tri-states, subword topology, and zero-plaintext commitment retrieval.
Our goal is plain: long-term memory for agents should work like local files — a basic utility anyone can run, without a credit card or a pipeline quietly burning tokens in the background.