Stop paying your agent to re-read your codebase.

Repowise indexes your code, git history, tests and decisions once, on your machine.
Your coding agent asks the index instead of grepping and opening files, so it does about half the work.
You get the same answers in a dashboard: what calls this, what breaks, what to fix first, and why.

_{Graph, risk, health, tests and dead code make zero LLM calls · no API key to index · 28 languages · Claude Code, Codex, Cursor and any MCP host · free and open source}

Quickstart · For your agent · What it does · Hosted · Benchmarks · Teams · Docs

Set it up in one line

Open Claude Code, Codex, Cursor or any MCP-capable agent in your repository and paste:

Read https://docs.repowise.dev/setup.md and set up Repowise in this repository.

The agent installs Repowise, indexes the repo with no API key, connects itself to the index, and asks you before anything costs money. To do it by hand:

uv tool install repowise          # or: pipx install repowise / pip install repowise
cd /path/to/your/repo
repowise init --yes --no-prose    # graph, git, health, dead code, docs. No key, no spend.
                                  # (add model-written docs any time with: repowise generate)
repowise serve                    # dashboard + MCP server (needs Node 20+; first run downloads the UI)

Restart Claude Code or run /mcp, then ask "What breaks if I change src/auth.py?" or "Use Repowise get_overview to summarize this repository." init wires Claude Code for this repo and points the global repowise MCP entry here. Full setup for every agent →

Your agent stops guessing

Without an index, an agent rediscovers your codebase on every task: grep, open a file, open three more, grep again. Repowise answers those questions ahead of time, so the agent asks once and gets on with the work.

In a measured run on django/django, an agent with Repowise made 3.8 tool calls instead of 7.2, opened 3.0 files instead of 7.2 and wrote 31.6% less, with answers just as good. That is the largest saving of the five context tools we tested. On a small local model the output cut reaches 47.9%. How it was measured →

• Your agent gets ten task-shaped MCP tools. Ask about several files at once and get callers, risk, tests, owners and the reasons behind the code in one answer. The tool list ↓
• Up to 99% less command noise. repowise distill trims test, install and git output before the agent reads it and keeps every error line. Distill →
• Context before the agent asks. Optional hooks warn it off fragile files and stale paths, and Repowise keeps your CLAUDE.md and AGENTS.md current from the index.
• See your own savings. repowise saved and the dashboard's Usage and savings page count the tokens your agent no longer has to read.

What it does

One index of your code, its history and its decisions, used three ways: to understand the code, to change it safely, and to keep improving it.

See how it fits together A call graph across 28 languages, an architecture map you can explore, C4 views, and a generated wiki for every module and file. The graph · Docs	Know what breaks Every caller of what you changed, the files that usually change with it but are missing from your diff, and the tests that reach it. Change risk · Tests
Fix what matters A 1 to 10 health score for every file, validated against real bug history, a ranked fix-first queue, refactoring plans and dead code. Code health · Refactoring	Follow it across repos Services and the HTTP, gRPC and event contracts between them, with a guard for breaking changes and the consumer files they affect. Workspaces
Ask it anything Cited answers and charts from the dashboard, or the same answers through MCP for your agent. Dashboard · MCP tools	Remember why Decisions mined from ADRs, comments, commits, PRs and agent sessions, each tied to the code it governs, plus docs checked against the code. Decisions · Doc drift

Hosted, and Foresight

Everything above runs free on your own machine. repowise.dev runs it for you, private repos included, and is where Foresight arrives first: models trained on years of real commits and fixes that rank the files a fix will touch, name what a change forgot, and explain every answer, with no LLM. What Foresight does →

Already indexed locally? repowise publish puts the repo on repowise.dev in one command. It indexes your GitHub remote, so nothing is uploaded from your machine. Public repos are free.

Know what breaks before you merge

All of this comes from the graph and git history, with no LLM, so the same diff always gets the same answer.

