FOR DEVELOPERS
Give your coding agent the context it would otherwise reconstruct.
Index architecture, symbols, history, ownership, decisions, and health once. Then let any MCP-compatible agent retrieve the bounded evidence it needs before a change.
The index is durable and inspectable. Model-backed prose is optional, and freshness travels with every response.
Read the quickstart- fewer output tokens
- 31.6%
- tool calls
- 3.8 / 7.2
- gold-file coverage
- 0.876
- flagship MCP tools
- 10
n = 43 · p = <0.0001 · Codex (gpt-5.6-sol) · django/django at a single pinned commit · 2026-08
Repowise versus bare agent in the same published Codex run.
n = 42 · p = 0.00004 · ContextBench, 42 sealed instances, Python and Go · 2026-08
The curated task-shaped set documented for individual repository work.
Relevant product evidence
The file is no longer an isolated blob of source.
A developer can inspect source-linked health, ownership, decisions, dependencies, and history in one readable surface. The agent retrieves the same indexed relationships through MCP, so the human and the tool act from the same evidence.
Capture: file intelligence from the Repowise repository. Values belong to the named index state.
How the index produces it
A repeatable individual workflow.
The useful loop is small: orient once, retrieve the task-shaped evidence, verify the boundary, then make the change with risk and tests already visible.
- 01 / Orient
Map the repository once
Parse symbols and dependencies, join git history and ownership, and build documentation, decisions, and health over the same graph. - 02 / Retrieve
Ask for the task, not a pile of files
Use get_answer for a cited explanation, get_context for a triage card, get_risk before an edit, and get_why when the code's history matters. - 03 / Verify
Keep source bounds and freshness visible
Responses report exact source ranges and index freshness so the agent can verify only when the evidence says it should. - 04 / Change
Carry risk and tests into the diff
Use dependents, co-change partners, measured or inferred tests, and code-health findings to narrow the review surface before implementation.
Plan or deployment fit
Choose who operates the same engine.
Start locally when you want full runtime control. Use Hosted when you want managed indexing and a public product surface. Move to a paid plan only when private code, sustained model-backed work, or shared operation requires it.
Open source
Local and self-hosted
Install the AGPL-3.0 engine, index on your machine, and connect your agent over MCP.
Best fit: individual workflow and local control.
Hosted Free
Browse and ask on real repositories
Index public repositories and use 10 grounded answers per calendar month from one shared answer pool.
No card. Private repositories and model-written documentation are excluded.
Hosted Pro
Private repositories and sustained AI use
From $15/month on monthly billing, with private repositories, push-triggered re-indexing, model-written documentation, and credit-billed answers.
The deterministic surfaces do not consume credits.
Honest limitations
Efficiency is measured; quality still needs evaluation.
The published agent-loop effect comes from one repository and one harness. Claude results were less stable, and no measurable answer-quality change was established. Local deterministic analysis also does not mean every feature is local-only: optional prose, answers, and generated code may send code-derived context to the model provider configured for that deployment.
Questions, answered
The details behind the claim.
Which AI agents and editors does repowise work with?
repowise exposes your codebase through the Model Context Protocol (MCP), so it works with Claude Code, Cursor, Cline, and Codex, plus any other MCP-compatible client. The same index serves every agent, so you are not locked to one editor.
How much does repowise reduce my agent's token usage?
In a real agent loop (Codex, django/django, 43 questions against a bare-agent control), repowise cut output tokens 31.6% and reached an answer in 3.8 tool calls instead of 7.2, opening 3.0 files instead of 7.2. The published result is specific to that repository and harness; it did not establish an answer-quality change.
Is repowise free? Do I need to send my code anywhere?
The core engine is free and open source under AGPL-3.0. Deterministic indexing runs locally. Optional model-backed generation can send code-derived context to the model provider you configure, so that provider's data policy applies.
How is this different from my editor's built-in codebase index?
An IDE index is usually editor-specific and retrieval-focused. repowise joins parsed structure, dependency reach, git history, ownership, decisions, and code health in a durable index that any MCP-compatible client can query.
What are the ten MCP tools?
get_overview, get_answer, get_context, get_symbol, search_codebase, get_risk, get_change_risk, get_why, get_dead_code, and get_health. They are task-shaped so an agent can retrieve bounded evidence instead of reconstructing the repository through repeated reads.
How does repowise stay current as I keep committing?
The local engine updates incrementally, while hosted paid plans can re-index on pushes. MCP responses report the indexed commit, age, and a stale warning when the served source has diverged.
Last reviewed: September 2026
Give your agent a durable model of the repository.
Install Repowise, index the codebase, and connect the MCP client you already use.