Docs

Install RedMirror Reflection, activate your licence, and point your coding agent at it. About five minutes.

1. Install

Reflection is a single binary, no runtime, no dependencies. One line downloads it and puts it on your PATH.

macOS & Linux

# installs to ~/.local/bin/redmirror-reflect
curl -fsSL https://dist.redmirror.io/install.sh | sh

Windows (PowerShell)

# installs to %LOCALAPPDATA%\Programs\redmirror-reflect
irm https://dist.redmirror.io/install.ps1 | iex

Prefer to grab the binary yourself? Every build is at dist.redmirror.io, redmirror-reflect-macos, redmirror-reflect-linux, redmirror-reflect-windows.exe. Put it anywhere on your PATH. Check it runs:

redmirror-reflect --version

Keep it current any time, it self-replaces (checksum-verified):

redmirror-reflect update

2. Activate your licence

After you start your free trial you get a licence token by email. Activate it once, on each machine:

redmirror-reflect license activate <your-token>

That stores the token locally and validates it with the licence server. In CI or a container, skip the file and pass it in the environment instead:

export REDMIRROR_REFLECT_LICENSE=<your-token>

3. Add it to your editor

Reflection speaks MCP, so it drops into any agent that supports MCP servers. The command is always the same, redmirror-reflect mcp, only the config file differs. Pick your editor:

claude mcp add reflection -- redmirror-reflect mcp

{
  "mcpServers": {
    "reflection": {
      "command": "redmirror-reflect",
      "args": ["mcp"]
    }
  }
}

{
  "servers": {
    "reflection": {
      "type": "stdio",
      "command": "redmirror-reflect",
      "args": ["mcp"]
    }
  }
}

# config.toml
[mcp_servers.reflection]
command = "redmirror-reflect"
args = ["mcp"]

{
  "mcpServers": {
    "reflection": {
      "command": "redmirror-reflect",
      "args": ["mcp"]
    }
  }
}

{
  "mcpServers": {
    "reflection": {
      "command": "redmirror-reflect",
      "args": ["mcp"]
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "reflection": {
      "type": "local",
      "command": ["redmirror-reflect", "mcp"],
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "reflection": {
      "command": "redmirror-reflect",
      "args": ["mcp"]
    }
  }
}

# Pi
pi install https://dist.redmirror.io/pi/reflection.git
# …or with npm
npm i -g https://dist.redmirror.io/pi/reflection.tgz

redmirror-reflection activate <your-token>
redmirror-reflection ./src

4. Use it

Once it's installed, just ask your agent to scan a file, a change, or the whole repo for real bugs. Guided by orient/angles to the risky relations, it states an invariant and the kernel searches every reachable state, all with your agent's own model. What comes back is either a counterexample you can replay, the exact steps that reach the bug, or a bounded proof that none exists in range, and your agent reports only what the gate stamped GROUNDED.

Install the skill (so your agent follows the enforced flow)

Reflection ships its own agent skill: the claim/witness grammar and the protocol (orient → scaffold → propose → redmirror_reflect_gate → report only what's stamped GROUNDED). The binary prints it, so there's nothing extra to download; drop it where your agent reads skills or rules:

# Claude Code
redmirror-reflect skill > .claude/skills/reflection/SKILL.md
# Cursor / Windsurf / any agent, paste it into your rules file
redmirror-reflect skill

Prefer to read or copy it first? It's also hosted at redmirror.io/skill.md. With the MCP tools mounted your agent already has the grammar from the tool descriptions, the skill just helps agents that drive the verbs by hand.

Make it mandatory (hard enforcement)

The skill is advisory, an agent can ignore it. To make the gate unskippable, let the agent's own tooling run it, one command scaffolds the pack for your agent (project-level only, run it from your project root — it writes under the current directory, never your global config):

redmirror-reflect init claude   # tools (MCP) + skill + a Stop hook that blocks finishing until findings are grounded
redmirror-reflect init pi       # the extension (tools + skill) + the gate wired into pi's flow
redmirror-reflect init jcode    # tools + skill (jcode is an MCP host)
redmirror-reflect init cursor   # tools + rules …also windsurf · codex · gemini · dsh · ci

Using another agent? redmirror-reflect init <its-name> still works — for an agent with no preset it prints the exact MCP wiring and skill so you can set it up by hand. Any MCP-capable agent works.

Where the agent has real hooks (Claude Code, Pi) this is true enforcement, the harness runs redmirror-reflect audit, not the model, and blocks until every gated finding is grounded. Where it only has rules (Cursor, Windsurf, Codex, Gemini) the skill is installed and a CI gate (redmirror-reflect init ci) is the universal hard backstop.

Whole-repo scans track coverage. Given no single file to look at, the skill has the agent map the target into subsystems × angles — one per invariant family the subsystem touches (accounting, lifecycle, idempotency, referential integrity, races, authorization) — and record each in .redmirror-reflect/coverage.jsonl. audit then blocks until every cell is grounded (a proven bug) or cleared (proven safe) — no subsystem left unexamined.

Ground another tool's findings too

RedMirror finds bugs on its own — and because it proves them, it can also sit behind whatever else surfaces candidates for you: Claude Code's /security-review, your model's own pass, or a tool like Semgrep or CodeQL. Run your review first, then have Claude prove each finding with RedMirror and keep only what the kernel grounds:

# 1. run your review, in Claude Code
/security-review
# 2. then, same session:
"Ground each of those findings with reflection: redmirror_reflect_witness for injection
 you can reproduce, redmirror_reflect_refute for auth/logic bugs. Keep only what it confirms."

Real candidates come back CONFIRMED with a replayable reproduction; look-alikes that can't be reproduced come back INCOMPLETE and are dropped, on the record. A worked example (a real exec injection next to a safe execFile sibling, where the review flags both and Reflection confirms only the first) is in demo/claude-security-x-reflection.

5. Your model

Your coding agent is the model, and there's no key to set for Reflection. Your agent proposes findings with its own model; the kernel's tools (orient, scaffold, gate) do the exhaustive checking with no tokens, so there's nothing to configure and nothing extra to pay for beyond your agent's own usage.

Any tool-calling model works, and it doesn't have to be a frontier one: on the 440-case benchmark the same 96% real-bug recall holds on a 20B model as on a 120B, and small open models like qwen3-coder run the whole flow. A local model is fine, because the rigor lives in the gate, not the model.

6. Offline & renewal

Reflection runs offline. To keep working it checks your subscription with the licence server about once a week and receives a short-lived signed lease that lets it run without a connection until the next check. Between checks you can be fully offline.

If you cancel, the binary simply stops running once its current lease expires, within about a week. It never deletes or alters your code. If it can't reach the licence server for longer than a lease period, connect briefly to revalidate and it resumes. Manage or cancel your subscription any time from your account.

7. Support

Stuck, or something looks wrong? Email support@devs.mu, include your OS, editor, and the command or config you used. Billing and licence questions go to the same address, or manage your subscription from your account.