• Change risk. Score any commit or branch 0 to 10 against your repository's own recent commits, with what it may break, the companion files it forgot, the tests it is missing and the tests to run. repowise risk main..HEAD (reference)
• Tests without a coverage run. Which tests reach a file and which ones a diff exercises, from a coverage report when you have one and from the call graph when you do not: 97.5% correct on which tests to run. repowise impacted-tests main..HEAD (reference)
• Bug magnets. Which files keep getting bug fixes, with a warning when your agent edits one. (reference)
• Branch overlap. Other open branches editing the same files. repowise overlap (reference)
• In CI. Patch coverage, doc drift, security and change risk as gates through the GitHub Action, a GitLab template or plain CLI, with SARIF output. No API key. Repowise in CI →

On every pull request. The free Repowise PR Bot posts one comment, edited in place on every push, with the callers outside the PR, the tests and companion files it is missing, and its change risk. A green PR gets no comment at all.

_{A real comment on a real PR: repowise-dev/repowise#1204 · its analysis page → · install the PR bot →}

Every change, with its evidence

Each merged PR or commit becomes a Change Record: what it touched, who owns it, the tests that reach it, the contracts and decisions it crosses, and what happened after it landed. No forge API is called.

Know exactly what to fix

Every file gets a 1 to 10 score from 53 deterministic detectors, read three ways: defect risk, maintainability and performance. Performance findings such as N+1 queries and I/O in loops are traced across functions and files.

The score is checked against real bugs. On 21 open-source projects, ranking by Repowise found 2.3x as many later-buggy files as CodeScene in the same review budget. It also checks itself on your repository after every index: "16 of the 20 lowest-health files had a bug fix in the last 6 months, 3.3x the 24% baseline."

Then it names the fix: Extract Method, Extract Class, Move Method, Split File or Break Cycle, with the exact symbols that move, ranked so a fix on a central file comes before the same fix on a leaf. Each plan has a copy-to-agent button.

repowise next                          # what to fix first, ranked by impact and effort
repowise health --refactoring-targets  # concrete plans
repowise dead-code                     # what can go, by confidence tier

Code health · Refactoring · Dead code · How it was validated →

Across your repositories

Real systems are more than one repository, and the expensive failures live between them. Change a backend contract and Repowise names the frontend calls that consume it, the services downstream, and the architecture rule the new dependency breaks, before it ships.

Workspace guide and support matrix → · Keeping the index fresh →

Measured against the field

The same repositories, commits and questions for every tool, each given its full advertised surface, against answer keys we did not write.

No single product competes with all of this, so there is no single table. Rows marked measured are head-to-head numbers that link to docs/BENCHMARKS.md, where the sample sizes, the tests and the rows we lose live. Unmarked rows are capability presence, not measurements.

As an agent context layer

The two cost rows answer different questions. Building the call graph, we are the lightest tool measured, about ten times lighter than the next, and roughly as fast as the fastest. Building the whole index, CodeGraph is 22x faster than we are, because by then we have also built the git-history layer, the wiki, the decisions and the health pass. If a call graph is all you need, that is the right trade and you should take it. With model-written prose on, it is 135x.

The hand-graded precision row cuts both ways. About fourteen percent of the call edges we draw are wrong, and on seastar CodeGraph grades better than we do. The compiler row exists because we graded the hand-read one ourselves: on Go and TypeScript the answer key is the Go team's own call graph and the tsc checker's own resolution, which we neither wrote nor can tune. Precision alone is easy to win by drawing almost nothing, and recall alone by drawing everything, so the claim is the pair.

_{Competitors measured at CodeGraph 1.5.0, Graphify 0.9.31, Serena 1.6.2.dev0 and code-review-graph 2.3.7 in August 2026. Repowise compiler-graded figures are from main on 2026-10-03; the other Repowise rows are from 081a59fa, August 2026.}

As a code health tool

CodeScene is the only other vendor in this category with a published empirical defect study, which is why it is the one we ran head to head. It flags about 27 files where we flag 132, so if you want a short list to act on, its threshold is the better fit.

Documentation generators

DeepWiki, Google Code Wiki and Swimm generate documentation from a repository, which overlaps one of our layers. We have not measured against them, so there is no table here.

The PR bot, against LLM review bots

An LLM reviewer is a different product: it can read intent, and it can be wrong in a new way on every run. This one does set arithmetic over a call graph and a git history, so pushing the same diff twice gives the same review twice. Full side-by-side comparisons: repowise.dev/compare →