repowise vs CodeGraph, the numbers.
CodeGraph is the strongest competitor we measured: a genuine second place on retrieval and on the agent loop. It also indexes 22x faster than we do. This page leads with the published benchmark, including the row we lose.
Most comparisons in this category are a feature checklist. We ran CodeGraph against repowise on the same questions, the same repository, and the same agent, and we are publishing every number, including the one where CodeGraph wins.
Retrieval was graded deterministically against 42 sealed ContextBench instances. The agent loop was measured on 44 django/django questions with Codex, byte-identical prompts, a fresh index per tool. Indexing time was a stopwatch on the same repository. Nothing below is a capability claim; it is all a measurement with an n and, where one exists, a p-value.
Where CodeGraph stands second.
Deterministic grading against gold file spans, no LLM judge. CodeGraph is the strongest of the three competitors we measured here, and still second.
Finding the right files
File coverage on 42 ContextBench instances pinned before any of this work started and kept sealed until the final measurement. Grading is deterministic and no LLM judge is involved.
| Tool | File coverage | Precision | Files served |
|---|---|---|---|
| repowise (get_answer) | 0.876 | 0.087 | 19.2 |
| repowise (search_codebase) | 0.742 | 0.168 | 8.2 |
| CodeGraph | 0.610 | 0.093 | 14.0 |
| Graphify | 0.546 | 0.033 | 34.5 |
| code-review-graph | 0.445 | 0.240 | 5.4 |
Scroll the table sideways to see every column.
n = 42 sealed instances. Head to head against CodeGraph, get_answer wins 19, loses 1, ties 22, sign test p = 0.00004. The pooled 112-instance figure would be 0.835 and is deliberately not quoted: averaging the halves loses the only number that matters, which is how the tool does on instances it has never seen.
A genuine second place, not a strawman.
Every tool called on every question, so this is like for like. CodeGraph is the only other tool in the field that clears statistical significance here.
What changes in a real agent loop, on Codex
Every question in django's question set, six arms, byte-identical prompts, each tool's full advertised surface, and a freshly built index on the same pinned commit. Every tool was called on every question, so this is like for like.
| Tool | Agent used it | Output tokens | vs bare agent | Tool calls | Leaner on | p |
|---|---|---|---|---|---|---|
| repowise | 44 / 44 | 1,250 | -31.6% | 3.8 | 37 of 44 | <0.0001 |
| CodeGraph | 44 / 44 | 1,383 | -24.4% | 4.0 | 37 of 44 | <0.0001 |
| Serena | 43 / 43 | 1,550 | -14.8% | 10.1 | 35 of 43 | <0.0001 |
| Graphify | 43 / 43 | 1,658 | -8.9% | 7.4 | 31 of 43 | 0.003 |
| code-review-graph | 43 / 43 | 1,710 | -6.0% | 7.2 | 26 of 43 | 0.046 |
| bare agent (control) | 0 / 44 | 1,828 | baseline | 7.2 | n/a | n/a |
Scroll the table sideways to see every column.
Codex (gpt-5.6-sol) on django/django at one pinned commit. Correcting for testing five tools at once, three reductions are solid and two are marginal. 5 of the 48 questions are missing from every arm equally because the run hit an API usage cap, so the figures are over the 43 questions all six arms completed; because all arms lost the same 5, the paired comparisons are unaffected.
Correcting for testing five tools at once, three reductions are solid and two are marginal. CodeGraph's -24.4% is one of the solid ones. The honest reading is that we lead a field in which more than one tool works, not that we are the only one that does.
CodeGraph indexes 22x faster. Say it plainly.
This is the number a skeptic should check first, because it is the one that would be easiest to bury in a footnote.
Indexing time, the row we lose
We are the slowest indexer in the field, on every repo we measured, and it is not close. Measured on django/django.
| Tool | Index time | What it builds |
|---|---|---|
| CodeGraph | 16.4s | call graph |
| code-review-graph | 44.8s | call graph |
| Graphify | 141.5s | call graph, communities |
| repowise (--no-prose) | 366.8s | graph, git history, decisions, code health |
| repowise (default, prose on) | 1,058s | all of the above plus generated documentation |
Scroll the table sideways to see every column.
22x CodeGraph like for like, and 135x with prose on, which is what a default repowise init actually costs you. Both numbers ship. The reason is not an optimisation we forgot: in that same run repowise built 36,485 graph nodes, mined history across 2,630 files, rendered and embedded 3,392 wiki pages, extracted decision records and produced 5,317 health findings. It is also a one-time cost, since updates after the first index are incremental.
If all you want is a call graph, CodeGraph builds one in 16 seconds and you should use it.
The reason is not an optimisation we forgot. CodeGraph builds a call graph. In the same pass, repowise also mines full git history across every file, renders and embeds a wiki, extracts architectural decisions, and scores code health, which is what the other four layers below cost in wall-clock time. Both facts are true at once, and neither one cancels the other.
135x with prose on. The tools we are measured against build a call graph; in the same pass we also mine git history, generate and embed documentation, extract decision records and score code health. If all you want is a call graph, CodeGraph builds one in 16 seconds and you should use it. How we measured
Which one is right for you?
Choose repowise if
- You want the highest measured file coverage and the largest agent-loop token saving in the field
- You want a wiki, code health, dead code, git intelligence, and decisions in the same index as retrieval
- You can accept a slower first index in exchange for five layers instead of one
- You want an open-source, self-hostable index with agent-neutral MCP tools
Choose CodeGraph if
- All you want is a call graph and you want it built in seconds, not minutes
- Indexing time matters more to your workflow than retrieval accuracy or agent-loop savings
- You are re-indexing very large monorepos frequently and the extra layers are dead weight for your use case
- A single, focused MCP surface over a call graph is a better fit than a wider toolset
repowise vs CodeGraph
| Capability | repowise | CodeGraph |
|---|---|---|
| Indexing speed on django/djangoCodeGraph: 16.4s. repowise (--no-prose): 366.8s, 22x slower | Not included | Included |
| File coverage on sealed retrieval instances0.876 to 0.610, measured, n=42 | Included | Not included |
| Output-token reduction in a real agent loop-31.6% to CodeGraph's -24.4%, both measured on Codex | Included | Partial support |
| Auto-generated wiki and Q&A | Included | Not included |
| Defect-validated code-health score | Included | Not included |
| Dead code detection | Included | Not included |
| Git intelligence (hotspots, ownership, bus factor) | Included | Not included |
| Architectural decision records | Included | Not included |
| MCP tool surface advertisedrepowise: 10 flagship tools. CodeGraph: 1 tool, under Claude Code | Included | Partial support |
| Incremental updates after the first indexNot measured for CodeGraph; repowise's first index is the one-time cost | Included | Not included |
Self-assessed against publicly documented features as of August 2026. A dash means partial or limited support. Vendor capabilities change, so please verify against CodeGraph's current docs before deciding.
What repowise costs.
The repowise core is open source under AGPL-3.0 and free to self-host, with every heuristic public. Hosted tiers: Free for public repos, Pro at $15 per month, Teams at $60 per month, and custom enterprise licensing when you need it. CodeGraph's pricing changes, so verify it on their site, then compare it with a tier you can read line by line.
Questions, answered
Is CodeGraph better than repowise?
On two of the three things we measured, no: repowise finds more of the right files (0.876 to 0.610 file coverage on 42 sealed instances) and leaves an agent with less work to do (-31.6% output tokens against a bare agent, versus CodeGraph's -24.4%, both on Codex). On the third, indexing speed, yes: CodeGraph builds its index in 16.4 seconds against our 366.8, 22 times faster. If all you want is a call graph, CodeGraph builds one in seconds and you should use it.
Did you run CodeGraph correctly?
Every arm in the agent-loop run, including CodeGraph, got a byte-identical prompt, its own full advertised tool surface, and a freshly built index on the same pinned django/django commit. CodeGraph was called on all 44 questions on Codex, so this is a like-for-like comparison rather than one tool getting ignored. We probe every arm before a run to confirm its server actually answers, specifically so a broken setup cannot pass as a real result.
What version of CodeGraph did you test?
CodeGraph 1.5.0, measured in August 2026 against repowise at commit 081a59fa. Both tools change over time; if you are reading this months later, treat it as a dated comparison and check whether either project has moved since.
Can I reproduce these numbers myself?
Yes. Every run, including the ones where CodeGraph wins, is published with its raw data in the repowise-bench repository: the retrieval matrix, the 48-question Codex agent-loop run, and the indexing-time measurement all link to their source directories below.
Why does CodeGraph index so much faster?
Because it builds less. CodeGraph builds a call graph. In the same pass, repowise also mines full git history, generates and embeds a wiki, extracts architectural decisions, and scores code health across every file, which is what the extra 350 seconds buys. Neither fact cancels the other: 22x slower and five layers instead of one are both true at once.
Is CodeGraph the strongest competitor you measured?
Yes, and we say so directly. Across the four open-source agent-context tools we benchmarked, CodeGraph is second on retrieval, a genuine second on the agent loop, and the only one of the four to beat us in any category outright, on indexing speed. It is a stronger result than any of the other three tools produced.
Which tool should I actually use?
If your whole need is a call graph an agent can query fast, and indexing time matters more than everything else, CodeGraph is a reasonable choice and beats us on that one axis by a wide margin. If you want the agent to find the right files more often, do measurably less work per question, and get a wiki, code health, dead code, and decisions in the same index, repowise wins on the numbers that follow, at the cost of a slower first index.
Is repowise open source like CodeGraph?
Yes. repowise's core is open source under AGPL-3.0 (OSS 0.39.0) and self-hostable, with every marker and scoring rule public. It ships ten flagship MCP tools so any agent, not just one vendor's, can call it.
Check every number yourself.
Every figure on this page, including the ones where CodeGraph wins, links back to repowise-bench for the raw run data, and to the full benchmarks page for the methodology, sample sizes, and every invalidated run we kept rather than deleted.
0.546 retrieval coverage from 34.5 files a question, the least precise tool we measured, against repowise's 8.2.
Indexes on demand with no build step, a real advantage, but makes 42% more tool calls than a bare agent while writing less.
Highest precision, lowest coverage, and a 40,904-node graph the agent called zero times in 15 questions under Claude Code.
A self-hostable wiki for your private repos, with code health and git risk layered on top.