AI context for coding agents
Give the agent the answerable shape of the codebase.
Ten task-shaped MCP tools retrieve architecture, symbols, history, risk, decisions, and health without making the model reconstruct the repository through repeated search and file reads.
Open MCP protocol. Self-hostable. Every response reports index freshness and source bounds.
Read the MCP docs- fewer output tokens
- 31.6%
- tool calls
- 3.8 / 7.2
- files opened
- 3.0 / 7.2
- gold-file coverage
- 0.876
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 Codex run.
Repowise versus bare agent in the same paired run.
n = 42 · p = 0.00004 · ContextBench, 42 sealed instances, Python and Go · 2026-08
Real product evidence
Context arrives with the code, owners, decisions, and risk already joined.
A file page is the smallest useful proof of the index. The agent can retrieve the same bounded source, signatures, dependency snapshot, ownership, health, and governing decisions through MCP instead of assembling them from separate tools.
Capture: the Repowise repository. Product facts shown in the image belong to that index state.

How the index produces it
Index once, retrieve by task.
The useful unit is not a vector match. Repowise combines parsed code structure, graph reach, git history, generated knowledge, and calibrated retrieval into compact tool responses.
- 01 / Build
Parse structure and history
Language-aware parsing resolves symbols, imports, calls, ownership, hotspots, decisions, and health into one durable index. - 02 / Retrieve
Call the task-shaped tool
get_answer, get_context, get_risk, get_why, and the other flagship tools return only the evidence needed for the current task. - 03 / Verify
Keep freshness and bounds visible
Every response reports the indexed commit, age, staleness when applicable, and exact source bounds so an agent knows when to trust or verify.
Honest limitations
The benchmark proves efficiency, not answer quality.
The published Codex effect comes from one repository and one harness. Claude results were less stable, and no measurable answer-quality change was established. A compact retrieval payload is also not the same as an end-to-end agent-loop saving. Read each condition before applying the figure to your own workload.
Questions, answered
The details behind the claim.
Which agents and editors does it work with?
Any MCP-compatible client. repowise is agent-neutral: it works with Claude Code (primary, with one-command setup), Codex CLI, Cursor, Cline, and Windsurf, plus any tool that speaks the Model Context Protocol. The same ten tools are exposed over a single MCP endpoint, so you are not locked to one editor.
How much does it cut 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. A second run on Claude Code held at 15.9%. Loading one commit's context on its own is a separate, easier number: 35.6x fewer tokens than reading every changed file, which measures one payload rather than a finished session.
What is distill?
Distill is index-aware output distillation. It compresses noisy command output such as pytest, git log, and git diff before the agent reads it, saving 60 to 90 percent of the tokens while preserving every error line. Measured savings: 61% on a pytest run with 11 failures (all 11 failure lines kept), 89% on git log, and 86% on a 30-commit git diff. It is fully reversible.
How does it know when the index is stale?
Every MCP response carries a _meta envelope with index_age_days, the indexed_commit, and a stale_warning that appears only when the index has actually diverged from HEAD. Silence means the index is current. This is honesty as a feature: the agent is told when to verify against source rather than trusting a snapshot blindly.
Is it locked to one editor or vendor?
No. repowise is open source under AGPL-3.0 and self-hostable, and it speaks the open Model Context Protocol, so any MCP client can call it. You can run it fully local with your own API key, or fully offline via Ollama, and your code never has to leave your infrastructure.
What are the ten tools?
get_overview (architecture map, module list, entry points), get_answer (a cited answer with calibrated retrieval_quality), get_context (a triage card for files, modules, or symbols), get_symbol (raw source bytes for one indexed symbol), search_codebase (semantic search over the wiki), get_risk (hotspot scores, dependents, and PR directives), get_change_risk (a pre-merge defect-risk score for a commit or diff range), get_why (architectural decision rationale and lineage), get_dead_code (unreachable code by confidence tier), and get_health (per-file code-health scores).
How is this different from my IDE's built-in index?
IDE indexes like Cursor and Continue are ephemeral, single-repo, and embeddings-only: they re-embed on demand and forget. repowise is a durable, structured layer every agent can call over MCP, enriched with code health, git history, ownership, and architectural decisions your editor never sees, and it spans multi-repo workspaces.
Does it generate context files like CLAUDE.md?
Yes. repowise auto-generates CLAUDE.md for Claude Code and a managed AGENTS.md for Codex, with architecture, entry points, hotspots, and conventions, and keeps them current as the codebase changes. Agents that read those files get accurate orientation before they make a single tool call.
Last reviewed: September 2026
Give your agent real codebase context in one call.
Index a repository, connect an MCP-compatible client, and let the agent retrieve the evidence it needs without rediscovering the codebase.