Guides · measured July 2026
How to speed up Cursor on a big codebase. Start with the part that isn't the model.
Open a huge repository in Cursor and it can start to drag: the agent stalls before it answers, indexing spins, edits feel a beat behind. The instinct is to blame the model. On a big codebase the model is rarely the slow part. Most of a turn is spent finding the code: searching the tree, re-reading files, waiting on the index to catch up. Below are the fixes that actually move the needle: the settings you can change in a minute, then the one structural change that removes the re-scan for good.
TL;DR
The short version. If you read nothing else.
The model is rarely the slow part. On a big codebase most of an agent's turn goes to finding code (searching the tree, re-reading files), about ~58% of its session tokens, and that search comes back every single turn.
Settings help, but only so far. Ignoring build output, scoping the repo, letting the first index finish and passing exact paths all shrink the re-scan, but none of them remove it.
One warm index removes it. A single always-fresh, whole-machine index shared by every agent answers filename lookups in 85 µs (139 µs median across 4.47M files) and content in ~7 to 9 ms.
The grep tax collapses to one call. The proof content query drops from 93.8 s to 16 ms (58,625×), and an agent's 6 min 57 s, 71-call hunt for one file becomes 16 ms in a single call, roughly 58% of its tokens handed back to the model.
It's light, fresh and local. The engine sits around 44 MB idle, a saved file is searchable ~1 ms later, and nothing ever leaves the machine. Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo.
Where the seconds actually go
Anatomy of one slow turn. The model is the small block.
Watch a single agent turn on a large repository. A little of it is the model reasoning, the part you pay for, and the part that is genuinely fast. Most of it is the agent going out to find context: scanning the tree, re-reading files it already saw, waiting on the index to settle after a save. That middle block is the bottleneck, and it comes back on the next turn, and the next. The shortcut is not a smaller block: it is answering that search from a warm index in a single call.
Proportions are illustrative; the labeled figures are measured on the benchmark machine (Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4.47M files). ~58% is the share of session tokens an agent spends finding files; 16 ms is a content answer from a warm, always-fresh index. Trim the block with settings (next section), or remove it with a shared index (the one after).
Do this today · minutes, not a rewrite
Five ways to make Cursor faster right now.
Steps 1 through 4 shrink what Cursor has to chew on, so indexing settles faster and results stay relevant. Step 5 is the one settings can't reach, and it's where the rest of this article goes.
Tell Cursor what to skip. Add build output, dependencies and generated data (the node_modules, dist, .next, vendored bundles and large datasets) to Cursor's ignore files. Anything you list is never indexed, so the index doesn't spend itself on files you'll never ask about. A smaller index is a faster, more relevant index.
Open the project, not the planet. Point Cursor at the specific repo you're working in, not a giant parent folder that holds a dozen of them. The index is scoped to what you open: a tighter scope means a quicker first pass and results that aren't diluted by unrelated matches.
Let the first index finish. On a large codebase the initial pass is the heavy one. Kick it off, let it settle, then work. Hammering the agent mid-index makes both the indexing and the answers slower.
Hand the agent the path when you know it. In agent mode, a precise file or folder beats “search the whole repo.” Every whole-tree scan on a big project is seconds the model spends waiting instead of reasoning, so scope the ask whenever you can.
Mind the re-scan tax. Here's the one no setting fixes: whenever the agent needs context it doesn't already hold, it goes out and searches the tree again, from cold. On a big repo that scan is the recurring cost, and it returns every turn, on every agent you run. The rest of this page is about removing it.
Why the block keeps coming back
The agent falls back to grep. On a big repo, that's the tax.
When an agent needs a string it doesn't already have in context, it shells out to a fast literal search, most often ripgrep. ripgrep is excellent at what it does; it is also, by design, a tool that walks the tree from cold on every call. It keeps nothing warm between queries. On a small project you never feel it. On a big codebase, called every turn, by every agent on the machine, it is exactly the middle block in the diagram above.
We timed one heavy content query on the benchmark machine, same corpus, both ways:
Across a five-query content set that gap holds at 58,625×: content answers land in the ~7 to 9 ms range, ~8 ms on average. The whole-run version of the same story: an agent asked to find one file with nothing warm underneath spent 6 minutes 57 seconds across 71 tool calls; the same answer off the index took 16 ms and a single call. Tokens spent grepping are tokens not spent thinking, and on a big repo, that is most of them.
Same machine · same drive · same queries
The search step, everywhere it happens today.
| The searcher | The task | Time | vs Interlinked |
|---|---|---|---|
| Interlinked | one indexed lookup | 85 µs | baseline |
| VS Code Ctrl+P | same file, same drive | 35 s | 412,000× |
| Windows Search | median of 20 queries | 67 s | ~480,000× |
| ripgrep (agent's content grep) | the proof query, same machine | 93.8 s → 16 ms | 58,625× on the set |
| Claude Code (no index) | agent hunts for one file | 3 m 13 s | 2,276,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. The filename rows compare against Interlinked's 85 µs single-file lookup; the ripgrep row is a content query, timed against the index's own 16 ms content answer, and the 58,625× multiplier is across the five-query content set. The Claude Code row is a measured agent run. Full per-tool methodology in the ripgrep comparison and how Cursor's own index works.
The structural fix
One warm index. Shared by every agent on the machine.
The settings shrink the block. To remove it, put a single always-fresh index under everything and let every agent query it instead of re-scanning the tree. Interlinked keeps a live index of every file on the machine (names and contents, across every repo and the non-git bulk of the disk) and hands it to whatever agent you use through one connector. It is not a semantic index and doesn't try to be: it is the fast, literal layer that answers "does this exact string exist, and where?" before Cursor finishes noticing you pressed a key. Keep Cursor's own index for meaning; this is the floor it stands on.
Because it is one index and not one-per-agent, the re-scan happens zero times: the answer is already warm when the next agent asks. At rest the whole engine sits around 44 MB in Task Manager, and the index on disk stays under 1% of the drive (about 24 GB on a 4 TB machine). It never leaves the machine, and there is no model anywhere in the box.
NOT A REPLACEMENT FOR CURSOR'S INDEX. THE LITERAL, WHOLE-MACHINE LAYER UNDER EVERY AGENT, CURSOR INCLUDED.
Common questions
Before you install. The questions people actually ask.
Does this replace Cursor's built-in codebase indexing?
No, and it doesn't try to. Cursor's index is semantic; it understands meaning. This is the fast, literal layer beneath it, answering “does this exact string exist, and where?” in ~7 to 9 ms. Keep Cursor's index for meaning; this removes the cold re-scan under every agent.
Does it speed up other agents, or only Cursor?
Every agent on the machine. One warm, whole-machine index is shared through a single connector, so Cursor, Claude Code, Copilot, Windsurf, Cline and the rest all answer from it (85 µs filename lookups, 139 µs median across 4.47M files, and ~7 to 9 ms content) instead of each re-scanning the tree.
Won't a machine-wide index be stale for a file I just edited?
No, it stays fresh. A saved file is searchable ~1 ms after you save it, so the agent never queries a cold or out-of-date tree.
How heavy is it on my machine?
Light. At rest the whole engine sits around 44 MB in Task Manager, and the index on disk stays small. There's no model anywhere in the box, and nothing ever leaves the machine.
What does it cost?
Everything (the app and the MCP layer every AI client plugs into) is free forever, no card. Hosting starts at $5.99/mo.
Speed up Cursor, and every agent beside it
Trim the index. Then remove the re-scan.
Do the five settings today: they cost nothing and Cursor keeps doing what it does well inside your open repo. Then put one always-fresh, whole-machine index underneath, so Cursor and every other agent stop re-scanning the tree and start answering from something warm. One signed installer indexes the machine and wires up the AI clients you already use, with no JSON editing, no cloud account, no keys.
Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo. Download for Windows · Why finding files is the bottleneck