Benchmarks, retrieval architecture and the engineering behind indexing a codebase once and serving it to every tool that asks.
1–10 of 66 · page 1 of 7
A technical note on what 'verifiable' actually means in a verifiable code IR. Not a machine that rebuilds your code from a document, but a derived contract that every change gets checked against. Here is what a single verification check consists of, why round-trip is a signal and never a promise, and the honest boundary of what it can and cannot catch.
A code graph takes a whole, coherent program and shreds it into a bag of symbols and edges. It is genuinely useful, but it is a teardown, and the meaning never survives the pieces. A verifiable intermediate representation is the opposite move. It lifts your code into a higher layer that keeps the intent intact, then checks every change against it. Here is the difference between shredding and preserving, and why it decides everything downstream.
Vector search and GraphRAG look like opposites, but they share the same final move. Parse the code, retrieve some of it, rerank it, and stuff it into the context window. That last step is where both of them rot, because a model that is handed a pile of chunks degrades the same way no matter how the pile was chosen. Here is why the retrieval layer is not the cure for context rot, and what is.
The claim that a verifiable IR beats vector search and GraphRAG only matters if the numbers hold up. So here is the run. 46 Kubernetes-ecosystem repositories, 150,000 files, 8 GB of code, measured end to end. What we tested, how we scored it, and why feeding the model 22x more context made it cheaper and more accurate at the same time.
Verifiable is the one word competitors cannot claim. A code graph extracts a shadow of your code and can never tell you whether the code still does what it is supposed to. A verifiable intermediate representation is a derived contract that every change gets checked against. Here is what verifiable actually means, why GraphRAG and vector search can only retrieve, and what continuous verification unlocks.
Your team uses Claude Code, Cursor, Copilot, and Windsurf, and each one rebuilds an understanding of your codebase from scratch and shares nothing with the others. MCP is the standard that lets you stop doing that. Compile your repos once into a verifiable IR and serve it to every tool over one MCP endpoint. Here is why the context layer belongs outside the tool, and what changes when it does.
The objection to compiling a codebase into a verifiable IR is always cost. It sounds like Opus pricing across every file. It isn't. At open-source-model rates it runs about $13.30 per 1,000 files, you pay it once, and per-file diffing means you only ever re-pay for what changed. Here is the real economics of the verifiable context layer, and why the expensive thing is not building the IR but living without one.
Every tool that feeds your codebase to an AI coding agent picks one of four representations. AST parsing, vector embeddings, code graphs, or a verifiable intermediate representation. Here is what each one keeps, what each one throws away, and why the first three are features of the fourth.
Specs and code drift apart the day after you write the PRD, because they are two separate documents that nobody keeps in sync. A verifiable context layer derives the spec a codebase actually implements and then continuously checks the code against it. Here is how spec-driven development works on a brownfield codebase, and why it needs a verifiable code IR that checks code against intent.
Context graph is a term people understand and reach for. But most things called a context graph are one-way extractions you can read and never check anything against. The version worth wanting is the one you can verify code against, and that single requirement is what separates an index from a verifiable code IR. Here is what verification demands, and why it is the only honest test of a context graph.
