The vault series · on trust
Receipts, not vibes.
A good assistant will tell you two files are related and sound completely sure, and it can't show you why in a way you can check. The knowledge vault inside Interlinked draws the same kind of connection the opposite way: every edge names the fact it came from, and you can verify it by hand in one step. No model sits in the middle. That is the whole difference between a claim you can audit and a claim you're asked to take on faith.
Two ways to answer one question
"Are these files related?" Answered two ways.
Both pipelines below take the same input (two files) and reach the same shape of answer. One routes through a model whose reasoning you cannot open. The other is a short chain of facts your machine already recorded, each one checkable on its own. Follow the arrows.
The top lane is how most AI features work, and it is often right. But the moment you ask "why?" the audit trail runs into the model and stops. The bottom lane never has that dead end: fact, count, floor, edge. Nothing in it is a judgment call, so nothing in it needs your trust. The floor of 3 is part of the receipt: a pair that changed together twice never becomes an edge at all.
You already know this feeling
A confident number you were never shown the math for.
You have trusted an unauditable number before, probably twice today. When a code assistant completes a whole function, it is making a claim: this is what you meant. It is frequently right. But there is a model in the middle, and a model's reasoning is not a thing you can open and read line by line. A credit score is the same shape: one number that decides whether you get the apartment, produced by a formula you are not allowed to see. Both arrive with total confidence. Neither comes with a receipt.
| The claim | What it's built on | Check by hand? | Model in the loop? |
|---|---|---|---|
| A Copilot-style code suggestion | a plausible completion | No | Yes, opaque |
| A credit score | one number that gates real decisions | No | Yes, opaque |
| An Interlinked edge | “co-changed 6×”: it names its fact | Yes, one step | None |
An Interlinked edge is built to be the opposite of both. It would rather hand you a small, boring, checkable fact than a confident conclusion, because a fact you can re-derive is worth more to an agent than a verdict it has to believe.
Show your work
Every edge is redoable by hand.
Pick any relationship the vault drew and reproduce it yourself: no access to our source, no trust required. There are a few kinds of evidence, and each has exactly one check. The number is whatever your record says (6 here, 435 there) and it is always a number, never an opinion.
Six commits in your own history changed both files together.
git log --oneline -- launcher-health.tsx drive-map-graph.tsxcount the lines → 6435 files across the two repos have byte-for-byte identical contents: one repo is the other's ancestor.
hash every file in both trees · intersect the two lists435 collisionsProject A's name appears, literally, in 106 files of project B.
search the name across project B106 hitsRun any of these and you either confirm the edge or catch it being wrong, out loud, in a way anyone can repeat. That is the property that matters. A wrong receipt is falsifiable. A confident guess just sits there being wrong quietly, and gets absorbed into whatever the agent does next.
Why leave the model out
A model that's usually right is sometimes confidently wrong, with no tell.
That is the case against putting a learned model in the derivation. When it invents an answer, it wears the same confidence as when it nails one; nothing on the surface flags the difference. A chain of counts fails loudly instead: the count is checkable, so a bad edge is caught by looking, not by luck. Receipts trade a little cleverness for total legibility, and on the connections that steer an agent, legibility is worth more.
There is a practical dividend too. Because no model is involved, the derivation is identical on every machine, runs offline, and costs nothing to trust: 26,958 edges on a fresh machine, none of them a guess, zero failures, seeded from 8,455 git events in 1.7 seconds and measured on a Ryzen 9 9950X3D with 4.47 million files. And because each edge is keyed to the file's identity in the operating system, it survives renames and moves, spans every repo plus the non-git files around them, and belongs to no vendor.
Evidence, not verdicts
The vault hands over evidence. The agent decides what it's worth.
Because every edge carries its count, an agent can weigh it instead of obeying it. "Co-changed 6×" is a strong nudge; a pair that changed together once never clears the floor and never becomes an edge at all. The vault never tells the model what is true: it shows it what is on the record and lets it judge. That is the right division of labor: facts from the machine, judgment from the model. Never the machine pretending to judge, never the model pretending to have facts.
THE VAULT SERIES: RECEIPTS OVER GUESSES.
See your own machine's receipts
Ask your agent why two files are connected.
One signed installer configures 19 AI clients and seeds the vault from your own git history in seconds: nothing to set up, nothing to feed it. The same index returns a filename in about 85 microseconds, and every result can carry the edges the vault derived. Ask any connected agent "why are these two files related?" and it won't answer with a vibe. It will answer with a count you can check.
Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo. Download for Windows · How the vault builds itself