Notes and benchmarks.

Benchmarks·Windows SearchVS Coderipgrep

100GB costs $14 at Unity, $10 at Diversion and $7 at GitHub. Here it is $5.99.

Storage per 100GB: $5.99 here, $7 at GitHub, $10 at Diversion, $14 at Unity; Perforce does not publish its rate. Downloads, seats, and the monthly bill for 5 to 100 people on a terabyte, from each vendor's own pricing page. From seven people up, ours is the lowest published price, and it stays flat as the team grows.

Oct 1, 20267 min

Features

Why we chose superposition. No more file locking.

We had hard and soft file locking working, tested both for nearly three months with people and AI agents, and removed them in October 2026. Now when two people or agents change the same file, both versions are kept and nobody waits. Why neither lock makes sense in the era of agents, and how superposition works.

Oct 10, 20265 min

The world's fastest Windows file search. A proprietary invention at Interlinked.

Every file name cached and compressed ahead of time, and up to date in milliseconds. On one 4.47M-file Windows machine a file by name comes back in 85 µs, against 35 s in VS Code and 67 s in Windows Search, and an AI agent goes from 71 tool calls to one. An evolution of agentic workflow: faster agents, fewer tokens.

Oct 4, 20264 min

Perforce vs Diversion vs Git LFS: what big-file version control actually costs

Published list pricing for the three things teams choose between when files stop being text, with the arithmetic shown. A 20-person team on one terabyte pays $113.81 here against $790 on Diversion, $877.50 on Perforce and $145.11 on Git LFS. Against Git LFS it is a rate difference of roughly a fifth to a quarter; against the other two it is 4.6x to 7.7x, and almost all of that is the seat.

Sep 21, 20267 min

Lore vs GitHub: what happens when the files stop being text

Not a takedown. Git is superb at source code and was never built for bytes: 100MB per file, 2GB per push, repositories strongly under 5GB. LFS is the escape hatch, it keeps every version whole, and it bills the owner for everyone else's downloads. Hugging Face moved 500,000 repositories and 20 petabytes off it in 2025 and published the numbers. What a chunked engine does instead, and the three jobs we are not pretending to do.

Sep 21, 20268 min

Agents·Claude CodeVS Coderipgrep

Self-hosting is the expensive option

The engine under big-file version control is open, so running it yourself looks like the cheap path. It is not. Three lines nobody estimates decide the bill: the index database it will not start without, a server sized to the bandwidth it streams, and egress at nine cents a gigabyte. A terabyte pulled once a month is about $185 self-hosted against $60 hosted, and the self-hosted column still has no accounts, permissions, share links, viewer or metering.

Sep 18, 20266 min

The backbone of the LLM economy: what your AI actually does all day

Every agent session starts with finding, not thinking, and we measured it: ~58% of session tokens, 71 tool calls, 6 minutes 57 seconds for what one indexed call answers in 16 milliseconds. A tour of the layer the whole agent stack stands on, with the bedrock diagram.

Jul 3, 20269 min

Features·Claude CodeCursorAnthropic

Your agent's memory dies on rename

CLAUDE.md, .cursorrules, vendor memory: the whole industry keys agent knowledge to a path, a repo, or an account. Reorganize your project and it quietly becomes wrong. Keying memory to the file's OS identity fixes it: machine-wide, vendor-neutral, rename-proof. The vault series, part 1.

What is an MCP server? A plain-English guide

The plain-English answer, diagrammed end to end: how AI agents like Claude Code and Cursor gain tools through the Model Context Protocol, then the file-search MCP server that hands every agent instant whole-machine search (85 µs across 4.47M files).

Features·Claude CodeCursor

71 tool calls, three tools: inside the run we keep quoting

We recovered every call from the 6m 57s Claude Code file hunt frame by frame. It used three tools (glob 47 times with one character changed, bash 22, read twice) and never found the file by searching. Call 61 read a leftover Windows shortcut and lifted the path out of it.

Aug 3, 20267 min

Files that find each other: how the vault builds itself

