Code intelligence stopped being a search feature

Overview

A 2026 Codebase-Memory study reports that a Tree-sitter-based knowledge graph exposed through MCP reduced agent token use by roughly 10x and tool calls by 2.1x across 31 repositories. That single result explains why code intelligence became a first-order design problem for AI coding agents: the index is no longer just a developer convenience, it is a cost, latency and accuracy control plane.
Sources: arXiv (2026)

From mid-2025 to early June 2026, the field moved away from “ask the model, grep the repo, read files” towards structured context layers. Local tools built repo maps from Tree-sitter, ctags-like symbol extraction, SQLite full-text indexes and embedded graph stores. Enterprise tools doubled down on SCIP-style semantic indexing, code knowledge graphs, history-aware search and central services that many agents can query.
Sources: Aider (2025) (↗); Coograph docs (2026) (↗); KotaDB (2026) (↗); Sourcegraph docs (2025) (↗)

The defining shift was not one storage engine or one benchmark. It was the arrival of a repeatable pattern: precompute structure, expose it as tools, and let agents query narrow facts rather than burn context on broad file reads. MCP became the most visible transport for that pattern, while LSP, SCIP, Tree-sitter, vector search and graph databases supplied different kinds of truth underneath.
Sources: Thoughtworks Technology Radar Vol. 32 (2025) (↗); Anthropic (2025) (↗); Sourcegraph MCP (2026) (↗)

This matters because coding agents are becoming longer-running and less IDE-bound. GitHub, OpenAI and Anthropic all pushed agentic coding workflows in 2025, while Gartner and Stack Overflow still showed that most organisations kept autonomy constrained and monitored. That gap created demand for better grounding: agents need enough code context to act, but organisations need limits, provenance and auditability.
Sources: GitHub Newsroom (2025) (↗); OpenAI (2025) (↗); Anthropic (2025) (↗); Gartner (2025); Stack Overflow (2026)

Q1 2025

• Chat plus precise code search becomes an enterprise platform pattern

Q2 2025

• MCP enters mainstream developer tooling
• Background coding agents become visible
• Tree-sitter repo maps mature

Q3 2025

• LSP-to-MCP bridges emerge
• Graph plus vector retrieval gains agent use

Q4 2025

• Context engineering replaces prompt-only coding workflows
• MCP becomes a default integration assumption

Q1 2026

• Local code graphs report token and tool-call savings
• SCIP and in-house code intelligence costs move into public debate

Q2 2026

• Enterprise MCP code intelligence expands
• Frontier coding benchmarks face validity pressure

Sources: Sourcegraph blog (2025) (↗); InfoQ (2025) (↗); GitHub (2025) (↗); Aider (2025) (↗); Serena / GitHub repo (2025) (↗); Kuzu blog (2025) (↗); Thoughtworks blog (2025) (↗); arXiv (2026); Sourcegraph (2026) (↗); Sourcegraph MCP (2026) (↗); OpenAI (2026) (↗)

Key findings

1. Local indexes became small services, not just files

The local tooling lane converged on repo maps that extract symbols, definitions, call sites and file relationships before the agent starts work. Aider’s Tree-sitter repository map, RepoMapper and codeindex represent the lightweight end: parse code, rank important symbols, and compress the repo into an agent-readable map. Coograph and KotaDB show the next step, persisting local code intelligence in SQLite-style stores, including full-text search and structured records.
Sources: Aider (2025) (↗); Open source (2025) (↗); Open source (2025) (↗); Coograph docs (2026) (↗); KotaDB (2026) (↗)

The storage models now form a rough ladder. The simplest tools keep ctags-style text maps or JSON symbol tables. More durable tools use SQLite, FTS5 and on-disk caches. Graph-native tools use embedded stores such as Kuzu, often with full-text and vector indexes beside graph traversal.
Sources: KotaDB (2026) (↗); Kuzu blog (2025) (↗); Kuzu blog (2025) (↗); Kuzu GitHub repo (2025) (↗)

2. MCP standardised access, not intelligence

