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%

n = 43 · p = <0.0001 · Codex (gpt-5.6-sol) · django/django at a single pinned commit · 2026-08

tool calls
3.8 / 7.2

Repowise versus bare agent in the same Codex run.

files opened
3.0 / 7.2

Repowise versus bare agent in the same paired run.

gold-file coverage
0.876

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.

Repowise file intelligence page showing source-linked health, ownership, decisions, and dependencies.
File intelligence in Repowise, with provenance and related evidence kept beside the source.

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.

  1. 01 / Build

    Parse structure and history

    Language-aware parsing resolves symbols, imports, calls, ownership, hotspots, decisions, and health into one durable index.
  2. 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.
  3. 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.