On a fresh machine, Interlinked replayed 8,455 git events across 12 repos in 1.7 seconds and seeded 26,958 relationships, before the first query. No LLM, no embeddings; every edge is a receipt you can check. The same idea CodeScene sells, run live and machine-wide. The vault series, part 2.

Explainers·ripgrepVS Code

What is ripgrep, and why is it so fast?

The multithreaded Rust grep behind VS Code and most AI agents, how it left grep in the dust, and the one wall every filesystem walk hits: on 4.47M files, the same search ripgrep takes 93.8 seconds to run, a warm index answers in 16 milliseconds.

Agents·Claude CodeAnthropicripgrep

How Claude Code finds files (and why it is slow)

Claude Code has no map of your machine, so it finds a file the long way: looping ls, grep and read for 71 tool calls and 6m 57s on a 4.47M-file drive, ~58% of its tokens gone before it opens the right file. Here's the loop drawn, and the one indexed call that ends it in 16 ms.

Explainers·CursorVS Code

How Cursor indexes your codebase - and what it cannot see

Cursor builds a semantic embeddings index of the repo you open: genuinely good, and blind by design to your other repos and the non-git 90% of your disk. Here's exactly how it works, and the whole-machine layer that sees the rest.

Comparisons·ripgrep

ripgrep vs grep: what actually changed

ripgrep beat grep with parallel search, .gitignore, Unicode and backtrack-proof regex: real, measurable wins. But on 4.47M files both still walk the disk every query, so even ripgrep's best is 93.8 seconds. Here's the one ceiling only an index escapes.

Methodology·Claude Code

One call, not 71: dissecting agent retrieval in a real session

We pulled every tool call from one long agent session: 199 of them. Only five reached across the whole machine to find a file, none over 3.2 ms; the other 194 were pure work. The raw Interlinked calls, the counts, and the momentum after the index made search free.

Jul 23, 20266 min

How to find a file you lost on your computer

You saved it, you named it something, and now it's gone. Three ways to find a lost file on Windows (by half-remembered name, by a phrase inside it, or by what it was saved with) in milliseconds, not minutes.

Aug 4, 20264 min

How to search inside PDFs on Windows: all of them at once

Stop opening PDFs one by one to find a phrase. How to search the text inside every PDF on your computer at once (statements, contracts, manuals) with results in milliseconds.

Aug 4, 20264 min

Windows Search can't find a file you know exists? Here's why

The file is right there (you can browse to it) but search returns nothing. The three reasons this happens (indexed locations, content filters, timing) and how a whole-machine index fixes all three.

Aug 4, 20265 min

Find a file when all you remember is a phrase inside it

You don't remember the file name: you remember a sentence, a name, a number that's IN the file. How content search finds it across your whole computer in milliseconds, even in PDFs named scan_0417.

Aug 4, 20264 min

Guides·Claude CodeCursor

Can your AI assistant find files on your computer? Yes, here's how

AI assistants can't see your hard drive by themselves. Give one a local search index and 'pull up everything from the Meridian deal' becomes a working request: one install, no setup per app, nothing uploaded.

Aug 4, 20265 min

Find every contract on your PC, even the ones with unhelpful names

Contracts and deal documents scatter across Downloads, email exports, and old folders, half named final-v3.pdf. How one search assembles all of them: by name, by the text inside, and by which files belong together.

Aug 4, 20265 min

What is the context window - and why file search eats it

The context window is your model's RAM: a fixed budget every token shares. Here's why an agent's file hunting quietly eats ~58% of it, and how an instant index hands the whole window back for thinking.

How AI coding agents actually read your code

AI coding agents can't see your files: they perceive your code through a blind loop of search and read calls, each one costing seconds and tokens. Here's that loop drawn out, measured on 4.47M files, and the one change that collapses it to a single 85-microsecond hop.

Explainers·ripgrepClaude Code

RAG vs indexed search vs grep: the retrieval map for code

There are three ways to get code to an AI agent: embeddings (RAG), a live index, or grep. They win in completely different places. Here's the map of when to reach for which, and why the exact-fast-fresh lane runs parallel to RAG rather than replacing it.

