Repowise: A Local, Deterministic Code Intelligence Index for AI Agents and Humans

What Repowise Actually Solves

Repowise targets a specific inefficiency: coding agents that rediscover repository structure on every task. Instead of grep, read, and re-read, the tool precomputes a graph of symbols, callers, git history, tests, and architectural decisions. The README frames the problem as questions like 'Who calls this function?' and 'What breaks if I change it?' that could be answered ahead of time. The intended users are developers who run Claude Code, Codex, Cursor, or any MCP host, and who want cited context, blast radius, and test impact without burning LLM calls. The project also serves humans through a local dashboard and code health scores. The core claim is that exploration work is done once, and agents receive task-shaped context instead of raw file dumps.

The One-Index Architecture and Its MCP Surface

The architecture is a single local index that combines multiple layers: the call graph, git history, test relationships, code health scores, dead code detection, and a structural wiki. The README stresses that these are not disconnected scanners. The graph locates what git history flags, code health measures it, tests show what guards it, and decisions explain why it exists. The same evidence feeds agents, editors, pull requests, and a dashboard. The MCP interface exposes ten task-shaped tools, rather than the typical entity-based tools that force agents into long sequential chains. You can pass several targets in one call and get complete context back. The README gives examples like `get_overview` and a question about changing `src/auth.py`. This design is a deliberate contrast to tools that return one file or one symbol at a time.

Getting It Running: Commands and Configuration

The quickstart is three commands. Install with `pip install repowise`, then inside a repository run `repowise init --no-prose -y` followed by `repowise serve`. The `--no-prose` flag skips the optional LLM-generated prose, keeping the core analysis fully local and deterministic. The init command builds the graph, git, decisions, health, dead-code, and structural-wiki layers, and it wires Claude Code automatically. After that, you connect any MCP host or open the dashboard. No API key is needed for the core analysis. The README notes that optional synthesis is the only LLM layer, so the default path is zero LLM calls for graph, risk, health, tests, dead code, and PR review. The setup is genuinely minimal, but the documentation points to a separate quickstart guide for full setup and every agent, which suggests the three-command flow may not cover all hosts.

The Measured Claims: What to Believe and What to Verify

The README leads with numbers: 31.6% less agent-generated output across 43 repository questions, 3.8 instead of 7.2 tool calls, and 7 out of 7 undominated precision/recall cells in a compiler-graded evaluation. It also claims 2.3 times more defects surfaced than CodeScene under a 20%-of-lines review budget. These are strong claims, and the README is careful to note that the 393-versus-13,984 figure is one retrieval payload, not end-to-end savings. It also says every benchmark publishes its sample, method, limitations, and losing rows in docs/BENCHMARKS.md. I cannot verify those numbers from the repository material alone. The p-values and sample sizes are reported, which is more than most tools offer, but you should read that benchmark file before trusting the headline percentages. The comparison to CodeScene is particularly interesting because CodeScene is a commercial tool with a different approach, so the methodology matters.

Where Repowise Is the Wrong Tool

Repowise is not a lightweight linter. It builds a full index, which takes time and disk space, and it is designed for repositories with enough complexity that grep and a CI test suite become insufficient. For a small project with a few hundred files, the overhead of indexing and running an MCP server is likely not worth it. The README does not mention supported languages, which is a red flag: if your stack uses an uncommon language, the call graph and dead code detection may not work. The tool also assumes you are willing to run a local server and connect an agent or dashboard. If your team does not use MCP-capable agents, the main interface is less useful. The AGPL-3.0 license is another constraint: if you need to embed or modify the code in a closed-source product, the license forces you to open your changes or buy a commercial license. The README mentions commercial licensing, but the default is strict.

The Real Alternative: CodeScene and the Difference in Approach

The README explicitly benchmarks against CodeScene, so that is the natural alternative. CodeScene is a commercial code analysis tool that also provides health scores and defect prediction, but it operates as a hosted or on-premises service with its own dashboard and CI integrations. Repowise differs in two ways. First, it is agent-first: the MCP tools are designed to feed coding agents directly, while CodeScene's primary audience is human reviewers and managers. Second, Repowise keeps the core analysis local and deterministic, with no API key, whereas CodeScene's analysis is proprietary and not fully transparent. The benchmark claims that Repowise surfaces more defects than CodeScene under the same review budget, but that is a single comparison. If you already use CodeScene, Repowise might complement it rather than replace it, but the overlap in health scoring means you would need to reconcile two sources of truth.

Maintenance, Upgrades, and License Implications

The project is actively maintained, with releases v0.44.0 through v0.46.0 in August 2026, and the default branch is not archived. The version numbers below 1.0 suggest the API and MCP tool surface may still change. The README does not describe a migration path for configuration or index formats, so you should expect to re-run `repowise init` after upgrades. The license is AGPL-3.0, which means any network service that uses the modified software must offer its source code to users. That is a significant implication if you plan to expose Repowise as a shared service within your organization or to customers. The README mentions a commercial license for teams and enterprises, but the terms are not detailed in the material. For internal use where you do not modify the tool, the AGPL is manageable, but if you need to extend the analysis or integrate it deeply, you must either publish your changes or buy a commercial license. The core analysis being local and deterministic is a maintenance advantage: no external API dependencies to break.

Editorial conclusion

Adopt Repowise if you run a coding agent and want to reduce its exploratory tool calls, or if you need a local, deterministic way to rank defect-prone files and compute test impact. Do not adopt it if your codebase is small enough that grep and a CI test suite suffice, or if you cannot accept the AGPL-3.0 license for your use case. Before rolling out, verify the benchmark methodology in docs/BENCHMARKS.md, confirm that the supported languages match your stack, and test the MCP integration with your specific agent host. The core value is the precomputed graph and the task-shaped tools, so start with `repowise init --no-prose -y` and measure the difference in your own agent workflow.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes