Stop paying your AI
to re-read the same
files.
Self-hosted · no data sync · zero tokens to recall · 14-day free trial
Makes your code smart
The intelligence is stamped into the repo at write-time — while the AI still knows why.
Turns the codebase into a memory
Decisions live on commits, not in docs beside them. The code is the single source of truth.
Gives your code rules
Standing instructions your AI checks before every edit — they can't be skipped or forgotten.
Makes your AI more efficient
No re-reading, no re-deriving. Answers come from the index, not from whole files.
Helps AI truly understand
The why, the wiring, the blast radius — not just where a word appears.
Saves massive time & tokens
~1,400× fewer tokens and ~67× faster than grep-and-read, measured on real repos.
Docs drift.
Code doesn't.
Every AI session writes docs, plans, notes — then the plan changes and nobody updates them. Thousands of files, most out of date. The AI reads the stale version and confidently builds the wrong thing — after re-reading it for tens of thousands of tokens.
A second source of truth that rots.
- The AI burns thousands of tokens documenting every decision into Markdown.
- The next change happens in code — the doc is never touched again.
- Now the doc and the code disagree. Nothing tells you which one is wrong.
- Six months in: 3,254 files, ~90% outdated, nobody trusts any of them.
- To answer “why was this built this way?” the AI greps and re-reads whole files — tens of thousands of tokens, every single time.
The code is the only truth.
- Knowledge is stamped onto a commit (a SHA) — pinned to the code, not floating beside it.
- One sentence per decision: what was decided, and why.
- If a new change contradicts it, recall raises a flag the moment you write it.
- It self-heals: recall offers to update the note, you approve, the truth stays current.
- Recalling it costs zero tokens and answers in microseconds — no file ever re-read.
Make the code smart.
Then read it for free.
The trick isn’t a clever reader — it’s the opposite. recall spends the intelligence once, at write-time, so reading it back can be dead-dumb. And a dumb reader is the fast, precise, cheap, traceable one. The ~1,400× token saving falls out of that — it isn’t the trick, it’s the receipt.
Make the system smarter — once, at write-time.
While the AI works and already knows why, it stamps one sentence onto the commit: the decision, the why, the links. The thinking happens at the knowing moment, not the guessing moment. The codebase itself gets smarter.
Now the reader can be dead-dumb.
Because the intelligence is already in the index, recall doesn’t reason at read-time at all — it’s plain SQLite full-text search. No model, no embeddings, no re-reading files. A reader so dumb it costs nothing to run.
And a dumb reader is the fast, precise, cheap one.
It returns the exact decision (precise, not “where a word appears”), in sub-milliseconds (fast), for zero model tokens (cheap) — and the harder and more complex the question, the bigger the win, because a dumb lookup stays flat while grep-and-read explodes.
Every answer is traceable — and can’t go stale.
Each note is pinned to the commit it was written against, so you can follow any answer back to its source, and recall flags it the moment the code moves on. Nachvollziehbar by construction: the code is the memory, so the memory can’t lie.
- grep the codebase for the symbols
- open + read 3 candidate files, top to bottom
- re-derive the reasoning from scratch — every turn
- one SQLite lookup over the stamped anchors
- returns the decision + the why + the links
- pinned to a commit — traceable, freshness-checked
Measured cold-start on two live production repos (360, mccain-cms) — three real questions, no recall trailers planted. ~1,400× fewer tokens, ~67× faster — and the harder the question, the wider the gap, because the dumb lookup stays flat while grep-and-read keeps re-reading.
Measured on real
repos. Before we
shipped a line.
We didn't benchmark a toy. We ran the engine against two live production repos — 360 and mccain-cms — both with zero recall trailers, the honest cold-start a new customer sees. Here is what came back.
Your code never
leaves your machine.
recall is a small, self-hosted tool — not a platform. It needs exactly one thing: access to your project folder. That's the whole footprint, and the whole setup takes two minutes.
Runs on your machine
A small CLI and a local index inside your repo (.mind/). No server to run, no agent in the background. Works offline.
No data sync. Ever.
Nothing is uploaded, nothing is synced, no telemetry. It only reads your project — the website just checks your license.
Open code — maximum trust
The full source is public on GitHub. Read every line that touches your repo before you run it.
$ pip install git+https://github.com/heidrich/whatever-recall.git
$ recall init .
# indexed — your repo is its own memory nowThat's it. No config, no cloud account, no upload — the memory lives in your repo and ships with every clone.
Not where a word
sits. The decision.
One query, three levels: the hit, the meaning behind it, and what it's wired to. This is the exact shape recall returns — pinned to a commit, freshness-checked, in under a millisecond.
Now you can trace
everything.
The local dashboard makes the whole memory visible — any time, read-only, zero tokens. Causal chains, plans & tasks, the drift light, the wiring in your code, and the decisions behind it. Nothing leaves your machine.
Causal chains, walkable.
Request → decision → consequence → the code diff → the result. Click the arrows and walk any answer back to where it came from.
Plans & tasks, wired to the code.
Every plan, roadmap and standing instruction lives in the repo, linked to the files it touches — and surfaces the moment you edit them.
The drift traffic-light.
Which notes the code has moved past (🟡), which files you’re editing right now (🟠) — the honest list of what may no longer be true.
The wiring in your code.
The token-free code map and the pre-edit briefing: what a file is, why it’s that way, and what breaks if you change it (the blast radius).
Every decision, in one place.
Each feature mapped to the decisions, code, commits and tasks behind it — for coders and PMs alike, derived from the repo, always current.
One product.
Priced by seats.
Every plan has every feature — the CLI, the dashboard, Power Mode, the web-AI bridge, MCP, unlimited repos. You only choose how many people share the memory. Try all of it free for 14 days — no card, no feature locks.
- 1 seat
- CLI · dashboard · MCP · git hooks
- Power Mode & web-AI bridge
- Token-free recall, offline-capable
- Annual = 2 months free
- Up to 10 seats — flat, no per-seat counting
- Everything in Solo, same features
- The graph compounds with every teammate
- $8.30 per seat per month at full size
- Annual = 4 months free
- Up to 25 seats — flat
- Everything in Team, same features
- Unlimited client repos
- Priority support
- 25+ seats? Talk to us
14-day trial, full features, no credit card. Self-hosted either way — your code and your memory never leave your machine; the account only carries your license.
“We document constantly, then change the plan and never update the doc. The memory rots, the AI reads the rotten version and builds the wrong thing. So we moved the truth into the code itself — the one thing that can't lie.”