deja-vu: A zero-dependency memory layer that indexes the agent history you already have
Your agents already solved this. deja finds it, it indexes the sessions your coding agents already wrote to disk, months of history from before you installed it, and recalls them automatically at session start in all seventeen. 84.9% hit@1 on LongMemEval-S, no LLM, no embeddings. One zero-dep binary, fully local.
At a glance
- What is it?
- deja-vu turns the session logs that Claude Code, Codex, Cursor and other coding agents already write to disk into a searchable, MCP-served memory. It claims high recall on public benchmarks without embeddings, and it starts from your existing history rather than recording forward.
- Who is it for?
- Adopt deja-vu if you work across multiple coding agents on the same machine and want a local, zero-dependency memory that uses history you already have. Skip it if you cannot tolerate a shell-based installer on Windows, if your agent harness is not among the seventeen listed, or if you need memory that records forward from a clean state.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly Go, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 14, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem: agent memory starts empty and forgets fast
Coding agents like Claude Code, Codex, and Cursor write every conversation to local files. Those files are a record of decisions, commands, and edits. But no agent reads them by default. When a session starts, the agent has no memory of what you fixed in March. It will re-debug the same issue. deja-vu solves this by indexing those existing session logs and making them available to the agent at the moment it needs them. The intended user is a developer who works across multiple agents on the same machine and wants a shared memory layer without running a server or training embeddings. The pitch is direct: every memory tool starts empty and records forward, deja starts full.
Retroactive indexing: how deja turns old logs into searchable memory
deja-vu is a single Go binary with no dependencies. It scans the directories where agents have already written session files, including months of history from before you installed it. It builds an index locally. The README claims sub-millisecond lookups over 5 GB of history. The mechanism is not based on LLM inference or embeddings. Instead, it uses a relevance tier for natural-language questions, and exact matching for commands and file paths. The index strips keys and tokens as it is built, so what reaches the model is safe to send. The core data flow is: scan agent session files, build a local index, expose it via MCP tools and a CLI. The agent calls deja itself, nobody searches anything. Recall arrives at session start, on every prompt, before a file is edited or a command runs, and after one fails.
Installation and first run: two commands to a working index
The README gives a direct install path: `curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh` then `deja install --auto`. The second command wires MCP recall into every agent it finds, turns on session-start recall where the agent supports it, and builds the first index. The claim is that ten seconds install and about ten to index. Alternative installs exist: `brew install deja-vu`, `go install github.com/vshulcz/deja-vu/cmd/deja@latest`, or `npx @vshulcz/deja-vu "query"` to try without installing. On Windows, the shell script exits with `unsupported OS`, so you use Scoop: `scoop install deja-vu`, or download the zip and put `deja.exe` on your PATH. The binary alone is a complete install for searching: index, search, `show`, `ctx`, `blame`, `--json`, and redaction need nothing else. `deja warmup` leaves a skill at `~/.agents/skills/deja-search/SKILL.md` that teaches an agent the CLI contract, so history is searchable even without MCP.
What gets wired into your agents: MCP, guidance files, and hooks
`deja install` writes user-level guidance for the harnesses it detects. The README lists seventeen: Claude Code, Codex, opencode, Gemini CLI, Antigravity, Qwen, Kimi Code, pi, Copilot, Cursor, Goose, OpenClaw, Hermes, Roo Code, omp, DeepSeek Harness, and Zed. Each gets its own guidance file, or a skill under `~/.agents/skills` for Cursor and Grok Build. Re-running install rewrites deja's marked block without touching surrounding user content. You can opt out with `deja install --all --no-guidance`. The MCP `recall` tool answers questions like "we fixed this three weeks ago" in whichever agent asks. Session-start recall is turned on where the agent supports it, but the README notes that Cursor has no user-level instructions file, so it gets a skill read only when something looks relevant, not every session. The `PreToolUse` and `PostToolUse` hooks are the interesting part: before an agent edits a file or runs a command, deja names that file's prior decision or that command's working invocation. When a command fails, the hook answers with what followed that same error before.
The benchmarks: what the numbers claim and how to reproduce them
The README reports 85.3% hit@1 on LongMemEval-S and 69.6% on LoCoMo, with sub-millisecond lookups over 5 GB of history. Both harnesses ship in this repo and run on the public datasets in minutes. The homepage links to a benchmarks page where you can check the numbers yourself. This is a concrete claim you can verify, which is rare. The methodology matters: no LLM, no embeddings, so the hit rate comes from a deterministic index and a relevance tier. The 84.9% figure in the repository description differs slightly from the 85.3% in the README, which is a small inconsistency worth noting. If you plan to adopt deja-vu, run the harnesses on your own data. The README says they run in minutes, so there is no excuse not to verify.
Limitations and failure modes: where deja is the wrong tool
The most obvious limitation is Windows support. The install script is a shell script and exits with `unsupported OS`. You need Scoop or a manual zip download. That is a friction point for a tool that claims zero-dep simplicity. A second limitation is agent coverage. Seventeen harnesses are listed, but if you use an agent that is not on that list, you get no guidance file and no hooks. The binary-only mode still works for search, but session-start recall and pre-tool hooks are off. A third limitation is the index's dependence on the session files agents actually write. If your agent writes in a format deja does not parse, the index is incomplete. The README does not specify which formats are supported, so you need to verify that yourself. Finally, the claim about surviving compaction is measured over 43 compactions: the summary keeps 77% of decisions and 0.2% of commands, and deja hands back the other 99.8%. That is a strong claim, but it depends on the index capturing the right spans and commands. If the session files are truncated or deleted, the index loses that history.
Alternatives and how they differ
The main alternative is a memory tool that records forward, like a vector-store-based memory or a custom retrieval-augmented generation setup. Those tools start empty and build memory as you use them. deja-vu starts full because it indexes existing logs. Another alternative is no tool at all: rely on the agent's own context window and hope compaction does not lose decisions. The README's comparison page exists but the material does not detail it. The difference in approach is fundamental: deja-vu is retroactive and deterministic, while embedding-based memory is forward-looking and approximate. deja-vu has no LLM in the loop, so no token cost for indexing, and no embedding model to maintain. The trade-off is that deja-vu cannot generalize beyond what is in the logs; it only recalls exact or tiered matches. An embedding-based system might find semantically related solutions that deja-vu misses. If you need semantic similarity rather than exact recall, deja-vu is the wrong tool.
Maintenance, license, and upgrade cost
The project is MIT licensed, which means you can use, modify, and redistribute it freely, with attribution. The repository is not archived, and the last push is recent, with a nightly release and v0.19.1. The maintenance cost is low: a single Go binary, no external services, no model updates. Upgrades are handled by re-running the install script or using your package manager. The README does not mention a migration path for the index between versions, but the nightly release suggests active development. The `deja install` command rewrites only its own marked block in guidance files, so upgrades do not clobber your custom agent instructions. The binary-only setup has no upgrade path beyond replacing the binary, which is simple. The main cost is the initial indexing time and the disk space for the index, which the README does not quantify. If you use the MCP integration, you need to keep the binary path stable across upgrades, or re-run `deja install` after each update.
Editorial conclusion
Adopt deja-vu if you work across multiple coding agents on the same machine and want a local, zero-dependency memory that uses history you already have. Skip it if you cannot tolerate a shell-based installer on Windows, if your agent harness is not among the seventeen listed, or if you need memory that records forward from a clean state. Before relying on it, verify that your agent's session files are in formats deja indexes, confirm the benchmark harnesses in the repo reproduce the claimed numbers on your own data, and check which of the seventeen harnesses support session-start recall versus only on-demand search. The binary-only mode with `deja doctor` reporting `not-wired` is a sane fallback if you want search without MCP integration. The project's own numbers are reproducible from the repo, so verify before trusting the 85.3% figure.
Community notes