Code Intelligence Tools

Executive Summary

Code intelligence is a choice about which information an agent needs and how to retrieve it. A dependency graph, a language server, a semantic index, and a packed source archive can all help, but they answer different questions. This comparison covers 17 tools and agent features across those approaches, including API documentation as a separate context source.

The September 15, 2026 review adds Graphify and Codebase Memory MCP, corrects licensing and privacy claims, and removes unsupported market-leader rankings. GitNexus now documents incremental analysis and watch mode; CodeGraph has shipped v1.6.0; and Serena's current application license is GPL rather than MIT. These are adoption-relevant changes, not just newer popularity figures.^{[1][2][3][4][5]}

My recommendation is to evaluate one retrieval approach against the questions your agent repeatedly gets wrong. A graph can expose dependencies, but a static edge is not proof that a change is safe. Better navigation still needs tests and review.

Scope and Membership

Included tools provide a usable interface for coding agents to retrieve, navigate, edit, or package code or relevant API context. The tables below define the 17 members. This intentionally includes Aider's built-in repository map and Context Hub's external API documentation, while identifying how they differ from standalone repository indexes.

General-purpose editors, review products, and generated documentation sites are adjacent products, rather than rows in this comparison. Sourcegraph Cody, DeepWiki, and Greptile remain discussed below. Maintenance and availability inform the assessment; a star threshold or a quiet month does not decide membership.

Most members expose MCP, a CLI, or an agent-native interface. Repository links in the sources point to current GitHub documentation; this is a source review, not a hands-on benchmark of all 17 tools.

Repository Graphs

These products overlap, but neither database choice nor the largest advertised language count settles graph quality. Dynamic dispatch, generated code, framework conventions, and language-specific resolution are useful evaluation cases. Test whether the tool finds the dependencies you already know before trusting its impact analysis.

Graphify is particularly relevant when the context spans code and design documents. Its distinction between extracted and inferred edges is useful: an LLM-inferred relationship should not be presented as a parser-confirmed call. Codebase Memory MCP instead emphasizes a compact local structural index. Both are credible additions, with different evidence and operating models.^[1][2]

Symbols, Semantic Search, and Focused Analysis

The old graph-versus-search boundary is too rigid. grepai traces calls, mcp-vector-search includes a graph, and Serena can edit symbols. Choose the operation you need, then check whether its results are sufficiently accurate and concise for the agent consuming them.^[14][17][12]

Context Packaging and API References

Packaging is a useful baseline when you need a reproducible context artifact or a bounded collection of files. It can also complement selective retrieval. There is no defensible universal file-count threshold at which every team should switch from packing to a graph.

Commercial Context Retrieval

As checked September 15, Augment lists Standard at $20/month and Business at $100/month, each as a flat plan supporting up to 50 seats and including that amount of usage. Its pricing page describes model-provider list price plus a 40% service fee on LLM usage. Those are plan and usage terms, not a fixed price per repository or per successful coding task.^[24]

Augment's product page reports large quality improvements in its own Context Engine benchmark, using particular agents, models, and an Elasticsearch PR dataset. That supports a vendor-reported result for that experiment. It does not establish that every organization should replace local retrieval or that the same percentage applies to a different model.^[25]

Adjacent Products and an Entrant to Watch

Tembo addresses the execution environment around these tools: it runs coding agents with repositories, dependencies, and connected work context, then brings their output back for review. Its documented platform supports harnesses including Claude Code, Codex, and Pi. That makes it relevant when the problem extends from finding code to operating agents across a team.^[26] Disclosure: Ry Walker is Tembo's CEO and co-founder.^[27]

This is adjacent platform context, not an eighteenth retrieval component. A useful evaluation separates two questions: which index answers the agent's code questions, and where the agent runs with the right permissions, tools, and task context. For a Tembo deployment, verify the selected retriever's installation, index persistence, network requirements, and commercial license against that environment. This review does not establish a specific Tembo integration with every tool in the table.

