repowise vs Serena, the numbers.
Serena indexes on demand instead of up front, which is a real advantage. But in our measured agent loop it makes 42% more tool calls than a bare agent with no tool at all, 10.1 against 7.2, while writing less. Busier, not leaner. The full comparison, including the advantage, is below.
An agent tool is supposed to leave less work for the agent. The interesting failure mode is a tool that gets called constantly and the agent still ends up doing more, not less.
We measured Serena against repowise and three other tools on 44 django/django questions with Codex and 15 with Claude Code, byte-identical prompts, a bare-agent control on both. Serena needs no index build, so its indexing-time row is genuinely not applicable rather than a number we are hiding.
No index to build before it answers.
This is the real advantage, stated plainly, before the counter-case.
Every other tool in this comparison, repowise included, pays an upfront indexing cost before an agent can use it: 366.8 seconds for repowise on django/django, 16.4 for CodeGraph, 141.5 for Graphify. Serena has no equivalent row. It indexes on demand, as the agent explores, which means zero wait before the first question and no index to keep synchronized as files change underneath it. On a codebase that mutates faster than a batch index can track, or where you cannot tolerate any upfront wait, that is a real structural advantage repowise does not have.
Busier, not leaner.
Every tool called on every question it completed, so this is like for like. Serena's call count is the number to read closely.
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.
Serena writes 14.8% less than the bare agent, a real and significant saving. But it reaches that answer in 10.1 tool calls, 42% more than the bare agent's own 7.2 and nearly three times repowise's 3.8. On-demand indexing means the exploration a pre-built index would have replaced still has to happen, one call at a time, through Serena's tools instead of raw file reads.
It also opened 3.0 files instead of 7.2. Those move together because they are the same effect: work done once, offline, that the agent would otherwise redo per query. How we measured · raw data
Which one is right for you?
Choose repowise if
- You want the agent to finish in fewer tool calls and write less output, both together
- You can tolerate an upfront index build in exchange for a pre-computed structure that replaces exploration
- You want a wiki, code health, dead code, git intelligence, and decisions in the same index
- You want an open-source, self-hostable index with agent-neutral MCP tools
Choose Serena if
- You cannot tolerate any upfront indexing wait before the agent can start working
- Your codebase changes fast enough that keeping a batch index in sync is the bigger cost
- You are fine with more tool calls per question in exchange for zero index-build step
repowise vs Serena
| Capability | repowise | Serena |
|---|---|---|
| No upfront index build requiredSerena indexes on demand; repowise builds an index first | Not included | Included |
| Tool calls to reach an answer3.8 to Serena's 10.1, against a bare agent's 7.2, measured on Codex | Included | Not included |
| Output-token reduction in a real agent loop-31.6% to Serena's -14.8%, both measured on Codex | Included | Partial support |
| Called reliably by Claude Coderepowise: 15 of 15 that day, unstable across reruns. Serena: 4 of 15, needs explicit project activation first | Partial support | Not 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. Serena: 29 tools, 29,050 characters of schema | 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 Serena'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. Serena's pricing changes, so verify it on their site, then compare it with a tier you can read line by line.
Questions, answered
Is Serena a good alternative to repowise?
Serena's on-demand indexing, no build step before the agent can use it, is a real advantage repowise does not have. But on the agent loop it makes 42% more tool calls than a bare agent with no tool at all, 10.1 against 7.2, while writing 14.8% less output. It is busier, not leaner, which is a different profile from repowise's fewer calls and fewer tokens together.
Did you set Serena up correctly? It scored zero under Claude Code.
Serena's number under Claude Code is 4 of 15 questions where the agent called it at all, not zero, and getting even that far required an explicit project activation step before Serena answers anything, which is not obvious from a first read of its docs. We ran that activation before every question. Under Codex, where the agent reaches for tools more readily, Serena was called on all 43 questions it completed.
What version of Serena did you test?
Serena 1.6.2.dev0, measured in August 2026 against repowise at commit 081a59fa. This is a dated comparison; check current docs before deciding.
Can I reproduce these numbers?
Yes. The 44-question Codex agent-loop run and the 15-question Claude Code run are both published with raw data in repowise-bench, including Serena's tool-call and token counts per question.
Why does Serena make more tool calls than a bare agent?
Because it indexes on demand rather than up front. Where repowise's pre-built structure lets the agent replace several greps with one answered question, Serena's agent still explores the codebase step by step, just through Serena's tools instead of raw file reads, so the call count does not fall the way ours does. 10.1 calls to reach an answer, against the bare agent's 7.2 and repowise's 3.8 on the same run.
Is there a real advantage to Serena's on-demand model?
Yes, and we say so directly: nothing to build before the agent can use it, no upfront wait, no index to keep in sync as files change. That is a genuine trade against repowise's slower, heavier first index, and it may be the right trade for a codebase that changes faster than an index can be rebuilt.
Which tool should I actually use?
If avoiding any upfront indexing step matters more than tool-call efficiency, Serena's on-demand model is a real fit. If you want the agent to finish in fewer steps and write less to get there, both measured together, repowise's pre-built index shows a clearer advantage on this benchmark, at the cost of that first index.
Is repowise open source like Serena?
Yes. repowise's core is open source under AGPL-3.0 (OSS 0.39.0) and self-hostable, and ships ten flagship MCP tools for any agent.
Check every number yourself.
Every figure here, including Serena's on-demand advantage, 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.
0.546 retrieval coverage from 34.5 files a question, the least precise tool we measured, against repowise's 8.2.
Highest precision, lowest coverage, and a 40,904-node graph the agent called zero times in 15 questions under Claude Code.
A durable, cross-agent context layer that outlasts your editor's ephemeral index.