Quorum — Multi-Model AI Review & Consultation for Claude Code

Convene a quorum of AI models — OpenAI Codex, Google Gemini, and a fresh-context Claude (Fable) — to review Claude Code's work or answer its questions. Claude Code verifies every finding against the code and delivers one verdict.

Quick Install

Step 1: Add the MCP server

claude mcp add -s user quorum -- npx -y @simonren/quorum

Step 2: Restart Claude Code

The MCP tools and slash commands (/multi-review, /multi-consult) are installed automatically on first launch.

Check what quorum detects:

npx -y @simonren/quorum doctor

Manual command install (if needed):

npx -y @simonren/quorum update

Verify with:

claude mcp list
# quorum: npx -y @simonren/quorum - ✓ Connected

Alternative: Manual Install

git clone https://github.com/SimonRen/quorum.git
cd quorum/mcp-server
npm install && npm run build
claude mcp add -s user quorum -- node /path/to/quorum/mcp-server/dist/index.js

Prerequisites

Install at least one reviewer CLI. Claude Code itself is the third reviewer — it is spawned as a separate claude -p instance with read-only tools, no MCP servers, and no settings-file hooks or plugins, so it shares none of your conversation. It does still see the project's CLAUDE.md and Claude Code's auto-memory for that directory; only --bare would remove those, and --bare disables OAuth.

# OpenAI Codex CLI
npm install -g @openai/codex-cli
codex login

# Google Gemini — via the Antigravity CLI (`agy`). `gemini-cli` is sunset on 2026-06-18.
curl -fsSL https://antigravity.google/cli/install.sh | bash
agy  # follow the Google OAuth flow

Node.js 20 or newer.

Usage

/multi-review                                        # review the work from this conversation
/multi-review focus the challenge on rollback safety # steer both passes
/multi-review security [xhigh]                       # focus area + Codex xhigh reasoning
/multi-consult <question>                            # ask the panel, get one synthesized answer
/multi-consult <question> [flex]                     # Codex flex tier (cheaper/slower)

• /multi-review — for work Claude Code has already produced (code changes, a plan, findings, a proposal). Every model runs a standard pass (bugs, gaps, does it clear the stated bar) and an adversarial pass (assumptions, design decisions, failure paths) in parallel. Claude Code verifies each finding in the code and reports a verdict with a mandatory "Panel said:" footer.
• /multi-consult — for a question with no prior work to review: which approach, which technology, how to structure X. Each model answers in a fixed structure (Recommendation / Reasoning / Tradeoffs / Risks / Open questions); Claude Code synthesizes one recommendation with a "Models said:" footer so dissent stays visible.

Reserved tokens count only when bracketed at the end of the arguments: [flex] / [cheap], [default tier], [xhigh] (review) or [high reasoning] (consult). Both commands refuse to run from ~, /, /etc, or other sensitive directories.

For quick reviews: just say "review" and Claude Code uses its native abilities. The panel is only convened when you ask for it — a call runs six reviewer processes and takes minutes.

How It Works

Claude Code does work → /multi-review → brief + cwd → Codex, Gemini, Claude review (standard + adversarial, read-only)
                                                    → Claude Code verifies findings against the code → verdict + "Panel said:"

You have a question   → /multi-consult → question + criteria → Codex, Gemini, Claude answer
                                                    → Claude Code synthesizes → recommendation + "Models said:"

Key principles:

• Claude Code is primary. External models assist; Claude Code verifies and decides.
• Working-directory strategy. Claude Code passes the cwd and a small brief; reviewers read the files themselves. Read-only by contract: Codex runs with --sandbox read-only; Claude runs in default permission mode with prompts disabled, write and agent tools removed, and only read-only git allowed in Bash; agy runs with --sandbox, which covers only its terminal, and agy lets the model rerun a command outside it unless agy's toolPermission is proceed-in-sandbox (doctor warns on always-proceed). agy cannot make its file tools read-only, so quorum fingerprints the working tree (git status) before and after every run and flags any change at the top of the result.
• Structured, verifiable answers. Reviewers respond with Verdict / Findings (severity, location, evidence, impact, fix, confidence) / Answers / Decisions; drift from the contract is flagged so Claude Code can discount it.
• Synthesis, not passthrough. Raw model output never reaches you unless you ask for it; the provenance footer always does.