Sourcegraph Cody needs more precise availability language than the previous broad SaaS row. Its individual Free, Pro, and Enterprise Starter plans ended in July 2025. Sourcegraph's February 2026 deprecation note replaces Cody Web with Deep Search for affected customers but explicitly leaves the Cody editor agent unaffected; that is not a blanket Cody shutdown.^[28][29]

DeepWiki provides public repository documentation and question answering, while Greptile centers its product on code review. They can supply useful code understanding, but this revision treats their end-user workflows as adjacent rather than counting them as interchangeable retrieval components.^[30][31]

Atlassian's Code Context is an entrant to watch. Its current setup documentation describes an open beta rolling out for Bitbucket and GitHub repositories in Rovo Chat and the TWG CLI. Site eligibility and rollout still matter, so it is outside this comparison's member tables for now. The documentation also warns that all opted-in repository content, including secrets, can be indexed; repository permissions remain central to access control.^[32]

What the Performance Evidence Actually Shows

A March 2026 Codebase-Memory paper reports roughly 10 times fewer tokens and 2.1 times fewer tool calls across 31 repositories, but answer quality of 83% versus 92% for file exploration. This is a result for that paper's system and experiment, not an independent ranking of today's products. The quality tradeoff is part of the result, not a footnote to omit.^[33]

CodeGraph publishes a separate multi-turn study reporting about 80% more retrieval context remaining in the window, despite savings on other measures. This exposes the distinction between processed tokens and source material that continues occupying the conversation.^[34]

There is first-hand criticism too. In an August 3 report, a Cursor user compared CodeGraph v1.5.0 with grep/read on a roughly 2,300-file Go repository and reported higher context use with CodeGraph, while both sessions reached the correct answer. The issue is closed, and v1.6.0 introduced response deduplication. It is a useful workload report, with a version boundary, rather than proof that the current tool always costs more.^[35][4]

The current implementation adds an important qualification: source is returned on every call by default. CODEGRAPH_EXPLORE_DEDUP=1 enables cross-call deduplication only for a host that guarantees one durable context per connection. A shared server handling new subagents or compacted conversations cannot assume that previously returned source remains visible. Include that setting and host behavior in a benchmark instead of treating deduplication as an automatic saving.^[7]

The prior comparison combined token, tool-call, and quality percentages from unlike experiments into a general victory for indexed retrieval. Those measurements cannot establish that conclusion. For adoption, compare the same task, model, repository revision, and correctness criteria; include indexing time, follow-up turns, failures, and stale results.

Privacy, Licensing, and Selection

“Local” describes a component, not the entire workflow. CodeGraph documents outbound usage telemetry. GitNexus documents optional remote model services and warns that a hosted bearer token can access indexed source. grepai supports both local and hosted embedding providers. In each case, inspect the configuration and the downstream coding agent before drawing a data-handling conclusion.^[8][9][14]

Repomix's MCP --sandbox option is also easy to overread: it confines its file operations to a workspace at the application layer. It is not an operating-system sandbox for arbitrary agent commands.^[19]

My shortlist depends on the job:

• Trace dependencies repeatedly: compare CodeGraph, GitNexus, CodeGraphContext, and Codebase Memory MCP on known relationships in your repository; add Graphify when documents are part of the context.
• Navigate and change symbols: evaluate Serena, including the current license and the quality of its language backend.
• Find code from an imprecise description: compare grepai with claude-context using the embedding and storage setup you would actually deploy.
• Export a reproducible context package: start with Repomix or code2prompt; Aider users should evaluate the built-in repository map before adding another component.
• Retrieve across hosted repositories: assess Augment's access model and total usage bill alongside retrieval quality.

These are starting points for evaluation, not a league table. The useful winner is the tool that gives your agent enough correct context to finish the work, at an acceptable cost and with understandable operating boundaries.

---

Research by Ry Walker • methodology