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.

A Repowise answer to how a file code health score is calculated, built from seven tool steps over the repowise-dev/repowise index.

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.

  1. 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.

  2. 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.

  3. Distill

    Less to read, nothing lost.

    Test and git output shrink by 60 to 90 percent with every error line kept.

  4. Context files

    CLAUDE.md and AGENTS.md, written and kept current.

    Architecture, entry points, hotspots and conventions, regenerated as the code moves.

  5. 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.

  6. 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.

Repowise file page for spec.py: an 8.3 health score, 59 files that depend on it, owner, tests and the decision that governs it.
repowise-dev/repowise · one file, already joined

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.

The same index the dashboard reads is exposed over the Model Context Protocol, so the agent asks a question and gets a shaped answer instead of a pile of files.
  1. 01 / Index

    Index once, update per commit

    Structure, history, tests and decisions are read from the repository and kept current.
  2. 02 / Connect

    Add the server in one command

    Claude Code, Cursor, Codex, Cline and any MCP client point at the same endpoint.
  3. 03 / Ask

    The agent picks the tool that fits

    Ask, triage, search, risk, why, health: each question has a tool shaped for it.

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.