A browsable codebase graph, not just a review bot.
Greptile builds a graph to power its PR-review bot. repowise builds a graph too, then exports it as a human-browsable wiki with decisions, a defect-validated health score, and ten MCP tools any agent can query.
Greptile proved that a graph of your codebase makes AI better. The question is whether that graph stays locked inside a review bot, or becomes a layer your whole team and every agent can read and query.
repowise builds the same kind of graph of files, functions, and dependencies, then exports it as a browsable wiki with architectural decisions, a defect-validated health score, and ten MCP tools, so the index is a durable artifact rather than a hidden input to one PR pass.
Which one is right for you?
Choose repowise if
- You want the codebase graph exported as a human-browsable wiki, not hidden inside a bot
- You want architectural decisions, a defect-validated health score, and dead-code detection in one layer
- You want ten MCP tools so any agent answers from a real model of your code
- You want it open source and self-hostable under AGPL-3.0, with zero code leaving your infrastructure
- You want defect validation you can reproduce on your own repo
Choose Greptile if
- You primarily need automated pull-request review with full-codebase context
- You want a reviewer that learns your standards from your PR comments over time
- You want an agent that autonomously writes and runs tests for each PR (TREX)
- You want a polished, mature review-and-merge workflow today
repowise vs Greptile
| Capability | repowise | Greptile |
|---|---|---|
| Graph of files, functions, and dependencies | Included | Included |
| Graph exported as a human-browsable wikiGreptile's graph is an internal index for review | Included | Not included |
| Auto-generated documentation, rebuilt per commit | Included | Not included |
| Architectural decision records (the why) | Included | Not included |
| Defect-validated code-health score | Included | Not included |
| Dead code detection | Included | Not included |
| Agent-native MCP context (overview, answers, risk, why)Greptile's MCP shares review-comment context | Included | Partial support |
| Open source and self-hostableGreptile is free for OSS but not open source | Included | Not included |
| Automated pull-request review | Not included | Included |
| Learns your standards from PR comments | Not included | Included |
| Autonomous test generation per PRGreptile TREX | Not included | Included |
| Mature review-and-merge workflow | Partial support | Included |
Self-assessed against publicly documented features as of June 2026. A dash means partial or limited support. Vendor capabilities change, so please verify against Greptile's current docs before deciding.
Same graph idea, a durable layer on top.
Greptile's graph feeds one review pass. repowise's graph becomes documentation, decisions, health, and agent context you can keep.
A graph you can read, not just a bot's input
repowise exports the codebase graph as a wiki you can browse, search, and link to, backed by architectural decisions mined from eight sources. It is a durable artifact for onboarding and architecture reviews, not a hidden index that only a review bot consumes.
- Human-browsable wiki, rebuilt on every commit
- Architectural decisions mined from eight sources
- get_why answers why the code is shaped the way it is
- AGPL-3.0: inspect, fork, self-host the whole platform
Ten MCP tools, not one review pass
The same index that builds the wiki answers ten MCP tools, so Claude Code, Cursor, Cline, and Codex all query a real model of your code. Loading one commit's context this way costs 35.6x fewer tokens than a raw dump, because the graph is structured rather than pasted.
- get_overview, get_answer, get_context, get_risk, get_why, and more
- 35.6x fewer tokens loading one commit's context vs a raw dump
- Works with Claude Code, Cursor, Cline, and Codex
- Bring your own LLM key or run fully offline
A score a review bot does not ship
repowise scores every file from 21 deterministic biomarkers and validates that score against real defects, then surfaces dead code for cleanup. The benchmark is open and reproducible on your own repo, so you confirm the score finds your bugs.
- Cross-project ROC AUC 0.74, up to 0.90 per repo
- 2.3x more defects under a fixed review budget in repowise's open 21-repo benchmark
- 21 deterministic biomarkers, no LLM, under 30 seconds
- Dead-code detection for cleanup sprints
Built for any agent's shell, not just one review bot.
Greptile's context serves its own review and QA product. repowise's deterministic layer, and a second tool called distill, serve whatever agent and whatever terminal you already run.
Distill cuts noise before your agent reads it
distill wraps a command your agent already runs, pytest, git log, git diff, and compresses the output before it reaches the context window: 61% smaller on a pytest run with 11 failures (every failure line kept), 89% on git log, 86% on a 30-commit git diff. It works with any agent's shell tool, not just repowise's own index.
No API key for the first index
pip install repowise, then repowise init --yes --no-prose builds the graph, git history, and full code-health score with zero LLM calls. Greptile is agent-first from the very first run; repowise's deterministic core needs no model and no key at all.
Ten tools for any agent, not one bot
Greptile indexes your codebase to power its own review and QA product. repowise's MCP tools are agent-neutral: the same index answers Claude Code, Cursor, Cline, and Codex, or your own custom agent, over the open Model Context Protocol.
Deterministic core, optional prose
Code health, dead code, and git intelligence run with no model in the loop, so they cost nothing and never drift between runs. Bring an LLM key only when you want the wiki's narrative pass.
The honest version
Greptile is a focused, well-built product in a category repowise does not compete in: automated pull-request review. Its swarm agents review and test PRs with full-codebase context, and it learns your team’s standards from your PR comments over time, getting sharper the longer you use it. Its TREX agent autonomously writes and runs tests for each pull request, and the overall review-and-merge workflow is polished and mature. If inline PR review is your priority, Greptile is a strong choice; repowise wins when you want the codebase graph exported as a durable, browsable layer with decisions, health, and agent context.
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. Greptile's pricing changes, so verify it on their site, then compare it with a tier you can read line by line.
Questions, answered
Is repowise a Greptile alternative?
They overlap on one idea and diverge on everything else. Both build a graph of your codebase, but Greptile's graph exists to power its PR-review bot, while repowise exports the graph as a human-browsable wiki you and any agent can query over ten MCP tools. If you want a durable intelligence layer rather than a review bot, repowise is the alternative; if your need is automated pull-request review, Greptile is the more focused product.
Both build a graph of the codebase. What is the difference?
Greptile's graph is an internal index of files, functions, and dependencies that feeds its review and test agents. repowise's graph is exported, human-browsable, and backed by an auto-generated wiki and architectural decision records, so it is a durable artifact you can read, search, and query rather than a hidden index. repowise also ships a defect-validated health score, decision archaeology, and dead-code detection that a review bot does not.
Does repowise review pull requests like Greptile?
No, that is Greptile's category, not repowise's. Greptile reviews and tests PRs with swarm agents, learns from your PR comments over time, and runs its TREX testing agent. repowise gives agents and humans a queryable model of the whole codebase, which is a different job from inline PR review.
Can repowise give AI coding agents codebase context?
Yes, and this is the core difference. repowise exposes the whole index through ten MCP tools (get_overview, get_answer, get_context, get_risk, get_why, and more) so Claude Code, Cursor, Cline, and Codex answer from a real model of your code. Greptile's MCP surface is focused on sharing review-comment context back to agents.
Is repowise open source? Is Greptile?
repowise core is open source under AGPL-3.0, so every biomarker, weight, and scoring rule is public and you can self-host the whole platform. Greptile is free for open-source projects but is not itself open source.
Does repowise have a code-health score?
Yes. repowise scores every file 1 to 10 from 21 deterministic biomarkers, with no LLM, in under 30 seconds on a 3,000-file repo. Its predictive performance against real defect labels is published and reproducible: cross-project ROC AUC 0.74 (95% CI 0.68 to 0.79, up to 0.90 per repo).
Why does an exported graph matter if Greptile already has one?
Because an exported, browsable graph serves people and many agents, not just one bot's review pass. repowise rebuilds the wiki on every commit and feeds the same index to ten MCP tools, so onboarding, architecture reviews, and agent context all draw from one durable layer. Greptile's graph is internal to its review workflow and is not meant to be read or queried as documentation.
Does repowise have anything like Greptile's context for agent shells and CI output?
Yes, and it covers ground Greptile does not touch: distill. Greptile's context serves its own review and QA product; repowise's distill compresses noisy command output, pytest runs, git log, git diff, before an agent's own shell tool reads it, cutting 61 to 89 percent of the tokens while keeping every error line. It works with any agent's terminal tool, not just repowise's own index.
Do I need an API key to index my repo with repowise?
No. pip install repowise, then repowise init --yes --no-prose builds the graph, git history, and full code-health score with zero LLM calls. Greptile is an agent-first product from the first index; repowise's deterministic layer, health, dead code, and git intelligence, needs no model and no key at all.
Ten MCP tools that feed your agents, plus distill.
The exported, browsable codebase graph.
The defect-validated score, in depth.
How the ten MCP tools and distill cut agent token spend.
The original MCP-tools walkthrough (the flagship set has since grown to ten).
Where repowise ranks among agent-context tools.
How review-focused tools like Greptile compare.
Browse real indexed repos before you install anything.