MCP became the agent-facing interface for code context. GitHub put an MCP server into public preview, VS Code added full MCP support, Anthropic added remote MCP support in Claude Code, and Sourcegraph exposed enterprise code intelligence through MCP. Thoughtworks moved MCP through successive Radar volumes as a serious agent-integration primitive.
Sources: InfoQ (2025) (↗); GitHub (2025) (↗); Anthropic (2025) (↗); Sourcegraph MCP (2026) (↗); Thoughtworks Technology Radar Vol. 32 (2025) (↗); Thoughtworks Technology Radar Vol. 34 (2026) (↗)

The important qualification is that MCP only defines how an agent calls tools. It does not decide whether a “find references” result came from a real language server, a Tree-sitter approximation, a stale embedding index or a vendor knowledge graph. This distinction explains why MCP adoption looks strong while accuracy evidence remains uneven.
Sources: Anthropic (2025) (↗); Serena / GitHub repo (2025) (↗); Sourcegraph resource page (2026) (↗)

3. LSP-to-MCP bridges gave agents an IDE brain

Serena is the clearest 2025 example of the LSP-to-MCP bridge pattern. It exposes semantic code retrieval and editing as MCP tools, using language-server capabilities for symbol lookup, references and code-aware edits. Agent-lsp and lsp-mcp point in the same direction, while multilspy provides earlier infrastructure for driving language servers programmatically.
Sources: Serena / GitHub repo (2025) (↗); Anthropic Claude plugin page (2026) (↗); agent-lsp (2026) (↗); Open source (2025) (↗); GitHub (2024)

This approach wins when names matter: go to definition, find references, inspect a type, rename a symbol or constrain an edit to a real declaration. It weakens when the language server cannot initialise, the build graph is broken, generated code is missing, or the project’s dependency state differs from the index. The public evidence for these bridges is still mostly repository documentation, tool listings and practitioner write-ups rather than controlled accuracy studies.
Sources: Serena / GitHub repo (2025) (↗); GitHub (2026); Medium (2026); Arda Kılıçdağı (2026)

4. Enterprise code intelligence stayed semantic and centralised

Large organisations cannot ask every agent worker to rebuild a whole monorepo index. Sourcegraph’s 2025 and 2026 materials describe code intelligence as a platform spanning search, chat, precise navigation, history and cross-repository context. Its SCIP documentation positions the protocol as language-agnostic structured indexing for precise code navigation.
Sources: Sourcegraph blog (2025) (↗); Sourcegraph docs (2025) (↗); Sourcegraph documentation / GitHub (2024); Sourcegraph (2026) (↗)

Sourcegraph’s own comparisons argue that SCIP and code graphs are more precise than text search or embeddings for exact navigation. That is a vendor claim, but it matches the technical trade-off: embeddings can find related intent, while semantic indexes store the specific symbol relationships that impact analysis and refactoring require.
Sources: Sourcegraph resource page (2026) (↗); Sourcegraph blog (2026) (↗)

5. Hybrid retrieval became the serious default

The academic lane strongly supports hybrid systems. RANGER uses graph-enhanced retrieval for repository-level agents, SemanticForge frames generation through semantic knowledge graphs and constraints, GRACE uses graph-guided repository-aware completion, and RepoScope uses call-chain-aware multi-view context. These systems differ in implementation, but they all reject pure chunk retrieval as enough for repository work.
Sources: arXiv (2025); arXiv (2025); arXiv (2025); arXiv (2025)

The practical division is now clear. Tree-sitter and AST methods are cheap, local and broadly portable, but they miss full type and build semantics. LSP and SCIP methods are more exact, but they cost more to maintain and depend on language tooling. Embeddings and learned sparse retrieval improve natural-language discovery, but they need graph or reranking constraints when the task depends on exact dependencies.
Sources: arXiv (2026); arXiv (2025); arXiv (2025); Relace (2025)

6. Impact analysis is where graphs start to pay rent

Enterprise buyers care less about pretty repo maps than about blast radius, affected tests and safe change automation. DEX’s map-first code intelligence emphasises repo-derived impact analysis, while Sourcegraph’s MCP and Deep Search materials emphasise cross-repository search, navigation and history. Academic work on call chains and repository graphs points in the same direction.
Sources: DEX (2026) (↗); Sourcegraph MCP (2026) (↗); Sourcegraph Deep Search (2026) (↗); arXiv (2025); arXiv (2026)

