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

macOS · Linux · Windows single binary, zero dependencies desktop clients available

recall — live, in your browser

0 network requests

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:

1 recall hit 3–5 grep / find / read turns skipped your full 100k–400k-token context, not re-sent
In long coding sessions every extra tool turn re-sends the whole active context as billed input tokens. Eliminating one blind round-trip saves one full re-read; a missed recall costs a turn instead. The arithmetic, the falsification protocol and our 7-day usage ledger are all public.

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.

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 results
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?

  1. Install

    $ curl -fsSL https://github.com/rocareer/rolling-memory/raw/main/install.sh | bash
    PS> irm https://github.com/rocareer/rolling-memory/raw/main/install.ps1 | iex

    SHA-256-verified prebuilt binaries; no Git, Go, Node or Python required. Prefer no terminal at all? There are macOS .dmg and Windows desktop clients.

  2. Let it wire your agents

    The installer detects your coding assistants and connects them to one shared vault.

    Claude CodeCodexZCodeCodeBuddydshCursorWindsurfClineany MCP host

  3. 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.