“Every AI coding agent I use forgets me the moment the session closes. I’d stopped even being annoyed by it. That’s the actual problem.”
It started as one of those unfocused late-night scrolls. I’d just wrapped up writing about my Claude Code setup — the eight layers, the memory system, all of it — and something about writing it down made me restless instead of satisfied. Auto Memory helps, genuinely. But it only starts remembering from the day you turn it on. Every session before that, every bug I’d already fixed, every decision I’d already made — gone, sitting in log files somewhere, doing nothing.
So I did what I usually do when a problem’s been quietly bothering me: opened GitHub, typed something vague into the search bar — I think it was just “coding agent memory” — and started scrolling through whatever came back. Mostly the usual suspects. Vector databases wearing a memory costume. Ambitious frameworks with more architecture diagrams than actual users. Then a small, unassuming repo with 32 stars and a name that made me smile before I’d even read the description: deja-vu.
Of course it’s called that. Of course the memory tool is named after the feeling of remembering something you swear you’ve already lived through.
What Actually Stopped My Scroll 🛑
“Your agents already solved this. deja finds it.” One line, and I stopped scrolling.
Here’s what made this one different from every other memory tool I’d skimmed past that night: it doesn’t ask you to start remembering from today. Claude Code, Codex, and opencode have been writing every single conversation you’ve ever had to plain files on your own disk this entire time — gigabytes of debugged problems and design decisions, sitting there, completely unsearchable. deja doesn’t capture anything new. It just finally makes all of that history usable.
That’s a genuinely different bet than everything else I’d seen. Most memory tools are forward-looking — they start a fresh notebook the day you install them and slowly fill it in from there. deja starts full. The very first time you search it, you’re not searching new memories. You’re searching months of work you’d already done and completely forgotten you’d done.
I sat with that for a minute before I even opened the README properly. It’s such an obvious idea in hindsight that I felt a little dumb for not having thought of it myself.
Going Through the Actual Code, Not Just the Pitch 🔍
“A README can sell you anything. I wanted to know if the code backed up the claims.”
I don’t usually take a tool’s performance numbers at face value, so I went and actually read through what it’s doing under the hood before trusting it with real session history.
It’s a single Go binary — no models to download, no background service to keep running, nothing phoning home. Here’s the actual mechanics, not just the marketing summary: on first run, deja walks every session store it can find — the JSONL files Claude Code and Codex write, the SQLite database opencode keeps, and by now a genuinely long list of other harnesses too (Cursor, Copilot CLI, Gemini CLI, Antigravity, Qwen, Kimi Code, Goose, OpenClaw, Hermes, Roo Code, and more). It parses each one, strips anything matching a known credential shape, and writes the result into two files sitting quietly in ~/.cache/deja: records.bin, holding the actual searchable content, and a set of token buckets forming the inverted index itself. A separate manifest.gob tracks per-file state — size, modification time, a hash — so on every subsequent run, deja only re-reads files that have actually changed since last time instead of re-indexing gigabytes of untouched history over and over.
That incremental design is why the numbers hold up in practice and aren’t just a best-case benchmark: the first index of a real, heavily-used setup — one demo referenced indexing over 19,000 sessions across more than a dozen different harnesses on a single machine — takes roughly ten seconds. Every run after that only touches what’s new.
One detail that genuinely impressed me once I found it: running deja warmup doesn't just refresh the index quietly in the background. It also writes a small skill file to ~/.agents/skills/deja-search/SKILL.md that teaches any agent reading it the actual CLI contract — how to call deja search --json, how to read ctx and blame output, what the relevance tiers mean. The tool documents itself to the agent, not just to the human reading the README. That's a small design choice, and it's exactly the kind of detail that separates a tool built by someone who's actually used it under real working conditions from one that was only ever demoed once for a launch post.
It’s also been through an actual third-party security pass, not just self-reported safety claims — a published audit combining a dependency vulnerability scan with prompt-injection heuristic testing came back with no high-severity findings. Worth checking yourself before trusting any tool with months of raw session history, and worth noting that this one didn’t just ask you to take its word for it.
The Part That Actually Deserves Recognition 🙏
“Small open source tools like this rarely get the credit they deserve, because there’s no marketing budget behind them making noise.”
The whole thing is built and maintained by one person — Vladislav Shulcz, a backend engineer and student at Saint Petersburg State University working mainly in Python and Go. His own GitHub bio lays out a philosophy that, once I saw it, explained everything I’d just spent an hour reading through the code confirming: he says he likes systems that stay boring in production — explicit APIs, small moving parts, tests, CI, clear docs. That’s not a throwaway line. It’s a description of exactly what deja actually is. No embeddings pipeline to babysit, no service to keep alive, no clever abstraction hiding what it’s actually doing — just a small, well-tested binary that does one job and documents itself honestly, including the parts where it admits its own limits.
It’s not a one-off either. Looking through his other public work, the same instinct shows up repeatedly — a tiny, zero-dependency typed dependency injection library for Python, a self-hosted metrics stack written in pure Go, a reproducible Kubernetes autoscaling lab built specifically to compare controllers with actual measured evidence instead of just claims. A consistent pattern: narrow scope, real tests, tools built to actually be trusted in production rather than to impress in a demo.
That’s worth sitting with for a second. A student, working alone, shipped something with genuinely careful security thinking, real performance discipline, and documentation thoughtful enough to include an honest FAQ comparing itself against heavier alternatives instead of pretending they don’t exist. That kind of care doesn’t show up by accident. It shows up because someone actually cared whether the tool was good, not just whether it shipped.
I don’t know Vladislav, and this isn’t a paid mention or a partnership — just a genuine “thank you” from someone whose 1am GitHub scroll turned into an actual fix for a problem I’d basically given up on solving. Open source runs on exactly this: one person, one late night, one itch they decided to actually scratch instead of just tweeting about it.
Actually Trying It 🧪
“Ten seconds to install, about ten to index — that’s the actual claim. I wanted to see if it held up on my own machine, not just take their word for it.”
Installing it is about as low-friction as tools get:
curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh
deja install --all # wires MCP recall into claude-code, codex, opencode
deja install claude-code --auto # adds a session-start hook — recall without asking
The first search against my own session history was the moment this stopped being an interesting README and started being a tool I actually trusted. Asking it about a bug I knew I’d fixed weeks earlier — something specific enough that I could verify the answer myself — it pulled back the exact session, the exact fix, in a genuinely small handful of milliseconds. Not a vague summary. The actual conversation, the actual resolution, retrieved from a session I’d completely forgotten I’d ever had.
With the auto-recall hook wired in, the next time I opened a project I’d worked on before, the agent already had relevant context waiting before I’d asked it anything. That’s the actual promise of the whole tool, delivered exactly as described — not “the agent might remember if you remind it,” but the agent quietly already knowing.
Why This Actually Matters, Beyond One Tool 💭
What got me about this whole discovery wasn’t really the tool itself, even though it’s genuinely good. It was the reminder that the most useful things in this ecosystem right now aren’t always the ones with a funding announcement attached. Sometimes it’s one person, awake at a weird hour, annoyed at the same specific thing you’re annoyed at, who just goes and fixes it — and doesn’t need anyone to overhype it, since it’s demonstrably worth using regardless.
That’s the actual value in still scrolling through GitHub at 1am occasionally instead of only reading whatever trends to the top of a curated newsletter. The good stuff doesn’t always announce itself. Sometimes you have to be the one to find it, read the code properly, and say thank you to whoever’s on the other end of that commit history.
Tags: Claude Code, AI Coding Agents, Open Source, Developer Tools, Software Engineering, Agentic Coding
Before you go
- Please take a moment to like the post and follow the writer!
- Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute here
I Was Scrolling GitHub at 1AM Looking for a Memory Fix. I Found Something Better. 🔁 was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.