This is also where syntactic maps stop being sufficient. A call edge from an AST may be useful, but production impact analysis often needs build targets, generated code, test ownership, package metadata, feature flags and deployment history. The sources show the direction of travel, but not yet a common benchmark for enterprise blast-radius accuracy.
Sources: Sourcegraph blog (2026) (↗); arXiv (2025)

7. IDE indexes won the human loop, but headless agents need shared indexes

IDE-native code intelligence remains powerful because it sits where developers already edit and review code. Cursor’s rapid uptake, VS Code’s MCP support, JetBrains’ MCP work and Kiro’s built-in Tree-sitter repo map all show that editor indexes are becoming agent tools, not just UI features.
Sources: Bloomberg (2025); GitHub (2025) (↗); JetBrains Blog (2025); JetBrains Blog (2026); Kiro docs (2026) (↗)

Headless agents create a different requirement. A multi-agent worker pool needs one index artefact or one query service, otherwise every worker repeats parsing, search and file reading. MCP makes shared access easier, but it also turns index freshness, permissions and audit logs into operational concerns.
Sources: Sourcegraph MCP (2026) (↗); Anthropic (2025) (↗)

8. The evidence base lags the product race

The most concrete local-indexing result is Codebase-Memory’s reported 10x token reduction and 2.1x fewer tool calls on 31 repositories. That is promising, but it is one system, one evaluation design and one paper. Many local code-graph tools present plausible architectures rather than replicated measurements.
Sources: arXiv (2026); Coograph docs (2026) (↗); Medium (2026)

Evaluation pressure is also rising from the other side. OpenAI said SWE-bench Verified no longer measured frontier coding capabilities well enough, while METR’s HCAST and time-horizon work pushed evaluation towards calibrated task difficulty and longer autonomous work. This matters because a code index can look good on search recall while still failing on sustained software change.
Sources: OpenAI (2026) (↗); METR / PDF (2025); METR blog / analysis (2025)

9. Security became part of code intelligence

Code indexes are sensitive assets. They compress architecture, secrets-adjacent references, dependency paths, ownership signals and history into an agent-readable interface. Remote MCP support and enterprise MCP servers increase the value of shared context, but they also widen the surface for permissions mistakes and data exposure.
Sources: Anthropic (2025) (↗); Sourcegraph MCP (2026) (↗); Bloomberg (2026)

Security and monitoring sources now sit beside capability sources. Anthropic’s sabotage-risk work, OpenAI’s reporting on malicious AI use and DeepMind’s Gram all indicate that more capable coding agents need stronger observation and control. Code intelligence does not solve that problem, but it determines what the agent can see and therefore what it can damage.
Sources: Anthropic (2026) (↗); OpenAI (2025) (↗); Google DeepMind (2026) (↗)

Evidence and data

The strongest efficiency number is Codebase-Memory’s 10x token reduction and 2.1x reduction in tool calls across 31 repositories. Treat it as directional rather than settled, because the sweep did not surface several independent replications with different languages, repo sizes and agent harnesses.
Sources: arXiv (2026)

The adoption numbers show strong assistant uptake but limited full autonomy. Gartner projected that 75% of enterprise software engineers would use AI code assistants by 2028, up from less than 10% in early 2023. The same analyst house separately reported that only 15% of IT application leaders were considering, piloting or deploying fully autonomous AI agents in 2025.
Sources: Gartner (2025); Gartner (2025)

The market signal is broad but not specific to code graphs. Bloomberg reported Cursor had drawn a million users by April 2025, Reuters covered OpenAI’s push to expand Codex into large companies through consultancies, and Stack Overflow’s 2026 analysis described workplace agent use as mostly single-agent and monitored. These data points support the need for shared code context, but they do not prove that any given index architecture pays for itself.
Sources: Bloomberg (2025); Reuters (2026); Stack Overflow (2026)

The protocol timeline is clearer than the accuracy timeline. GitHub’s MCP server entered public preview in April 2025, VS Code added full MCP support in June 2025, and Anthropic added remote MCP support in Claude Code later that month. The tool access layer matured quickly, while the measurement layer for semantic accuracy, latency and maintenance cost stayed fragmentary.
Sources: InfoQ (2025) (↗); GitHub (2025) (↗); Anthropic (2025) (↗)