Configuration

~/.config/quorum/config.json is created with defaults on first launch and hot-reloaded when edited. Every key is optional.

{
  "codex": {
    "enabled": true,
    "model": "gpt-6.1-sol",
    "reasoningEffort": "high",
    "serviceTier": "fast",
    "consultReasoningEffort": "xhigh",
    "consultServiceTier": "fast",
    "inactivityTimeoutMs": { "high": 300000, "xhigh": 600000 },
    "maxTimeoutMs": 3600000
  },
  "claude": {
    "enabled": true,
    "model": "fable",
    "fallbackModel": "opus",
    "effort": "high",
    "consultEffort": "xhigh",
    "inactivityTimeoutMs": 300000,
    "maxTimeoutMs": 3600000
  },
  "gemini": {
    "enabled": true,
    "model": "gemini-3-pro-high",
    "inactivityTimeoutMs": 900000,
    "maxTimeoutMs": 3600000
  }
}

| Key | Notes | |-----|-------| | <adapter>.enabled | false leaves that model out of the panel even when its CLI is installed. | | claude.model | Passed as claude --model: an alias (fable, opus, sonnet) or a full model id. | | claude.fallbackModel | Passed as --fallback-model, used when the primary is overloaded or not available; null disables it. | | claude.effort / claude.consultEffort | claude --effort (low…max) for review / consult; null omits the flag. | | codex.reasoningEffort / codex.serviceTier | Review defaults; the consult* keys are the consult defaults. Tool arguments override both. | | gemini.model | Passed as agy --model; omit to use agy's own setting (agy models lists ids). | | *.inactivityTimeoutMs | How long a reviewer may stay silent. Codex liveness is also proven via its rollout file; agy streams an event per model turn and tool call. agy's --print-timeout is set from gemini.maxTimeoutMs. |

npx -y @simonren/quorum doctor prints the detected CLIs, their versions, and the effective settings.

Upgrading from 0.9.x: your existing config file is kept as is and new keys get defaults. A config written by 0.9.x already contains "model": "opus", so the Fable default only applies to fresh installs — set claude.model to fable yourself to switch. doctor warns when the fallback equals the model.

Focus Areas

| Area | Description | |------|-------------| | security | Vulnerabilities, auth, input validation | | performance | Speed, memory, efficiency | | architecture | Design patterns, structure, coupling | | correctness | Logic errors, edge cases, bugs | | maintainability | Code clarity, documentation, complexity | | scalability | Load handling, bottlenecks | | testing | Test coverage, test quality | | documentation | Comments, docs, API docs |

MCP Tools

| Tool | Description | |------|-------------| | multi_review | Standard + adversarial review from every available CLI. Requires ccOutput (Claude Code's brief) and outputType (implementation, plan, findings, analysis, proposal). Returns one <review model=… pass=…> block per model and pass. | | multi_consult | Ask every available CLI the same question. Requires question; optional relevantFiles. Returns one <answer model=…> block per model with a 5-section structured response. |

Both tools are read-only and take minutes; failures in one model never hide the others' results.

Development

cd mcp-server
npm install
npm run build       # Build once
npm run dev         # Watch mode
npm test            # Run tests (no network, no CLIs needed)
npm run test:watch  # Watch mode tests
npm start           # Run server
node dist/index.js doctor

Publishing

Local, Makefile-driven, with npm's web 2FA (run from the repo root):

# 1. Bump "version" in mcp-server/package.json and .claude-plugin/plugin.json
make check                                   # build + tests
git add -A && git commit -m "vX.Y.Z — <summary>"
make release                                 # npm publish (browser 2FA) → verify → tag + push tag
git push

License

MIT