RC-01 — AI-native project memory · Built in Bavaria
Never changes your code · self-hosted · no card needed · zero tokens to recall
The shift
A human dev is bound by what they can hold in their head — so we built tools for human limits. An AI isn't. It can hold the whole graph, re-verify a claim in 0.25 ms, and never tire. What it lacks is a project that remembers: the why behind every line, the decisions it must not undo, the real names of things.
recall gives it exactly that — a codebase with memory, a conscience, and a track record. Free the AI from human restrictions, give it the context only the project can hold, and it codes the way it actually can: creative, exact, and fast. The AI are the hands; the project is the coworker.
One idea, six consequences — follow the chain
“…but what does it do to my code?”
It only reads. Everything recall knows lives in a local .mind/ index and in your commit messages — never in your source. No reformatting, no refactor, no edits, no files moved. Delete .mind/ any time and your repo is byte-for-byte what it was.
✓ Never edits your files✓ Read-only by design✓ Self-hosted · stays on your machine✓ Remove it any time, zero trace
The one cause
Today
Knowledge lives beside the code — in a wiki, a ticket, a chat window. The code itself stays flat and silent, so the instant it changes, the doc starts to lie.
with recall
recall keeps the knowledge in the code: pinned to the commit that changed it. One source of truth, not two that drift apart.
One truth in the code — so everything below follows from it.
so the knowledge must be written where the code is touched…
② Write-time stamping
Today
The expensive thinking happens while the bug is being fixed — then it evaporates. Later, someone (or some AI) has to re-derive the why from cold syntax.
with recall
While the AI works and the context is still in its head, recall stamps the decision + the why + the anchors onto the commit. Cheap, exact, one sentence.
$ git commit -m "switch seat check to an atomic RPC
Recall-Why: the JS check-then-insert raced under load and
double-booked the last seat; the RPC locks the org row.
Recall-Anchors: seats, confirmSeatOrRollback, orgs.ts"The why is written at the knowing moment — so reading it back needs no model.
so reading it back needs no model — just a lookup…
③ The 0-token read path — cut the token spend
Today
Every “why is this here?” makes the AI grep and re-read whole files — tens of thousands of tokens per question, paid again every session.
with recall
Because the meaning was written at write-time, reading is a plain SQLite + FTS5 lookup — no model, no embeddings. The finished answer in sub-milliseconds.
grep-and-read · a smart reader, every time
“why do uploads vanish after the RLS cut-over?”
~214,000 tokens
~147 ms · grows with the codebase
recall · a dumb reader, same answer
recall “rls cut-over uploads gone”
152 tokens
~2.18 ms · 0 model tokens · flat as the repo grows
Orienting is free — so you can afford to read the whole picture, every time.
free + complete ⇒ you can read the WHOLE profile before editing…
④ The 6 dimensions
Today
An AI opens a file blind — it can't see the open task wired to it, the decision it's about to undo, or what its change will break three files away.
with recall
One recall brief answers six questions at once — what · where · why · what breaks · open tasks · the trail — read-only, 0 tokens, the full profile of a file.
See it, don't just read it — the graph recall holds, live
The whole picture is affordable — so an AI never silently undoes a decision it never saw.
so the AI still has to NAME what it wants to find…
⑤ Search-inversion — fix vocabulary mismatch & AI hallucinations
Today
An AI invents a symbol name from its training — enforceSeats? seatLimit? — greps this repo, misses (blind grep lands 0 of 12), and burns the loop guessing again.
with recall
recall doesn't make the search better — it turns it around. It already wrote down this repo's real vocabulary at write-time, so it corrects the guess into the real name before the grep runs.
the AI · guessing from training
“where do we resolve the active seat?”
getUserSession()0 / 12 blind grep
vocabulary mismatch — a 30-year-old IR problem
recall resolve · this repo's real word
recall resolve getUserSession
getUserSession() → resolveActiveSeat()1 name, right answer
grep & embeddings can't — they never saw write-time
The idea is straight from the support trenches: a senior agent doesn't answer faster, they make sure the question is asked so it can't be misunderstood. recall does that for your AI — it structures the question against the repo's real words before a single token is spent guessing.
We fix the question, not the answer — the code becomes the senior support agent for the AI.
code moves on, so some notes will go out of date…
⑥ Self-healing → stop index rot & doc drift
Today
Docs rot because nobody notices when reality diverges from them. Six months in, most of the wiki is wrong and nobody trusts any of it.
with recall
Every note is pinned to a SHA. When the code beneath it moves, recall flags the drift (🟡) and offers the fix at the next commit — you approve, the truth stays current. It only flags, never silently rewrites.
a wiki · rots silently
the doc says one thing, the code now does another
~90% stale at 6 months
two sources of truth, nothing to check against
recall · detect → offer → approve
this change contradicts a pinned note
🟢 true again
mistakes have a half-life — the loop closes
Drift is caught and healed — and that feeds back into write-time, so the brain compounds. ↻ the loop closes — every commit makes the next one smarter.
07 — The cost of truth
For an AI, context space is the scarce resource. grep finds where a word sits — to learn why, it must read whole files back into context, tens of thousands of tokens per question. recall returns the decision in ~56. Measured cold-start on two live production repos (a 240-commit app, a 668-commit CMS), no recall trailers planted — that gap is the product.
~1,400×
fewer tokens than the grep-and-read path
152 vs ~214,000 tokens · 3 questions
~67×
faster to the answer that includes the why
2.18 ms vs 147 ms
0.25 ms
median recall at 108,627 anchors
scales flat — FTS5
10/10
real questions answered, 2/2 nonsense silenced
no hallucinated hits
Three knowledge questions, one production repomeasured · head_to_head.py
| Method | Time | Tokens | The why? |
|---|---|---|---|
| recall() | 2.18 ms | ~152 | ✓ direct |
| git grep + read files | 147 ms | ~214,000 | ✗ only where |
| code-index search | ~seconds | — | ✗ 0 hits · 2d stale |
recall is ~1,400× more token-frugal and ~67× faster than the real standard path (grep → read). The code index's map was 2 days / ~15 commits stale — the silent-lie failure recall is built against.
Tokens per question · grep vs recalldemo
| Question | grep+read | recall |
|---|---|---|
| Why must RLS writers set workspace_id? | 48,200 | 56 |
| Why split the viewer from the editor? | 71,500 | 61 |
| Why render the search modal via createPortal? | 39,800 | 52 |
Latency scales flatmeasured · FTS5
| Repo | Anchors | Median | Max |
|---|---|---|---|
| fixture | 1,204 | 0.04 ms | 0.09 ms |
| production app | 43,722 | 0.41 ms | 0.67 ms |
| production CMS | 108,627 | 0.68 ms | 1.0 ms |
08 — What you get
Six links, one outcome: the AI finally has what it needs to do its best work, and the company stops paying for it to guess. Here's what lands on the balance sheet.
152 vs ~214,000 tokens for the same three answers, measured. Across a team, across a year, that read-time saving scales into the millions — every orientation that used to cost a model call is now free.
The loop compounds: every commit stamps new knowledge and heals old drift, so the most-worked code carries the truest memory. The longer it lives, the smarter it gets — passively.
The AI is briefed before it edits and warned before it repeats a known mistake — so it stops re-deriving, stops hallucinating constraints, and stops undoing decisions it never saw.
Search-inversion fixes the guessed name to the repo's real vocabulary before the grep — no more guess → miss → guess loop burning tokens and wall-clock.
Blast radius, contested hotspots, the causal trail — and a new dev or a fresh agent inherits the whole repo's reasoning in one command.
Your code and memory never leave your machine — no cloud, no telemetry, no vector DB, no API key. One small tool, pure stdlib, runs with the network cable pulled.
09 — Self-hosted
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.
A small CLI and a local index inside your repo (.mind/). No server to run, no agent in the background. Works offline between hourly licence checks (a brief online confirmation, with a short grace window) — your code never leaves your machine.
Nothing is uploaded, nothing is synced, no telemetry. It only reads your project — the website just checks your license.
The full source is public on GitHub. Read every line that touches your repo before you run it.
the whole setup
$ 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. Questions? The source on GitHub is one click away.
10 — Security
The most sensitive thing about a codebase is the why behind it. recall keeps it in a local brain, not in your source — so your code ships clean, and your reasoning stays yours unless you choose to share it.
Every decision you stamp sits in the local .mind/ index — beside your code, never inside it. Your source ships byte-for-byte clean; there's nothing to scrub before you publish.
Mark a note --private and it's yours alone — never in an export, never in a shared brain. Notes can only get more private, never less. You can't widen something by accident.
recall export writes a shareable copy with every private note stripped out. Whether your team shares it is your call; what's in it is recall's guarantee: team knowledge, never private.
The export aborts rather than write a brain that still holds a private note, and check-leak blocks a commit that would stage one. A private decision physically can't reach a teammate's clone or a public repo.
stamp private · share clean
$ recall stamp "why we chose this" --private
🔒 private — stays in this brain
$ recall export --out .mind/shared.db
# private notes stripped · gate verified cleanA solo developer ships a clean codebase by construction. A team shares the knowledge it wants to — and nothing it doesn't. Your code is the public artifact; your reasoning is yours. How private knowledge stays local →
11 — Pricing
No tiers, no feature locks, no “upgrade to unlock.” Everyone gets every feature — the CLI, the dashboard, Power Mode, the web-AI bridge, MCP, unlimited repos. You only choose how many people share the memory. Buy a single seat and run solo, or add seats and the team tools appear. Try all of it free for 14 days — no card.
01 · Developer
$29/mo · $29/seat
1 seat = run solo. Add a 2nd to unlock team tools (members, keys, billing).
No card. Every feature. Cancel anytime.
Everything you get
The same product whether you're one developer or a hundred — the only thing that scales is the number of people sharing the memory.
Education & research — free, forever
I firmly believe that education — and exploring and debating problems together — is the best way to lead humanity into a fantastic future.
So schools and universities use recall for teaching and academic research at no charge — no fees, ever. We'd love to hear what you're building. The one honest line: if the research becomes a product or spin-off that earns money, it needs a regular plan from that point on.
Get in touch
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. Licensed under the Business Source License 1.1 — every released version becomes open source (Apache 2.0) three years after its release, so your stack can never end up in a proprietary dead end.
— Why it exists —
“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.”
— Stop briefing the AI. The code briefs itself. —
recall fixes the guess to your repo's real vocabulary before the search — because it's the only thing that recorded what you actually call things.
Self-hosted · hourly online seat check (short offline grace) · zero tokens to recall · 14-day free trial
The roadmap
The foundation is real today — the code becomes self-aware, reading is free, the search stops guessing. From there we harden on your feedback, then open it up into a real app with deeper features. The horizon we're building toward (not shipped yet, and we'll always say so plainly): today your code lives in folders and files built for human reading. An AI navigates the graph, not the tree — and recall already holds that graph. The idea turns it around: the graph as the truth, the file layout as a view rendered from it, so an AI can structure code the way it thinks while recall renders it back to ordinary files for your compiler and git. It starts small — recall suggesting where code really belongs.
Shipping now · the foundationNext · hardening on your feedbackThen · the app & deeper featuresThe horizon · graph-native
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。