How to search every file on Windows, fast

Windows Search indexes only a slice of your drive and walks the rest, which is why it takes 67 seconds to find one file among 4.47 million, while macOS Spotlight feels instant. A real how-to on every way to search Windows files, why coverage (not clever code) is the whole difference, and how an always-warm whole-drive index answers in 139 microseconds.

How to make Claude Code faster

The usual advice (smaller context, the right model, tighter prompts) helps at the margin. Measured on a 4.47M-file machine, the lever that actually moves the clock is giving Claude Code a real file index over MCP so it stops grepping: 6m 57s and 71 tool calls collapse to 16 ms and one.

Guides·Claude CodeCursor

How to give your AI safe access to your whole machine

An AI agent is blind to your disk until you wire it in, and the famous ways (Cursor, Glean) upload your files to do it. Here's the local-first alternative: whole-machine search through an MCP server where nothing ever leaves your machine.

Where your AI agent tokens actually go

You pay a $200 plan for reasoning, but on a real 4.47M-file session, about 58% of your agent's tokens go to finding files, not thinking. Here is the session token budget, drawn, and how to win back the other half.

The anatomy of an agent tool call

Every agent action is a tool call: six stages, and almost all the wall-clock hides in one (the disk hop) while the token bill hides in another (the bytes coming back). We trace all six on a 4.47M-file machine, show why Claude Code and Cursor both land on the slow stage, and collapse both: 93.8 s to 16 ms, 71 calls to 1, ~58% of tokens to ~0%.

Explainers·Claude Code

The layers of local AI infrastructure

Every LLM you run stands on five layers, and the one nobody names (context acquisition) is the bedrock holding up the rest. A field guide to the local AI stack, with the layers drawn as a diagram, and why Glean and Cursor are the same bet as Interlinked at a different scope.

Comparisons·Windows Search

Interlinked vs Windows Search

Windows Search takes 67 seconds to find a file on a 4.47-million-file PC. Interlinked finds it in 139 microseconds at ~44 MB idle, and the reason isn't clever code, it's coverage: index a slice of the drive and every miss becomes a slow walk of the rest.

Comparisons·CursorVS Code

Interlinked vs Cursor codebase index

Cursor indexes the one repo you opened; Interlinked indexes every repo plus the non-git 90% of your disk and serves all 19 agents. A scope-by-reach map shows why it isn't either/or - keep Cursor, add the machine-wide layer under it.

Explainers·CursorVS Code

What is a code index, and do you need one?

Sourcegraph, Cursor, and your IDE all build one, but what is a code index actually doing, and do you need your own? A plain-English guide that ends at the always-fresh, whole-machine index answering in microseconds across 4.47M files.

Comparisons·Claude CodeCursor

Claude Code vs Cursor: who gives the model better file context?

Claude Code greps your terminal; Cursor embeds the repo you opened. A fair look at how each feeds the model files, where each hits a wall, and the shared machine-wide index either can call.

Features·Claude CodeCursor

Not RAG. Not memory. The layer under both.

A vector database (RAG) and ChatGPT-style model memory are both approximations that live on the model's side and can't see your disk. The vault is a third thing: the exact, deterministic layer beneath both, keyed to the file's OS identity, fresh to the last save, every edge a receipt you can check, no model in the loop. The vault series, part 3.

Features·Claude Code

Receipts, not vibes: how the vault proves every connection

Copilot suggestions and credit scores are confident numbers you can't audit. Every relationship in Interlinked's vault names its evidence ("co-changed 6×", "shares 435 identical files"), checkable by hand in one step, with no model anywhere in the derivation.

Features·Claude CodeCursor

The machine gets biographies

Ask what all your repos are and today you get a directory listing: names and timestamps, no meaning. Interlinked reads each repo's own git history into an identity card (what it's about, active or dormant, where it pushes) for all 12 on the machine in 1.7 seconds, no LLM. And unlike git log or the GitHub Insights tab, it compounds every week. The vault series, part 3.

Explainers·ripgrep

