Explainers · updated July 2026
A monorepo is one repository for many projects.
Instead of a separate repo per app or library, everything lives in one tree with one history, the way Google and Meta keep most of their code. It makes a change that spans several projects a single commit. It also makes search harder as the tree grows past a certain size, and it has an exact opposite that trips up every code tool: a pile of separate repos that ship together as one product. Here is both shape, drawn to scale, and where each one hides things from your agent.
TL;DR
A monorepo, its opposite, and the index that covers both.
A monorepo is one repository with one git history holding many projects; its opposite is many repos that ship together as one product. Both are just shapes of a codebase.
Every in-repo tool works inside one boundary, so the most useful cross-repo fact, that a set of repos releases as one, is written down in no repo's index.
Search only slows as the tree grows if the tool re-walks it. A prebuilt index does not: a filename lands in 85 μs across 4.47M files, 412,000× faster than VS Code, ~480,000× faster than Windows Search.
Content search follows suit: a query that took ripgrep 93.8 s returns in 16 ms from the index (58,625×), and a saved edit is searchable again in about 1 ms.
Interlinked indexes the whole machine (every repo plus the non-git files) and hands it to every agent with no model in the box. Everything local is free forever, no card. Hosting starts at $5.99/mo.
The two shapes, drawn to scale
One boundary, many projects. Or many boundaries, one release.
Every code tool works inside a boundary, the repository you opened. A monorepo has exactly one, so one index reaches every project inside it. The opposite arrangement (separate repos that release together) has several boundaries, each with its own history and its own index, plus a relationship that spans all of them and is written down in none of them.
Left, the four projects share one .git and one index. Right, each repo carries its own. And the blue band, the fact that they release as one, is the thing no in-repo index can hold. The shape decides what a per-repo tool can and cannot see.
Why it bites back
The bigger the tree, the slower the walk. Unless you never walk it.
The reason a monorepo is convenient (everything in one place) is the same reason search slows down in it. Tools that scan the tree on each query take longer the more there is to scan. That is the documented behaviour of grep and ripgrep, and of an editor that walks a folder: they re-read files every time you ask. Past a few hundred thousand files, that is felt on every lookup.
An index that was already built does not re-walk anything. The same filename lookup lands in microseconds whether the tree holds ten thousand files or four and a half million: the cost is paid once, in the background, not again on every query. Measured on the benchmark machine below, the gap is not subtle:
| The searcher | The task | Time | vs Interlinked |
|---|---|---|---|
| Interlinked | one indexed lookup | 85 μs | the baseline |
| VS Code · Ctrl+P | same file, same drive | 35 s | 412,000× |
| Windows Search | median of 20 queries | 67 s | ~480,000× |
| Claude Code (no index) | one file, found by hand | 3 m 13 s | 2,276,000× |
Content search follows the same shape. A query that took ripgrep 93.8 s on this corpus returned in 16 ms from the index (same file, same machine), and across a five-query content set the index ran 58,625× faster. A saved edit is searchable again in about a millisecond, under 30 ms in the worst case.
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Filename figures are medians: 139 μs across 20 queries, 85 μs single-file; the Claude Code row is one file found by an agent with no index. Full per-tool method in the 412,000× write-up.
The mirror image
The opposite of a monorepo still ships as one.
Plenty of teams never adopt a monorepo. They keep separate repos (a web app, an API, a shared component library, a package of design tokens) versioned apart but released together, as one product. To a person, it is obviously one thing. To every in-repo tool, it is four unrelated folders that happen to sit near each other on a disk.
Cursor indexes the one repo you opened. Each of the four carries its own index. The single most useful fact about them (that they ship together) is recorded nowhere any of those tools can read. Ask an agent “which repos here move as a unit?” and, working per-repo, it cannot answer. Three things no in-repo index can hold:
Four repos, one release train. A fact that spans repositories can't live inside a single repository's index: by construction, the boundary it needs to cross is the boundary it stops at.
A component lifted from the shared library into the web app; a type duplicated across two services. The copies are real and related, and every per-repo view sees only its own half.
One is where this month's work happens; another went quiet a year ago. Liveness across a set of repos is a whole-machine question, and no single repo's history can answer it.
Two good tools, one shared blind spot
Cursor sees one boundary. Sourcegraph sees many. On a server, only what you pushed.
Cursor builds a strong index of the workspace you opened, exactly the right design for an in-editor assistant. But it is one boundary at a time: in a giant monorepo it indexes the slice you opened, and across separate repos it sees the one you are in while the siblings that ship with it stay dark. It is also Cursor's index, reachable only from Cursor.
Sourcegraph solves cross-repo at the organisation level: a code graph across many repositories, the right tool for a platform team. But it runs on a server, is configured per repo, and sees the pushed state: not the working copies on your disk right now, and never the files that were never in git.
Both leave the same gap: the local, unpushed, cross-repo reality of the machine you actually work on, whether that is one monorepo or a dozen repos that ship together. On a fresh install, a whole-machine index found 12 of 12 repos on the disk and seeded 26,958 relationship pairs from their own history, including the cross-repo fact that a folder of separate projects ships together. How Cursor's index draws its edge →
The layer over both shapes
Index the machine, not the repo. Then the shape stops mattering.
Interlinked keeps an always-fresh index of every file on the machine (names and contents) across every repo, monorepo or not, plus the non-git ~90% (documents, configs, downloads, the PDF with the answer). One boundary or twelve, it is all one searchable field, handed to whatever agent you use through a single connector. And because it looks at the whole machine, it can record the one thing no in-repo index can: that a folder of separate repos ships together. No model anywhere in the box: every result is a literal match or a counted relationship you can verify.
That filename lookup takes VS Code's own search about 35 seconds on the same machine, 412,000× slower, and Windows Search a median 67 seconds (~480,000×). Content search runs in the 1 to 10 ms range: a query that took ripgrep 93.8 s here returns in 16 ms. A saved edit is searchable in about a millisecond, under 30 ms worst case. At rest the whole engine sits around 44 MB in Task Manager, the on-disk index stays under 1% of the drive, and it wires up 19 AI clients in one install. It never leaves the machine.
ONE MONOREPO OR A DOZEN REPOS THAT SHIP TOGETHER: INDEXED AS ONE FIELD, HANDED TO EVERY AGENT.
Do this today
Give every agent the whole tree.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest. No JSON editing.
Index every repo at once. One monorepo or a dozen separate repos, they all land in a single whole-machine index, plus the non-git files a per-repo tool never sees.
Scope when you know. Whole-machine when you don't know which repo it's in; scoped to a folder when you do. Scoped queries return in microseconds.
Let it map the relationships. Day one it reads your git history across every repo and records which ones ship together. Automatically, no model in the loop.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows · How the vault seeds itself