Field guide · comparisons · measured July 2026 · 8 min
The AI coding agent landscape in 2026, mapped by how each one finds your code.
Claude Code, Cursor, Windsurf, Cline, Copilot: the names multiply every month. Strip the logos and the field sorts into a startlingly small shape: four of the five run on top of the same editor, every one speaks the same tool protocol, and each finds your code one of just two ways. This is a fair field guide to all five (what each is built on, how each retrieves) and the single piece of infrastructure the whole landscape is missing.
TL;DR · key takeaways
Five agents (Claude Code, Cursor, Windsurf, Cline, Copilot), but four run on VS Code, all five speak MCP, and each finds your code one of just two ways: grep the files (literal) or embed the repo (semantic).
Both camps share one blind spot: none keeps a warm index of the whole machine. The non-git ~90% of the disk (configs, docs, datasets, the sibling repos that ship together) sits outside every per-repo index.
The cost is measured, not asserted: on a 4.47M-file Ryzen 9 9950X3D, one whole-machine file hunt cost Claude Code 6 m 57 s across 71 tool calls and ~58% of the session's tokens; for content, ripgrep read every byte: 93.8 s on a single query.
Interlinked is that missing floor: an always-fresh index of every filename and every file's contents, handed to every agent through one MCP connector. A filename lands in 85 µs (139 µs median); the content query ripgrep took 93.8 s on returns in 16 ms (58,625×); one warm call replaces 71 (~7,200,000×, and ~58% → ~0% of tokens).
No model in the box: it runs offline at ~44 MB idle, and a saved edit is searchable in ~1 ms. Everything is free forever, no card. Hosting starts at $5.99/mo.
The field guide · five agents
Two anchors, three more, one honest table.
None of these is a bad tool: each is well-built for the job it was designed around. The useful way to tell them apart is not the marketing; it is how each one gets code in front of the model. Claude Code and Cursor are the two anchors, the honest ceilings of the two approaches everyone else clusters near.
Runs shell tools (grep / ripgrep, ls, glob, read) against the live disk, fresh on every query.
Reaching any file on the machine with zero setup.
No warm index: it re-walks the disk to answer.
Embeds the repo you open into a vector index in its cloud, then matches your question by meaning.
“Find the code that does X” inside one repo.
The index stops at the workspace you opened.
Indexes the open codebase for retrieval and matches by meaning, feeding its Cascade agent.
Semantic recall inside the active project.
Bounded by the same open-workspace edge.
Reads and searches files directly with editor tools, no vector index of its own.
Transparent, in-editor file operations.
Nothing warm to ask: it re-reads each time.
Pulls workspace context from a project index plus code search to answer in-editor.
In-editor suggestions grounded in the repo.
Scoped to the workspace it was pointed at.
Every mechanism above is public in each tool's own documentation: Cursor and Windsurf's codebase indexing, Copilot's workspace context, Claude Code and Cline's file-and-shell approach. No timing is assigned to a tool we did not measure directly.
The landscape, on one map
Five agents. Two ways to look. One floor.
Read it top to bottom. At the surface are the agents you choose between. Trace each one down and it lands in one of two camps: grep the files or embed the repo. Both funnel through MCP, the open protocol they all speak, into the layer at the bottom of the map: the whole machine, the one neither camp keeps warm.
Four of the five run on VS Code. All five speak MCP. None keeps a warm index of the whole machine, the floor at the bottom of the map.
What the whole map shares
Different front doors. The same missing floor.
The logos suggest a crowded, fragmented market. The map says otherwise. Underneath the branding, the landscape shares three things, and the third is a gap wide enough to build a company in.
It is mostly one editor.
Cursor and Windsurf are forks of VS Code; Cline and Copilot are extensions to it. Only Claude Code stands alone, in the terminal. The variety in the logos is mostly one code editor wearing different faces, which is why they feel familiar the moment you open them.
They all speak MCP.
Every major agent now speaks the same open tool protocol. That is the quiet unlock: a capability you add once (an index, a converter, a knowledge store) becomes available to all of them at the same time, without integrating with each one separately.
They all need retrieval, and none owns the machine.
Every agent's first move is identical: find the right code to hand the model. The semantic camp stops at the open workspace; the literal camp re-reads a cold disk. The non-git ~90% of the drive (configs, docs, datasets, the sibling repos that ship together) is invisible to all five. The one piece of shared infrastructure the whole landscape needs is the one none of them ships.
Shell reach is unbeatable: it can touch any file. The wall is that there is nothing warm to ask. On our 4.47M-file drive, one file hunt ran 6 m 57 s across 71 tool calls and burned ~58% of the session's tokens before it opened the right file. A single by-name lookup measured 193.5 s. For content it shells out to ripgrep (the fastest grep there is) which still read every byte: 93.8 s on one query here.
The embedding index is genuinely good at “find the code that does X” inside the repo you opened, a different job from an exact lookup, and a correct design for an in-editor assistant. The wall is the workspace boundary. The sibling repos that ship alongside it, and the roughly 90% of the disk that was never in git, sit outside the index. When the question crosses that line, the agent falls back to the same place everyone does: a grep over a cold disk.
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Claude Code figures are the measured agent runs; the ripgrep figure is a content query over the same corpus. Cursor's mechanism and scope are drawn from its public documentation: no time is invented for it. Full per-tool method in How Claude Code finds files and How Cursor indexes your codebase.
The floor the map was missing
One index. Every agent. The whole machine.
Interlinked draws the bedrock at the bottom of that map. It keeps an always-fresh index of every filename and every file's contents across the whole machine (every repo, plus the non-git 90% a working-directory grep never sees) and exposes it to whatever agent you use through one connector. It is not a semantic index and does not try to be: it is the fast, literal, exhaustive layer that answers “does this exact string exist anywhere on this machine?” in the time Cursor takes to notice you pressed a key. Complementary to the embeddings; a warm floor under the shell tools.
And no model in the box. The speed comes with memory it derives itself.
The same index carries a knowledge vault, relationships it works out from your own history: files that change together, repos that share hundreds of identical files, which project is alive and which went dormant, plus notes any agent leaves that every other agent reads. Every edge is receipts you can check: counts and hashes, never a model's guess. It runs offline and never leaves the machine. On a fresh install, day one:
For scale on the same drive: that filename lookup takes VS Code's own search about 35 seconds (412,000× slower) and Windows Search a median 67 seconds (~480,000×). Content search runs in the ~7 to 9 ms range: about 9 ms for common words, 7 ms for rare symbols, and 16 ms for exact phrases. 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, and the index on disk stays under 1% of the drive, about 24 GB on a 4 TB machine. The engine behind these numbers is now validated: crash-free, with correct ranking across roughly 1,500 queries. There is no model anywhere in the box.
ONE INSTALL CONFIGURES 19 AI CLIENTS, INCLUDING ALL FIVE ON THIS MAP.
Do this today
Keep your agent. Add the floor.
Install once. One signed installer indexes every file on your machine and auto-configures 19 AI clients: Claude Code, Cursor, Windsurf, Cline, Copilot and the rest. No JSON editing, no cloud account, no keys.
Change nothing about your setup. Nobody has to drop Cursor's index or leave the terminal. Every agent on the map keeps its own strength, and gains a fast, literal, whole-machine lookup alongside it, through the MCP they already speak.
Scope when you can. Whole-machine when you don't know where something lives; scoped to a folder when you do. Scoped queries return in the microsecond range.
Ask across the machine. Then ask any agent “which repos do I have, and how do they relate?” and watch it see the sibling projects and the non-git 90% that lived outside every per-repo index.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows · The five ways an agent finds a file, ranked
Common questions · FAQ
Common questions. Straight answers.
The same handful of questions come up about the map, the numbers, and the floor underneath it, answered here with the measured figures.
What are the main AI coding agents in 2026, and how do they differ?
Claude Code, Cursor, Windsurf, Cline and Copilot. Four of the five are built on VS Code (Cursor and Windsurf are forks, Cline and Copilot are extensions) and only Claude Code stands alone, in the terminal. The real difference is retrieval: the literal camp (Claude Code, Cline) greps files live with no warm index, while the semantic camp (Cursor, Windsurf, Copilot) embeds the open repo and matches by meaning.
What is the one piece of infrastructure all five are missing?
A warm index of the whole machine. The semantic camp stops at the workspace you opened; the literal camp re-reads a cold disk on every query. The non-git ~90% of the drive (configs, docs, datasets, the sibling repos that ship together) is invisible to all five.
How much slower is grepping the whole machine than a warm index?
On a 4.47M-file Ryzen 9 9950X3D, one whole-machine file hunt cost Claude Code 6 m 57 s across 71 tool calls and ~58% of the session's tokens. A warm index answers the same question in a single call at 16 ms, about 7,200,000× faster, and ~58% → ~0% of tokens. A by-name lookup lands in 85 µs (139 µs median), and the content query ripgrep spent 93.8 s on returns in 16 ms (58,625×).
Do I have to switch agents or drop Cursor's index to use it?
No. It rides parallel through MCP, the protocol all five already speak: one install auto-configures 19 AI clients. Every agent keeps its own strength (Cursor its embeddings, Claude Code its shell reach) and gains a fast, literal, whole-machine lookup alongside it. It is complementary to semantic search, not a replacement.
Is there an LLM or embeddings inside it, and what does it cost?
No model anywhere, just an index and a path/id match, running offline at ~44 MB idle, with a saved edit searchable in ~1 ms and nothing ever leaving the machine. Everything is free forever, no card. Hosting starts at $5.99/mo.