Agent context
Give your coding agent the whole repo.
Claude Code, Cursor, Codex and Cline call ten Repowise tools over MCP and get cited answers, instead of guessing from the files they happen to have open.
Zero LLM calls in the analysis. Your code stays where it is.

repowise-dev/repowise · a cited answer from the index
Measured, not claimed
- 31.6%
- fewer output tokens
- n = 43 · p = <0.0001 · Codex (gpt-5.6-sol) · django/django at a single pinned commit · 2026-08
- 3.8 / 7.2
- tool calls
- Repowise versus bare agent in the same Codex run.
- 3.0 / 7.2
- files opened
- Repowise versus bare agent in the same paired run.
- 0.876
- gold-file coverage
- n = 42 · p = 0.00004 · ContextBench, 42 sealed instances, Python and Go · 2026-08
Sound familiar?
Your agent is smart. It is also flying blind.
- 01
It reads twenty files to answer one question.
- 02
It changes code it has never seen the callers of.
- 03
Every new session starts from zero.
What makes it different
The context it was guessing at, one call away.
- Cited answers
Ask anything, get the lines it came from.
One tool call returns the answer with its sources and how confident the retrieval was.
- Risk before the edit
Callers, co-changes and tests, before it touches a file.
The agent learns what a change reaches while it is still cheap to change course.
- Distill
Less to read, nothing lost.
Test and git output shrink by 60 to 90 percent with every error line kept.
- Context files
CLAUDE.md and AGENTS.md, written and kept current.
Architecture, entry points, hotspots and conventions, regenerated as the code moves.
- Warned mid-edit
Told when a function keeps breaking.
Hooks name the bug-fix history and the decisions that govern a file while the agent is in it.
- Ten tools
One shaped answer per question.
Ask, triage, search, read a symbol, check why, risk, change risk, health, dead code and the overview.
On a real repository
Everything the agent needs about a file, already joined.
A file page is the smallest useful proof of the index: bounded source, signatures, dependencies, owners, health and the decisions that govern it. The agent gets the same page through one MCP call instead of assembling it from five tools.

In plain words
The memory of the repo your agent does not have.
Repowise reads your repository once and builds a verified map of it: who calls what, which files change together, what the tests cover, why the code is shaped the way it is. Your agent asks a question over MCP and gets the answer with its sources, instead of reading forty files to find it.
How to read it
How to read an answer
- Verified
- The lines were checked against the live tree. The agent can act on them without reading the file again.
- Degraded
- Something failed to load or was trimmed. The reply says what, and names the targets to read yourself.
- Stale warning
- A file the answer relies on has changed since the index. Update, then ask again.
- A zero carries its basis
- An empty list of callers arrives with how much of that language's calls the graph resolved. Read that before concluding nobody calls it.
How it works
One index. Ten tools. Any agent.
- 01 / Index
Index once, update per commit
Structure, history, tests and decisions are read from the repository and kept current. - 02 / Connect
Add the server in one command
Claude Code, Cursor, Codex, Cline and any MCP client point at the same endpoint. - 03 / Ask
The agent picks the tool that fits
Ask, triage, search, risk, why, health: each question has a tool shaped for it.
Where it shows up
Shows up where the work already happens.
Claude Code
One command adds the server, the hooks and the slash commands. Every session starts with the freshness of the index and the decisions that govern the files you are in.
Cursor
Paste one MCP snippet. The agent gets the same ten tools and the same cited answers.
Codex
The Codex plugin carries the tools, the skills and a managed AGENTS.md kept current on every commit.
CLI
Ask, distill and check risk from the terminal, with or without an agent in the loop.
Questions
What people ask before they try it.
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, not 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 instead of 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: October 2026
Get started
Give your agent the context it was guessing at.
Index a public repository free, connect your agent in one command, and ask it something you already know the answer to.