repowise vs Graphify, the numbers.
Graphify reaches 0.546 file coverage by serving 34.5 files a question, more than four times what repowise's search_codebase needs for better coverage. That makes it the least precise tool in the field we measured. The full published comparison is below, including where Graphify indexes faster.
A retrieval tool that returns everything nearby will eventually contain the right file. The question is how much an agent has to read to find it, and that is a precision question, not a coverage question.
We measured Graphify against repowise on 42 sealed ContextBench instances, on 43 django/django agent-loop questions with Codex, and on a straight indexing-time stopwatch. Every number below is published with its sample size and, where one exists, its p-value.
More files served, less found per file.
Deterministic grading against gold file spans, no LLM judge. Graphify scores lowest on precision of anything in the four-way field.
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 real, significant saving, just the smallest one.
Graphify is not a null result. It beats a bare agent by a statistically significant margin, on the same run every other tool in this comparison was measured on.
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.
Graphify cuts output tokens by 8.9% against a bare agent, at p = 0.003, on 43 questions. That is a genuine effect, not noise, and it is worth saying plainly: it is also the smallest saving of the five tools measured in that run, at roughly a quarter of repowise's -31.6%. Graphify also indexes faster than repowise, 141.5 seconds against 366.8, building a call graph with communities in that time.
One repository, one commit, one prompt, and single-session questions of four to seven turns. Not a universal saving. How we measured · raw data
Which one is right for you?
Choose repowise if
- You want the best coverage-per-file-served ratio in the field, 0.742 coverage from 8.2 files
- You want the largest measured agent-loop token saving of the tools benchmarked
- You want a wiki, code health, dead code, git intelligence, and decisions alongside retrieval
- You want an open-source, self-hostable index with agent-neutral MCP tools
Choose Graphify if
- You specifically want Graphify's community-detection view on top of a call graph, which we did not measure
- Faster indexing than repowise matters to you and Graphify's 141.5s beats our 366.8s
- You are comfortable with a wider net of files served per question in exchange for its particular graph structure
repowise vs Graphify
| Capability | repowise | Graphify |
|---|---|---|
| File coverage on sealed retrieval instances0.876 (get_answer) / 0.742 (search_codebase) to Graphify's 0.546, measured, n=42 | Included | Not included |
| Precision (coverage per file served)0.168 from 8.2 files to Graphify's 0.033 from 34.5 files | Included | Not included |
| Output-token reduction in a real agent loop-31.6% to Graphify's -8.9%, both measured and significant, on Codex | Included | Partial support |
| Indexing speed on django/djangoGraphify: 141.5s. repowise (--no-prose): 366.8s | Not included | Included |
| Call graph plus community detectionNot part of repowise's retrieval layer; not benchmarked here | Not included | Included |
| 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. Graphify: 10 tools, 3 of 15 called under Claude Code | Included | Partial support |
Self-assessed against publicly documented features as of August 2026. A dash means partial or limited support. Vendor capabilities change, so please verify against Graphify'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. Graphify's pricing changes, so verify it on their site, then compare it with a tier you can read line by line.
Questions, answered
Is Graphify a good alternative to repowise?
On the numbers we measured, Graphify finds fewer of the right files (0.546 to our 0.876 coverage) while serving more than four times as many files per question to get there (34.5 to our 8.2), which makes it the least precise tool in the four-way field we benchmarked. Its agent-loop saving of -8.9% is real and statistically significant at p = 0.003, just smaller than the other tools we measured.
Did you run Graphify correctly?
Graphify was called on 43 of 43 questions on Codex with its own full advertised tool surface and a freshly built index on the same pinned django/django commit, byte-identical prompt to every other arm. It also indexed on its own schedule alongside the other tools: 141.5 seconds against our 366.8.
What version of Graphify did you test?
Graphify 0.9.31, measured in August 2026 against repowise at commit 081a59fa. Treat this as a dated comparison and check current docs before deciding.
Can I reproduce these numbers?
Yes. The retrieval matrix, the agent-loop run, and the indexing-time stopwatch are all published with raw data in repowise-bench, including Graphify's rows, linked below.
Why does Graphify serve so many files per question?
That is what its retrieval strategy trades off. Serving 34.5 files against our 8.2 for search_codebase means it is casting a much wider net to reach 0.546 coverage, which costs more tokens per question read and is the specific number behind calling it the least precise tool we measured, at 0.033 precision against our 0.168.
Does Graphify get called by the agent under Claude Code?
Rarely in our run: 3 of 15 questions, against repowise's 15 of 15 the same day. We flag our own adoption numbers as unstable across reruns too, so read that as a property of the pairing between tool and harness on that day rather than a permanent fact about either tool.
Which tool should I actually use?
If precision per file served matters, meaning you want the agent to read fewer, more relevant files, repowise's search_codebase is the better measured choice at 8.2 files for 0.742 coverage. If you specifically need Graphify's community-detection view of a codebase on top of its call graph, that capability is not something we measured and may still be worth it for your use case.
Is repowise open source like Graphify?
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, and it ships ten flagship MCP tools for any agent.
Check every number yourself.
Every figure here, including where Graphify indexes faster, links back to repowise-bench for the raw run data, and to the full benchmarks page for methodology and sample sizes.
The strongest competitor we measured: second on retrieval and the agent loop, and 22x faster to index. We publish that loss too.
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.
Enterprise-grade agent context without the enterprise contract. Open and self-hostable.