What is grep? The 50-year-old tool your AI still uses

grep turns fifty this year, and your AI agent still shells out to it (and ripgrep) to find code, walking the whole disk on every query. A friendly history of the 1974 classic, how it actually works, and why an index answers the same query in 16 ms instead of 93.8 seconds.

Explainers·Claude CodeVS Code

How GitHub Copilot finds context in your code

GitHub Copilot builds its suggestions from the code around your cursor and the tabs you have open, with a workspace index behind Chat. A clear look at how it actually gathers context, what stays invisible (closed files, sibling repos, the non-git 90%), and the whole-machine index any agent can query.

Explainers·CursorClaude Code

What are embeddings, and do they help with code search?

Embeddings turn code into coordinates so an AI can search by meaning: the trick behind Pinecone-style RAG and Cursor. Here's the plain-English guide: what they are, where they genuinely win, and the honest catch: they're approximate and they drift as you edit, so staying fresh is a re-embedding job. Then the exact, deterministic lane that runs alongside: 93.8 s on ripgrep, 16 ms here, no model to drift.

How to set up an MCP server in Claude Code

Wiring an MCP server into Claude Code is one command: claude mcp add, restart, /mcp to confirm. This guide walks the config file, scopes, and transports, shows the same setup in Cursor, then arrives at the shortcut: one install auto-configures 19 AI clients at once, backed by whole-machine search that answers in 85 microseconds.

Explainers·VS Code

What is fuzzy file finding? (Ctrl+P, fzf, and friends)