Signals and tensions

1. Semantic precision costs money and maintenance. SCIP, LSP and build-aware systems answer exact symbol questions better than embeddings, but they require language-specific tooling, indexing pipelines and operational care. Sourcegraph’s in-house code intelligence piece makes that cost visible, and Serena-style bridges inherit the language server’s limits.
   Sources: Sourcegraph blog (2026) (↗); Sourcegraph docs (2025) (↗); Serena / GitHub repo (2025) (↗)

2. Syntactic maps are underrated because they are boring. Tree-sitter repo maps, SQLite symbol stores and ctags-like summaries often give enough structure for small-to-mid repositories at low cost. They do not need a build, and that matters when agents work on unfamiliar or broken projects.
   Sources: Aider (2025) (↗); Coograph docs (2026) (↗); Kiro docs (2026) (↗)

3. Embeddings remain useful but over-sold when used alone. Learned sparse retrieval, dual-encoder repository search and embedding-plus-rerank systems improve discovery, especially for natural-language queries. They still need structural constraints when the answer depends on a real call path, symbol binding or dependency edge.
   Sources: arXiv (2026); arXiv (2025); arXiv (2025); Relace (2025)

4. MCP creates composability before it creates trust. The protocol lets agents call tools consistently, but it does not expose a universal confidence model, freshness model or provenance contract for code facts. That gap becomes serious when several agents share one index and act in parallel.
   Sources: Anthropic (2025) (↗); Sourcegraph MCP (2026) (↗); Thoughtworks Technology Radar Vol. 34 (2026) (↗)

5. Benchmarks reward patch success more than organisational safety. SWE-bench-style tasks helped coding agents progress, but enterprise code intelligence also needs to measure affected tests, review burden, stale context, ownership boundaries and rollback risk. The current research base gestures at these goals without converging on one benchmark.
   Sources: OpenAI (2026) (↗); METR / PDF (2025); DEX (2026) (↗)

Open questions

1. What is the fair benchmark for pre-indexing against live grep-and-read? The field needs controlled comparisons across languages, repo sizes, agent models, cache states and task classes, not only single-system savings claims.
   Sources: arXiv (2026); arXiv (2025)

2. How much build awareness is enough? Tree-sitter can map structure without compiling, but precise impact analysis may need type resolution, generated code, build targets and test metadata.
   Sources: Aider (2025) (↗); Sourcegraph docs (2025) (↗); DEX (2026) (↗)

3. Should MCP code tools report freshness, confidence and provenance as first-class fields? Current MCP adoption shows the value of common access, but code agents need to know whether a fact came from a live language server, yesterday’s graph, a vector guess or a generated summary.
   Sources: Anthropic (2025) (↗); Serena / GitHub repo (2025) (↗); Sourcegraph MCP (2026) (↗)

4. Can one shared index safely serve many agent workers? Shared services reduce repeated parsing and context spend, but they also concentrate permissions, audit requirements and failure modes.
   Sources: Sourcegraph MCP (2026) (↗); Anthropic (2025) (↗); Bloomberg (2026)

5. What is the right fusion order for graph, semantic and embedding retrieval? The strongest systems combine them, but the best production recipe may differ between code search, refactoring, test selection and architecture explanation.
   Sources: arXiv (2025); arXiv (2025); Kuzu blog (2025) (↗)

6. Will IDE indexes become reusable headless assets, or will enterprises standardise on separate code-intelligence platforms? The answer determines whether the centre of gravity sits with editors, MCP servers or central code graph services.
   Sources: JetBrains Blog (2025); GitHub (2025) (↗); Sourcegraph MCP (2026) (↗)

7. Which metric will buyers trust: tokens saved, defects avoided, tests skipped correctly, or reviewer time reduced? Until that settles, tool choice will remain a bet on where the real bottleneck sits.
   Sources: arXiv (2026); Bain & Company (2025); Stack Overflow (2025)

---

![[sources-tools-and-emerging-approaches-for-code-intelligenc]]