Documentation

Install Rhei, point it at a repo, and connect it to coding agents over MCP. Local mode works without an account: source, the local graph, reports, and memory stay on your machine.

cd /path/to/your/repo
npx -y @rhei-team/rhei init

An agent decides what to do. Rhei gives it the awareness to do it right: the right code, the prior work, and the boundaries to stay inside.

The result: fewer tokens, fewer sub-agents, the right files faster, and a team moving in one direction.

rhei init auto-registers Rhei with the MCP clients it finds, including Claude Code, Codex CLI, and Cursor. For any client it doesn't, point it at the CLI as a stdio MCP server:

# Claude Code
claude mcp add rhei -- rhei mcp

# any MCP client (stdio server config)
{ "command": "rhei", "args": ["mcp"] }

After changing MCP config or updating Rhei, restart or reconnect the client. rhei doctor verifies the wiring end to end.

Use the rhei MCP to find where upload rate limiting lives,
verify what is there, then add a limit to the upload route.

rhei context is the shell view of what Rhei has learned locally. It does not send source anywhere and it does not replace MCP tool calls; it gives humans and shell agents a compact readout of the same loop: goal memory, context traces, validation refs, commits, PRs, and current git changes.

npx -y @rhei-team/rhei context
npx -y @rhei-team/rhei context graph
npx -y @rhei-team/rhei context statusline --plain

Use it when you want to see what context Rhei would bring forward before asking an agent to act. Use rhei status for install and index readiness; use MCP tools like goal, context_builder, and read_file when the agent is doing the work.

+  Rhei Context · 53w
*  Recall  89% · 18 goals · 13 gaps
o  Proof   12/18 validated · 8/18 measured

          Jun
Mon       .  -  +  x  #
Tue       .  -  +  x  #
Wed       .  .  +  x  #
Thu       .  -  +  +  x
Fri       .  -  +  x  #
Sat       .  .  .  .  .
Sun       .  .  .  .  -
          .  -  +  x  #  low->high

Context Files · rhei · current
S   Recall   Gap Proof Goals Path
M   #######-  2    3     2  route.ts
    ####----  4    1     3  session.ts
??  --------  1    0     1  uploads.md
recall = evidence projected onto files
source remains authority

The output is advisory. Memory and traces can point Rhei toward useful files, but source, exact reads, validation, and receipts remain the authority for any code change.

Once your agent is connected (see Connect your agent), give it a goal. Here is the loop it runs on a real change:

goal mode=context
  goal: "add rate limiting to the upload route"

goal mode=verify
  query: "rate limit"  scopePaths: ["src/upload"]

apply_edits
  path: src/upload/route.ts  find: …  replace: …

validate target: "bun run test"
goal mode=trail

ledger op=plan_revert
  goalId: "add rate limiting to the upload route"

Every step is one receipt in the run's trace. See Traces for what they hold and why.

Rhei records every flow as a trace: each tool call, goal, memory read, and edit, attributed and addressable by id. A receipt is one event; a trace is the whole run.

A trace is made of receipts. Here is one, from this page's own edit:

apply_edits applied_verified
edit: applied 1/1  +14/-8 lines  mode=search_replace
readback: durable filesystem verified
frontier gate: active (depth 3)
authority: source writes / no production authority
receipt: receipt:rhei-code-io:edit:c60dfb99313f

In local mode, traces stay on your machine, keyed by event id, so the record compounds: the next task resumes from it, reviews read it, and your own analytics and audits query it.

Agents usually forget everything when a session ends. Rhei carries the useful parts forward, so the next task starts where the last one left off. What it remembers stays useful without being mistaken for fact.

In local mode, memory stays private on your machine. On Pro, it can follow you across machines and repos, according to your team's data settings.

Agents see one consolidated public MCP surface instead of a pile of one-off utilities, grouped by intent:

Edits are gated and receipt-backed: previews by default, apply only when explicit gates allow it, and durable verification after every write.

The same loop runs on every request: map, understand, retrieve, remember, prove.

1. 1

   It maps your repo

   A live map of your code: files, symbols, and how they connect, across 20 languages, kept current as you work. Active code stays hot and close; quiet code stays cold and cheap.

2. 2

   It understands the ask

   A symbol, an exact string, or a fuzzy intent. Rhei reads what you're after and looks the right way for each.

3. 3

   It brings the right files

   Only the few that actually matter, with the tests that guard them and a read plan, packed to your token budget. Never a blind dump of the whole repo.

4. 4

   It remembers what works

   Workspace memory learns from what your agents actually use: past fixes, decisions, and dead ends. The next task starts warmer, and useful is never confused with true.

5. 5

   It shows its work

   Every answer comes with a receipt: what it picked, what it skipped, and why.

Local mode keeps source, the graph index, reports, and memory on your machine. Paid plans only send what your configured source-upload mode allows: never, metadata_only, or selected_slices. Rhei does not train models on customer code by default.

Full contracts: Data Use overview, Security, and Privacy Policy.

rhei update        # dry-run: report current vs. latest
rhei update --yes  # apply, then restart your MCP client

Stuck or missing something? Email [email protected].