Fuzzy finding (VS Code's Ctrl+P and fzf) lets you type a loose fragment and jump to the exact file. Here's what subsequence matching really is, why developers love it, and the assumption both tools make: they only match the small list already in hand. Across a whole 4.47M-file machine, the same gesture is an 85 µs lookup, not a disk walk.

The case for local-first AI developer tools

Cloud code search (Glean, Sourcegraph) uploads your repositories to answer a query. Local-first keeps the index on your machine: private, offline, and 412,000× faster than searching the same drive in VS Code.

How to find a file when you forgot its name

You forgot the filename, but you remember a line from inside the file. The move is to search by content, not name (PDFs and Office docs included) where Windows Search crawls and a warm content index answers in the 1 to 10 ms range.

Comparisons·ripgrepClaude CodeWindows Search

The best file search for AI agents in 2026

An AI agent has five ways to search your machine: ripgrep, Windows Search, fzf, the editor index, or an indexed MCP server. Ranked on speed, scope, freshness, and token cost, only one wins all four.

Explainers·Claude Coderipgrep

Do AI coding agents actually need a file index?

For a toy repo you don't need one: ripgrep is perfect. For a real multi-repo machine the math isn't close: the same search is 93.8 seconds to walk and 16 milliseconds to look up. Here's exactly where you cross the line, measured on 4.47M files.

Comparisons·Windows Search

Spotlight vs Windows Search: why desktop file search is still slow

macOS Spotlight and Windows Search both index only a slice of your disk, and both answer a person at a search box, not an AI agent. A coverage-and-exposure teardown of the two engines you already know, and why a purpose-built machine-wide index answers in 139 µs where Windows Search takes 67 seconds, exposed to every agent through one call.

Guides·VS CodeCursor

Why your editor search gets slower as your project grows

Ctrl+P slowing down as your repo grows isn't in your head: VS Code re-walks your workspace and Cursor re-embeds it, so search cost climbs with project size. A persistent whole-machine index measured across 4.47M files stays flat at 139 µs, no matter how big your project gets.

Why one slow tool call ruins a whole agent run

An agent run is a serial chain of tool calls, each waiting on the last, so a file-search floor measured in seconds doesn't cost you once, it compounds across every hop. One measured run made 71 of them and burned 6m 57s; the same work on a warm index is one call in 16ms.

What is an AI coding agent?

Claude Code and Cursor don't just answer questions. They loop: plan, call tools, edit, repeat. Here's how that loop actually works, and why finding files quietly eats most of it.

What is tool use (function calling) in LLMs?

Tool use - function calling - is the loop that lets an LLM call a real function, read the result, and keep going until the job is done. It's what turns a chatbot into an agent like Claude Code or GitHub Copilot, and why the slowest tool in that loop, file search, quietly sets the ceiling.

Explainers·AnthropicClaude Code

What is a token, and why token cost matters

A token is about four characters of text, and you're billed for every one, in and out. What tokens actually are, how LLMs meter them, and why an AI agent burns ~58% of a session just finding files.

Explainers·ripgrep

What is an inverted index?

Every fast search runs on one idea: don't scan, look up. The inverted index explained in plain English: the map from words to files that turns 93.8 seconds of grep into a 16-millisecond lookup.

Explainers·CursorClaude Code

What is a vector database, and do you need one for code?

A vector database turns text into coordinates and finds the nearest match by distance: the engine behind Pinecone-style RAG and Cursor. Here's how similarity search actually works, why it's approximate for exact code, and the exact lane it runs parallel to.

What is RAG (retrieval-augmented generation)?

RAG is how ChatGPT reads your PDF and how Pinecone grounds a chatbot: retrieve, then generate. The whole pipeline in one diagram - where it shines, and the one step where it quietly drifts on fast-changing code.

Explainers·Cursor

What is semantic search, and where it fails on code

Semantic search finds code by meaning, so it nails "where do we charge the card?" and buries the exact getUserById you typed. What it is, the one place it fails on code (with a same-query, two-engine diagram), and the exact-match lane beside it: the 93.8 s grep query a live index answers in 16 ms.

Explainers·VS CodeCursor

What is a language server (LSP)?

Every time you Ctrl-click a symbol and jump to its definition, a language server did that, for the one project you opened. Here is how LSP works, and the whole-machine layer that starts where it stops.

Explainers·VS CodeCursor

What is a monorepo, and why search gets hard

A monorepo is one repository for many projects, and search slows as it grows. The harder case is its opposite: separate repos that ship together, a release link no in-repo index can see.

Explainers·Claude Code

What is agentic search?

An AI agent almost never runs one search: it searches, reads a few hits, refines the query, and goes again, 71 times to find a single file in one measured run. Here's the search-read-refine loop drawn, and why the search primitive underneath it decides whether that costs 6m 57s or 16ms.

Explainers·CursorClaude Code

What is a context engine for AI coding?

Your AI model never sees your code, only what a context engine hands it. What that layer is, why it caps every answer, how Cursor and Glean each build one, and the whole-machine engine measured at 139 µs across 4.47M files.

Explainers·Windows Searchripgrep

What is file indexing, and why it beats scanning

grep re-reads all 4.47M files on every query; an index reads them once, then answers in milliseconds. The plain-English difference between scanning and indexing, drawn, and measured: 93.8s of grep versus 16ms indexed, same query.

Explainers·VS Code

What is incremental indexing (how search stays fresh)?

You save a file, search for it, and it isn't there yet. That's the freshness gap, and incremental indexing is the fix: update only what changed, the moment it changes. Instead of rebuilding on a schedule like Windows Search, a live machine-wide index makes a saved file searchable in about a millisecond, with a staleness-sawtooth diagram that shows exactly why.

Explainers·Windows Search

What is NTFS, and how Windows tracks your files

Your PC already wrote down every file it has, so why does finding one still take a minute? How NTFS tracks your files, and why a catalog the OS keeps for free unlocks whole-machine search in microseconds.

Explainers·VS Code

How does Ctrl+F actually work?

Press Ctrl+F and it feels instant, because it only scans the one page already sitting in your memory. Here's exactly what happens under those two keys, and why searching a whole drive is a completely different problem.

Explainers·VS CodeCursor

How does code autocomplete find suggestions?

Type a dot and a menu appears in milliseconds: that's a search over a tiny, local list of symbols. Here's exactly how IntelliSense and Copilot find suggestions, why both stop at your cursor, and the whole-machine retrieval an agent needs instead.

How does an AI agent decide which tool to call?

Before every step, an AI agent is handed a list of tools and picks one by reading their descriptions: plain English, matched to your task. Here's why the fastest file search on your machine is useless to an agent that can't find it in the list.

Explainers·Windows Search

How search engines index the web (and what your disk lacks)

Google's index is over 100 million gigabytes (tens of thousands of times bigger than your drive), yet it answers in under half a second, because crawl and index happen before you ever type. Your disk skips that layer, so Windows Search scans for 67 seconds where an index answers in 139 microseconds. The whole gap, in one diagram.

Comparisons·CursorVS Code

Cursor vs VS Code: what actually changed

Cursor is a fork of VS Code, so it inherited the exact same file search: the AI moved to the top of the stack while the retrieval floor stayed put. What the fork actually changed, where each editor fits, and the whole-machine layer both still need: 35 s to find one file on 4.47M, 85 µs with a warm index.

Comparisons·Claude CodeVS Code

Claude Code vs GitHub Copilot: two philosophies

Claude Code fetches code with shell tools; GitHub Copilot is fed what's around your cursor. Two philosophies with exactly opposite blind spots: reach without speed, speed without reach. We draw both context paths, measure the cost on a 4.47M-file machine, and land on the one index either can call.

Comparisons·CursorVS Code

Cursor vs GitHub Copilot: which understands your codebase?

Cursor indexes your whole workspace; Copilot completes from the tabs you have open, so Cursor sees one layer further, but a side-by-side scope map shows both go dark at the same two walls: the repo boundary and the cloud. Here's the fair verdict, and the machine-wide layer that fills the whole column in microseconds.

Comparisons·ripgrep

fzf vs ripgrep: finder vs searcher

fzf finds filenames, ripgrep searches contents: teammates, not rivals. When to reach for which, why both still walk the disk on every query, and the indexed layer that answers both in microseconds.

Comparisons·Cursor

Sourcegraph vs local code search

Sourcegraph and Glean put the index on a server your code has to travel to. A local index never leaves the machine, is fresh ~1 ms after every save, and answers all 19 agents in microseconds. The privacy, cost, and freshness math (drawn cloud-vs-local) and exactly where each one wins.

Comparisons·Claude CodeCursor

MCP vs plugins: how AI agents get new powers

A plugin upgrades one app; an MCP server upgrades every AI agent at once. Why the Model Context Protocol stays neutral across Claude Code, Cursor and 17 more, and how a single install reaches 19 clients with zero per-app plugins.

RAG vs fine-tuning vs context: how to give an LLM knowledge

Fine-tuning bakes knowledge into the weights, RAG embeds it into a vector store, context retrieves it fresh into the window. Here's the honest tradeoff across cost, freshness, and effort, and why exact retrieval is the one approach that keeps up with code.

Comparisons·Claude CodeCursorVS Code

The AI coding agent landscape in 2026

Five agents (Claude Code, Cursor, Windsurf, Cline, Copilot), but strip the logos and the field collapses into two ways of finding your code over one shared blind spot. A fair field guide to all five, and the whole-machine retrieval layer none of them ships.

Comparisons·ripgrep

grep vs find: which does what

find matches a file's name and attributes; grep matches the text inside, and both crawl the whole disk on every query. See the distinction in one picture, then the index that answers either question in microseconds: 85 µs by name, 16 ms by content, on 4.47M files.

How to cut your AI coding token bill

More than half of a coding session's tokens go to finding files, not writing them: ~58%, measured on a real 4.47M-file machine. The practical ways to cut your AI coding bill, led by the one lever that halves it: give the agent a real index so it stops grepping Claude Code and stops burning your Claude Max cap. With a token-bill before/after diagram.

Guides·CursorVS Code

How to search code across multiple repos

A function lives in one repo, is called from three others, and referenced in a script that was never committed, so you search each project separately and stitch the results by hand. Here's why per-repo tools like Cursor and Sourcegraph each stop short, and the one machine-wide index that spans every repo at once.

Guides·VS Coderipgrep

How to find every place a function is used

Find All References stops at your project; ripgrep stops where you point it. The honest answer to "where is this used?" spans every repo, config and script on the machine, and it can land in milliseconds.

How to search inside PDFs and Word docs

The phrase you remember is on page 7 of a PDF your scanner named scan_0032.pdf, and grep can't read it, because a PDF's text is encoded, not plain bytes. Full-text document search reads the words on the page: why Windows Search and Spotlight only cover a slice, why byte-scanners come up empty, and how to search inside every PDF, Word, Excel and PowerPoint file in about 5.6 milliseconds.

Guides·Cursor

How to speed up Cursor on a big codebase

Cursor drags on a big codebase because most of every turn is spent finding code, not writing it. Five settings that help today, then one warm, machine-wide index that lets Cursor, Claude Code and Copilot stop re-scanning the tree.

Features·Claude CodeAnthropic

How to give Claude Code lasting project memory

CLAUDE.md gives each repo its own memory island: blind to the others, and absent on the 90% of your disk that was never in git. Here's how to use it well, then add a machine-wide vault keyed to file identity that survives renames and every agent shares.

Guides·ripgrepCursor

How to search the git-ignored files your tools skip

ripgrep skips .gitignore by default and Cursor never indexes it, so .env, build output and datasets go dark exactly when you need them. A diagram of what git-aware tools skip, the flags that un-skip them, and the whole-disk index that never did: 93.8 s on ripgrep, 16 ms here, same query.

How to set up Claude Code for a large codebase

A large codebase never fits in the context window, so the whole game becomes retrieval. Here's the setup that stops Claude Code and Cursor from getting lost in a big repo (one fast index across every repo, not just the one you opened) that takes a single file-find from 6m 57s to 16ms on a real 4.47M-file machine.

Guides·Cursor

Why Cursor slows down on large repos

Open a small project and Cursor's index is invisible; open a monorepo and it drags. The reason is a cost that scales with the codebase (build it, keep it fresh, search it) set against the one flat line that never moves: 139 µs across 4.47M files.

Features·Claude CodeAnthropic

Why does my AI agent keep forgetting things?

AI agents forget because the context window is finite working memory that wipes at the end of every session. ChatGPT memory and CLAUDE.md each patch one leak: here's the mechanism in one diagram, and the file-keyed layer that survives the reset.

Why Claude Code makes so many tool calls

An agent with no index can't ask where a file is, only whether it's here, one folder at a time. That's why Claude Code fires 71 tool calls to open one file, and why a single indexed call ends the loop.

Explainers·Cursor

Why semantic code search misses the exact match

Search for getUserById and semantic ranking hands back getUserByEmail (similar, confident, wrong) while a real call site drops below the top-k cut. Why embedding search near-misses on exact symbols, and the case for a literal lane beside Cursor's, with the exact-symbol-vs-nearest-neighbor diagram.

The AI coding bottleneck is not the model

Models got fast and smart, so why do coding agents still crawl? On a 4.47M-file machine the slow layer isn't thinking, it's finding the file: ~58% of a session's tokens and 6m 57s to locate one. Fix the floor, not the ceiling.

Guides·Claude Coderipgrep

7 things quietly slowing down your AI coding agent

Six you can fix this afternoon. The seventh (file hunting) costs more than the other six combined. A ranked, measured teardown of what's actually slowing your coding agent, with Claude Code and ripgrep at the top of the list.

The tools every Claude Code user should install

Claude Code and Cursor ship with a terminal and not much else. Here's the short stack worth putting around them (six MCP servers and shell tools) and why whole-machine file search is the spoke most setups leave empty, on a machine where the agent quietly spends ~58% of a session just finding files.

Guides·Claude Coderipgrep

5 signs your AI agent needs a file index

Slow sessions, ballooning bills, a wall of tool calls, stale answers, repos it can't connect: five symptoms that all trace to one missing piece. A self-diagnosis checklist you can run in a single session, with the measured before-and-after.

Agents·AnthropicClaude Code

The hidden token costs of AI coding

Every AI coding session leaks tokens in five quiet places (file listings, re-reads, failed greps, bloated context, and retries) and not one of them is a line item on your bill. Measured on a 4.47M-file machine, file hunting alone eats about 58% of a session before a line of code is written. Here's the breakdown, and the math.

Benchmarks·Claude CoderipgrepWindows Search

We raced 5 ways to find one file. Here is what happened.

Same file, same 4.47-million-file machine, one stopwatch: we timed ripgrep, Windows Search, VS Code, and Claude Code against a pre-built index. Four took 35 seconds to three minutes; the index took 85 microseconds: a single dot on the start line while the others ran off the page.

How many tool calls does it take an agent to find one file?

We counted: Claude Code made 71 tool calls to open a single file (6m 57s and most of its token budget) because every blind call re-reads the last. Here's why the count compounds into minutes and dollars, and how a live index turns 71 into 1.

Agents·Claude Coderipgrep

The real cost of ls in an AI agent loop

To you a directory listing is instant and free. To your agent it's a recurring bill, read once, re-read every turn, and re-listed because nothing remembers it: ~58% of a session's tokens and 71 tool calls to find one file. The tax nobody budgets for, measured on 4.47M files, and the one index that sends it to zero.

Why 2026 is the year of local AI infrastructure

Agents run on your machine, privacy pressure is climbing, and no cloud round-trip can beat a lookup that never leaves. The case that 2026 is the year AI's foundation goes local, with the measured proof it already has.

Agents do not need bigger brains. They need better retrieval.

The frontier labs are racing to million-token context windows, but a huge context stuffed with directory walks and grep dumps reasons worse, slower, and pricier than a small one holding exactly the right files. Measured on a real 4.47M-file machine: ~58% of an agent's tokens go to finding files, and one retrieval call replaces 71 tool calls. A sharp case that retrieval quality, not context size, is the lever, with the two-context-windows diagram.

Comparisons·Windows SearchClaude Code

One company made Windows search fast for AI agents. It was not Microsoft.

NTFS shipped in 1993; thirty-three years later, Windows Search still takes 67 seconds to find one file on a real 4.47M-file drive. A warm whole-drive index answers the same query in 139 microseconds, and hands it to any AI agent.

Explainers·Claude CodeAnthropicCursor

Sam Altman predicted the one-person company. Here is the layer it runs on.

Sam Altman keeps predicting the first one-person billion-dollar company. Take it literally: it's a solo founder running a swarm of agents, and agents run on retrieval. Here is the measured layer they stand on: 6m 57s to find one file, or 16ms with an index underneath.

Karpathy called it vibe coding. The vibes still run grep.

Karpathy named the moment (describe software in English, let the agent build it) and it's real. But English never touches a disk: to act on the vibe, the agent still shells out to grep and walks 4.47M files (93.8 s, ~58% of its tokens), because the vibe layer is only ever as fast as the retrieval layer under it.

Software ate the world. Now agents are eating your tokens.

Marc Andreessen said software would eat the world. The sequel, measured on a 4.47M-file machine: agents eat software, and agents eat tokens: about 58% of one session spent finding files, not thinking, and a 6m 57s hunt that should have been 16ms.

Why is my AI agent so slow (and burning tokens)?

Your AI coding agent isn't thinking slowly: it's searching slowly. Measured on a 4.47M-file machine, roughly 58% of a session's tokens go to hunting for files instead of reasoning; the fix is a real index handed to the agent over MCP.

Comparisons·Windows SearchVS Code

Jensen Huang says every company is an AI company. They will all hit the same wall.

Jensen Huang says every company will become an AI company. Take him literally and they all hit the same wall: retrieval. We measured it: Claude Code burned 6m57s and ~58% of its tokens to find one file; an index answers in 16ms.

Jul 4, 20268 min

Satya Nadella called it the age of copilots. Copilots still cannot find your files.

Satya Nadella called it the age of copilots, but every copilot answer starts by finding a file, and on a real 4.47M-file drive Windows Search still needs 67 seconds. A live whole-machine index does the same lookup in 139 microseconds, about 480,000× faster.

Jul 4, 20266 min