59.2×
faster to a completed Kodi index
11.624 seconds versus 688.114 seconds across the two persistent indexers in the formal four-product comparison. Same completion boundary.
Your agent hits the context wall
before it hits the bug.
Forty file reads into a task it compacts, forgets half the plan, and restarts the same grep → wrong file → try again loop it ran yesterday. You paid for every one of those reads - and the part that got dropped was the part where it understood your code.
Atlas Scout is a local, read-only MCP server. It hands Claude Code, Codex, and anything else that speaks MCP the exact symbols, source ranges, references, and relationships in your codebase - before they start opening files.
The model got token-efficient. Your retrieval didn’t.
Every model release makes tokens cheaper per unit. Not one of them changes what those tokens are spent on: context is still the budget, most of the window still goes on finding code rather than changing it, and discovery is the first thing summarised away - so tomorrow it happens again. Token efficiency has to start before the model, in how the working set is retrieved. Watch the cost compound through one task:
- Twenty reads in
- The context window is full of files it opened to find out they were the wrong files. The one line that mattered went past on page one of a 2,000-line skim. From here it gets measurably worse at the actual task.
- Then it compacts
- The plan, the constraints, the three things you told it not to break - summarised away. What survives is the shallowest version of everything it learned. You are now paying it to learn the same repository a second time.
- Then it does it again tomorrow
- Nothing carried over. New session, same grep, same wrong file, same detour you watched yesterday. Your codebase is the one thing in the loop that never gets remembered.
- And you find the rest in review
- It changed a function without knowing about four of its callers, because nothing it could reach would have told it. That one is not a token problem. That one ships.
Move discovery off the context window
Atlas Scout keeps a persistent local map of your codebase - symbols, references, relationships, and exact source ranges - and answers structural questions in one tool call: the right file, the exact lines, the real connections. The searching happens in the index. Only the answer reaches the model. That is what token-efficient retrieval means in practice - what your agent pays for is the answer, not the search that found it.
$ atlas-scout index .
indexed in seconds - your source files untouched
agent> where is lease verification, and who calls it?
verify.ts:44 verifyLease() - 9 references, 3 callers (one call, 40 lines read)
$ ▮Local, read-only, and deterministic - not an embedding search that returns plausible chunks. Works with Claude Code, Codex, Devin, Neovim, VS Code, and anything that speaks MCP.
Questions grep cannot answer
Atlas Scout is not a faster grep. Text search can approximate where does this string appear. It cannot answer any of the questions below - which is exactly why an agent armed only with grep has to guess, and why the guesses reach your diff.
| The question your agent needs answered | One call | Edition |
|---|---|---|
| Where is this defined? I only half-remember the name. | symbol_search | Free |
| What is in this file, without reading 2,000 lines? | symbol_outline | Free |
| Which of the five same-named symbols is this one? | symbol_resolve | Free |
| Who calls this, and what does it call? | symbol_references | Free |
| Where is this route, env var, config key, or theme token? | semantic_anchor_search | Free |
| Is that empty answer real, or is the index still warming? | symbol_schema | Free |
| Which few files should I read first for this task? | fast_context | Pro |
| What breaks if I change this - and which tests cover it? | edit_impact | Pro |
| How does this symbol actually reach that one? | symbol_path | Pro |
| Trace the call chain, inbound or outbound, from here. | symbol_trace | Pro |
| Show me the structural neighbourhood around this. | symbol_graph | Pro |
| What is related to this, and by what evidence? | symbol_related | Pro |
| How is this subsystem arranged, file by file? | symbol_architecture | Pro |
| Give me every symbol matching these structural filters. | symbol_query | Pro |
Fourteen tools across twenty-plus languages. Six are free forever, on the complete index, with no account and no quotas. The other eight are what turn “find it” into “understand it before you touch it.” See what Pro adds
Modern web stacks get structural treatment too: HTML maps dependencies, custom elements, IDs, and HTMX routes; PHP adds calls, type relationships, traits, and Laravel-style routes. Astro, Vue, Svelte, JSX, and TSX carry that markup awareness across framework boundaries. See the exact language boundaries
What changes for you
- Tasks finish sooner
- The agent gets the smallest correct working set handed to it in one turn, instead of assembling it over twenty reads.
- The context lasts longer
- Bounded answers with exact source ranges replace file dumps. Less noise in, better answers out - and further into the task before anything gets summarised away.
- You can trust the edits
- Before a change, the agent sees every caller and everything the change touches. No more surprise breakage found in review.
- Every tool shares the work
- One workspace map serves your agent, the CLI, Neovim, and VS Code at once - index once, query from everywhere, with your unsaved buffers counted too.
Install freeCompare Free and ProSix navigation tools, the complete index, no account, no quotas, forever.
Measured, not promised · frozen runs · public evidence
The receipts
Everything above is a claim. This is the evidence - locked large-corpus release campaigns, a formal four-product comparison, and real agent sessions, published with the failures, boundaries, and hashes beside the wins.
The run without Scout shipped it half-done
Two agents, same commit, same prompt: replace a hard-coded subscription promotion with admin-managed campaign data. Both passed typecheck, lint, and their tests. Only the run with Atlas Scout found all three customer-facing surfaces; the baseline shipped with two live promotion surfaces left behind. On a separate large Go task, Codex with Scout finished in 38% less wall time, with 35% fewer processed tokens and 48% fewer shell executions. Neither task prompt named Scout or any of its tools - both hosts discovered and used it on their own.
Preview 5 case studies: one paired run per host and task. The patches were independently validated but not identical, and a single pair is a sample, not an expected average.
21/21
Scout-assisted answers earned full credit
Every assigned Scout run across the original and extension agent campaigns returned useful structural evidence.
73.2%
lower provider cost than shell-only
In the Claude Code lane, the Scout median also used 66.8% less total input and 55.8% less output - the only Claude cell with 3/3 full-credit answers.
4/4
new model lanes led on time and token efficiency
Lowest median whole-agent time, total input, and output in Claude Opus 5 and all three OpenCode lanes.
It holds up where shortcuts fail
Firefox - 356,923 files, 4.34 million symbols - indexes fresh in about four minutes, with exact symbol lookup at 1.18ms p50. The Linux kernel answers a 500-request agent workload in 8.14 seconds across 4.78 million symbols, and Preview 22 cut roughly a quarter from the disk, memory, and write cost of those large-corpus indexes. The guidance also survives delegation: in a real 19-subagent workflow, every delegated agent received Scout’s routing context, and they made 17 structural calls of their own.
This is what it looks like when it’s working
A real Codex session on a real Rust codebase: one symbol_outline, a burst of targeted symbol_search calls, and straight to work. Every answer arrives with its own receipts - index fresh, 105 files, 2,712 symbols, nothing truncated - so the agent knows it can trust what it just learned. No grep in sight.
What it does not do to you
- It does not guess
- When Atlas Scout cannot prove a relationship, it returns it as unresolved. It never promotes a same-name coincidence into a call edge. For an agent, a confident wrong answer is worse than no answer - it acts on both.
- Nothing leaves your machine, nothing gets executed
- Indexing, resolution, ranking, and every query run locally, and every tool is read-only and non-executing - no builds, no package scripts, no test runs, no git hooks. Licence checks never carry source, paths, symbol names, queries, or git remotes.
- Your source files are untouched
- One gitignored map at .atlas/scout/, generated from your code and never a copy of it. Nothing to commit. Delete it whenever you like and rebuild in seconds.
- Free is not a demo
- Same extractor, same index, same freshness and ranking logic as Pro. No quotas on symbols, languages, repositories, or queries. No account, no card, no expiry.
The fastest install is the one your agent does itself
Read https://atlasscout.dev/atlas-scout.md and follow it to set up Atlas Scout.- Paste that line into your coding agent.
- It installs, indexes your project, and wires itself into your MCP host.
- From the next session on, it navigates instead of guessing.
- Fetch the skill and follow it end to end - it covers install, verify, and index.
- Register the MCP server for your host and add the navigation block to AGENTS.md.
- Use the structural tools first; fall back to text search only when they miss.
Prefer a page you can send to a teammate? atlasscout.dev/install has the agent line, the manual script, and the verification steps in one place.
You don’t have to read the code for this to work
If your agent writes most of your code, Atlas Scout is leverage you never have to think about: install it once, and every session your agent stops guessing at file names, stops breaking functions it didn’t know were used elsewhere, and stops burning your budget re-reading the same files. You don’t need to know what an index is. Your agent does - and it shows up smarter.
Common questions
- What is an MCP server for code navigation?
- An MCP (Model Context Protocol) server is a local or remote process that exposes tools to an AI coding agent. A code-navigation MCP server answers structural questions about a repository - where a symbol is defined, who calls it, what breaks if it changes - so the agent does not have to grep and read whole files to find out. Atlas Scout is one: it keeps a persistent local index and returns exact source ranges in a single tool call.
- How does Atlas Scout reduce my agent’s token usage?
- Discovery happens inside the index rather than inside the context window. Instead of running grep, opening the wrong file, and skimming 2,000 lines, the agent makes one call and receives the right file and the exact lines. In a published benchmark against shell-only navigation in Claude Code, the Atlas Scout median used 66.8% less total input, 55.8% less output, and 73.2% less provider cost, and was the only Claude cell with 3/3 full-credit answers.
- Does Atlas Scout send my source code anywhere?
- No. Indexing, resolution, ranking, and every query run locally on your machine. There is no repository telemetry, and licence checks never carry source, file paths, symbol names, queries, or git remotes. Every tool is read-only and non-executing: it never runs builds, package scripts, tests, or git hooks.
- Which agents and editors does Atlas Scout work with?
- Anything that speaks MCP, including Claude Code, Codex, OpenCode, Cursor, Devin, Neovim, and VS Code. One workspace index is shared across all of them - including your unsaved buffers - so you index once and query from everywhere.
- Is Atlas Scout free?
- Yes, permanently. Six of the fourteen MCP tools are free forever on the complete index, with no account, no card, no expiry, and no quotas on symbols, languages, repositories, or queries. Free uses the same extractor, index, freshness, and ranking logic as Pro. Pro adds eight connected-analysis tools such as edit impact, call tracing, and architecture views.
- Does Atlas Scout help on a brand-new project?
- Not until there is code in it, and it does not pretend otherwise. Atlas Scout maps code that already exists: on an empty repository there is nothing to index, no symbols to look up, and no callers to report - it cannot send your agent evidence that does not exist yet. Its value grows with your codebase, and it matters most on established projects, where the cost of rediscovering structure is highest.
- How is this different from embedding or vector code search?
- Atlas Scout is deterministic rather than probabilistic. It returns resolved structural facts with exact source ranges, not plausible-looking chunks ranked by similarity. When it cannot prove a relationship it returns it as unresolved rather than promoting a same-name coincidence into a call edge - which matters for agents, because a confident wrong answer and a correct one are both acted on.