@rvry/mcp

Reasoning Depth Enforcement for LLMs.

RVRY is an MCP server that improves AI reliability by forcing your model to finish thinking before it answers. When your AI raises a question, RVRY remembers it. When it makes an assumption, RVRY flags it. When it tries to wrap up while those are still unaddressed, RVRY doesn't let it.

Same model. Same question. Different answer.

Quick Start

npx --yes --package @rvry/mcp@latest rvry-mcp setup

The wizard will:

1. Open your browser to sign in (or prompt for a token)
2. Auto-detect supported clients on your machine
3. Configure them automatically

Supported clients: Claude Code, Claude Desktop / Co-Work, Codex

Restart any running clients after setup, and RVRY is ready.

Codex

To configure only Codex, run:

npx --yes --package @rvry/mcp@latest rvry-mcp setup --client codex

The installer registers the rvry MCP server through the Codex CLI and installs seven namespaced skills under ~/.agents/skills/:

| Skill | Tool | What it does | |-----------------------|-----------------|-------------------------------------------------------------------------------| | $rvry | rvry | Reflective answering: observation first, then an answer under its commitments | | $rvry-think | think | Quick structured analysis of a question | | $rvry-think-model | think_model | Apply one of the 18 named mental models | | $rvry-deepthink | deepthink | Deep multi-round analysis of a hard question | | $rvry-problem-solve | problem_solve | Structured decision-making before commitment | | $rvry-challenge | challenge | Adversarial stress-testing with a GO / NO GO verdict | | $rvry-meta | meta | Metacognitive observation on a topic |

For example: $rvry-deepthink Should we split the billing service?

The installer does not add a Codex lifecycle hook, and none is required. The MCP registration and skill files contain the integration. After installing or updating RVRY, restart existing Codex sessions or reload skills so they discover the new files.

Manual Configuration

For Codex, register the MCP server with its CLI:

codex mcp add rvry --env RVRY_TOKEN=rvry_your_token -- npx --yes --package @rvry/mcp@latest rvry-mcp

This manual command creates or overwrites the rvry registration, but it registers the tool server only. Use the setup command above to install the seven Codex skills as well. Do not print the registration as a verification step: current Codex CLI output includes the literal RVRY_TOKEN.

For any MCP client that supports stdio transport, add this to your MCP config:

{
  "rvry": {
    "command": "npx",
    "args": ["--yes", "--package", "@rvry/mcp@latest", "rvry-mcp"],
    "env": {
      "RVRY_TOKEN": "your_rvry_token"
    }
  }
}

Get your token at rvry.ai/dashboard after signing up.

Tools

| Tool | What it does | Plan | |---------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------| | think | Structured analysis for questions that need structure, not a saga. 1–3 analytical rounds; simple questions complete in one. | Free+ | | deepthink | Extended multi-round analysis for high-stakes questions. Catches assumptions, tests them, and doesn't let your AI wrap up until it's dealt with what it found. | Free+ | | rvry | Reflective answering. A protected observation round surfaces the commitments the answer must honor, then the answer is produced under them — with a ledger showing the fate of every commitment. | Free+ | | think_model | Applies one named mental model — 18 available, from Five Whys to Red Team — as a structured session with model-specific stages and synthesis. | Free+ | | problem_solve | Structured decision-making: orient, anticipate, generate, evaluate, commit. Includes a six-bias audit and written reversal conditions before the recommendation is final. | Pro+ | | challenge | Adversarial stress-testing. Finds weaknesses, tests assumptions, surfaces edge cases, and closes with a GO / CONDITIONAL GO / NO GO verdict. | Pro+ | | meta | Sustained metacognitive observation. Examines how your AI is thinking, not just what it's thinking. | Max |

The 18 Mental Models

think_model (/think-model in Claude Code, $rvry-think-model in Codex) runs exactly one model as an engine-enforced session — fixed stages, model-specific output structure, no early exits.

| | | | |-------------------------|-------------------------|-------------------------| | five-whys | rubber-duck | assumption-surfacing | | fermi-estimation | abstraction-laddering | decomposition | | constraint-relaxation | first-principles | steelmanning | | opportunity-cost | trade-off-matrix | time-horizon-shifting | | reversibility | pre-mortem | inversion | | second-order-effects | red-team | impact-effort-grid |

/think-model pre-mortem we're migrating the billing system to event sourcing next quarter

A Five Whys session ends with a verified causal chain and a root-cause fix. A Pre-mortem ends with a failure catalog, early warnings, and a written kill condition. A Red Team session attacks your proposal as named adversaries would and disposes of every attack — mitigated, or accepted in writing.

Choosing: stuck on a bug → rubber-duck; recurring problem → five-whys; risky initiative → pre-mortem; already made up your mind → steelmanning; deciding how much rigor a decision deserves → reversibility; backlog to order → impact-effort-grid; every solution feels like a compromise → constraint-relaxation. Close variants of names resolve automatically (premortem, steelman, 5-whys, …).

Slash Commands (Claude Code)

When you run setup and select Claude Code, the wizard installs these commands:

| Command | Tool | What it does | |------------------|---------------|----------------------------------------------------------------| | /think | think | Quick structured analysis of a question | | /deepthink | deepthink | Deep multi-round analysis of a hard question | | /rvry | rvry | Reflective answering — self-observation first, then the answer | | /think-model | think_model | Apply one named mental model to a problem | | /problem-solve | problem_solve | Structured decision-making, stress-tested before commitment | | /challenge | challenge | Adversarial stress-test with a GO / NO GO verdict | | /meta | meta | Metacognitive observation on a topic |

Usage: type /deepthink [your question] in Claude Code. Each command routes to the corresponding RVRY tool and includes rendering instructions so analysis appears as visible markdown rather than hidden in tool calls.

--record flag: Append --record to any command (e.g. /deepthink --record [question]) to archive per-round bodies under .rvry/<op>/<timestamp>-<slug>/ alongside the harvest file.

Updating commands: Re-running setup refreshes the RVRY-owned command files. Any pre-existing file is backed up to <name>.md.bak before it is overwritten.

Commands are installed to ~/.claude/commands/.

Codex Skills

When you run setup with --client codex, the installer writes the seven skills listed above to ~/.agents/skills/. Each skill includes Codex metadata declaring the rvry MCP dependency and disabling implicit invocation, so RVRY runs only when you explicitly select a namespaced skill. The skills preserve the same multi-round continuation, visible observation/reflection, harvest, and optional recording behavior as the Claude Code workflows.

The metadata identifies the already configured stdio dependency; it cannot carry the package arguments or RVRY_TOKEN needed to install RVRY by itself. Use the setup command above as the complete install and repair path.

Invoke a skill by name followed by the question, for example:

$rvry-think-model pre-mortem we're migrating billing to event sourcing next quarter

Re-run setup to refresh RVRY-owned skill files and metadata after a package update. Changed RVRY-owned files are backed up beside the original with a .bak suffix. New Codex sessions discover them automatically; restart an existing session or reload skills after installation. No Codex lifecycle hook is installed or required.

Parameters

All tools accept:

| Parameter | Type | Required | Description | |-----------------------|----------|----------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | input | string | Yes | Your question (new session) or analysis findings (continuation). | | sessionId | string | No | Session ID for continuing an existing session. | | skipScoping | boolean | No | Skip the scoping questions phase and begin analysis immediately. | | userConstraints | string[] | No | User-stated directives or requirements to track across rounds. | | requiresCurrentData | boolean | No | Set to true when the question depends on facts, policies, prices, or events that may have changed. Seeds a verification constraint that persists across all rounds. | | record | boolean | No | When true on every call, the local client archives each round's body to .rvry/<op>/<timestamp>-<slug>/round-N-<label>.md. Passed from slash commands via the --record flag. | | harvest | object | No | Final-call-only. The client includes its synthesis (title, summary, keyFindings, shimmer, openQuestions, followUps, plus operation-specific fields) so it can be persisted to the local session file. | | rounds | array | No | Final-call-only, present only when --record was set. Array of {round, mode, body} for each analytical round. |

think_model additionally requires modelName (one of the 18 model ids) on the first call.

Required user-input pauses: A scoping response includes scopingQuestions; ask the user and resume with the same sessionId. During analysis, the client exposes mustAskUser: true when the engine requires an answer before it can continue. blockingUnknowns is included only under that exact gate and is withheld otherwise. Ask the user, stop the current turn, then continue the same session with an evidence-bearing RESOLVE Cn: constraint update for the user's answer; a raw answer alone does not resolve the engine constraint.

When to use requiresCurrentData: Any question about regulations, pricing, legal rulings, market conditions, API specifications, or current events. The engine will require the model to explicitly classify every cited fact as either verified-current or training-data-dependent before concluding.

SHIMMER display: Most sessions open with a self-observation round. The model displays RVRY SHIMMER with the revery definition before its observation — this is the priming phase, where the model observes its own processing before structured analysis begins. The observation is preserved verbatim in the final harvest.

Local session artifacts: On the call that completes a session, the client persists the synthesis to .rvry/<op>/<timestamp>-<slug>/harvest.md in your project — every session leaves a durable artifact. With --record, each round's full body is archived alongside it. Add .rvry/ to .gitignore if you don't want session artifacts in version control.

How It Works

Your AI already has the reasoning capacity. RVRY forces it to use that capacity by holding it accountable — when it raises a question, that question has to get answered. When it makes an assumption, that assumption has to get tested. Throughout a session the engine tracks three kinds of obligation — things the analysis must still address, moves it must not make, and questions it can't silently drop — and a session cannot conclude while any of them are open.

The model keeps working not because it was told to think harder, but because it hasn't finished what it started. On hard questions, a smaller model with RVRY outperforms a bigger model without it. The bottleneck was never how smart the AI is. It was whether the AI finished thinking.

Learn more →

Pricing

| Plan | Sessions | Tools | Price | |------|-----------|---------------------------------------------|--------| | Free | 5/month | think, deepthink, rvry, think_model | $0 | | Pro | 21/month | Free tools + problem_solve, challenge | $20/mo | | Max | Unlimited | All tools, including meta | $99/mo |

Sign up at rvry.ai.

Requirements

• Node.js ≥ 18
• An MCP client with stdio transport support (Claude Code, Claude Desktop, Codex, and most others)

License

MIT — this package is the open client. The RVRY engine is a hosted service; a token from rvry.ai is required.