Quorum with Claude Code.

Claude Code is very good and it is one model. This gives it somewhere to go when one model is not enough — a panel that includes engines from other labs, reachable as a tool, without leaving the terminal.

Wiring it up

Quorum is a hosted MCP server. There is no package to install and nothing runs on your machine.

.mcp.json (project root, shared with the repo) · or claude mcp add for a personal one

{
  "mcpServers": {
    "quorum": {
      "type": "http",
      "url": "https://www.quorum.dog/mcp",
      "headers": { "Authorization": "Bearer qk_..." }
    }
  }
}

Claude Code was the one client here whose config file was never named. A project-scoped server lives in .mcp.json at the root of the repository you open — the same file your team commits, which is why the key belongs in an environment variable rather than inline: "Bearer ${QUORUM_API_KEY}" is interpolated from your own environment and keeps the credential out of the diff.

Get a key from your organisation dashboard.

What you get

Tool	What it does	Cost
`estimate`	Classify and price a question without running it — and say whether a panel is likely to help	free
`list_modes`	Which panels your key may call, and what they cost	free
`deliberate`	Convene the panel	real money
`get_receipt`	Per-seat models, judge scores, cost and latency for a past call	free
`run_test`	Your own question buckets, judges and repeats against a Mode	25% off deliberate, per question
`certify_mode`	A fixed 150-question certification run against a Mode	$50 flat

All six are on the hosted server. The two testing tools spend real money on purpose — run_test bills per question at 25% off normal deliberate pricing and takes dry_run: true to price a run without spending anything; certify_mode commits $50 flat for 150 questions and runs for roughly two and a half hours, because the shared execution engine paces at about one question a minute. Do not call either speculatively.

estimate is worth more than its price row suggests. Alongside difficulty_score and task_type it returns deliberation_value — whether a panel is expected to help here, not just what it would cost. likely_helps on multi-step reasoning, likely_hurts when the answer is a passage to be reproduced rather than reasoned to (a synthesis pass rewrites by design, which corrupts it), unknown when there is no strong signal either way. It carries basis: "hypothesis" and its evidence line — LiveBench 2026-08-22, n=36, plus tier — so you can tell advice from measurement. The escalation router shows it in a branch.

The point, stated plainly

The value is not “more Claude.” Asking Claude to check its own work gets you the same priors twice. The value is disagreement from models that were trained differently — a panel drawing on Anthropic, Google, OpenAI and others, arguing, and handing back one answer plus the places they split.

So the useful mental model is not “a better assistant.” It is a second opinion you can call, from someone who is not you.

Where it earns the wait

Before a decision you cannot cheaply reverse

Schema changes, auth models, a public API shape, anything with a migration behind it. Exactly the calls where a confidently-wrong single answer is expensive, and where models genuinely disagree.

When Claude Code has already answered and you are not sure

The highest-value pattern and the least obvious one. Hand the answer itself to the panel and ask them to attack it. You are not asking for a rewrite; you are asking whether three differently-trained models find the same weak spot.

When you want the disagreement, not the answer

Every deliberation records where the seats split, and get_receipt gives it back. Sometimes the useful output is knowing that two of three models flagged the risk you were about to dismiss.

Where it does not

Anything mechanical. Renames, formatting, writing a test for existing code. Claude Code is already better at this, because a panel adds a minute and three opinions to a task with one right answer.
Inside a tight loop. If you are iterating every few seconds, a 28-second call breaks your rhythm more than a wrong answer would have cost.
When you already know the answer. Using a panel as reassurance is expensive; the receipt will show the seats converging immediately, which is the tell.
When the context that matters is thirty files. Claude Code has your codebase; Quorum has your paragraph. A summarised question gets a summarised answer, and no amount of panel quality closes that gap. Give it the specific decision and the constraints, not the situation.

The paper

This page gets Quorum wired into Claude Code. AI Deliberation & Claude Code is the other half: when convening a panel here is worth the wait, the jobs it pays off on, and the ones it does not, with the exhibits behind each. 13 pages, PDF.

Every paper in the series sits on the whitepaper shelf.

Check it works

Ask your assistant to call list_modes. It is free, it requires a valid key, and it returns the panels you are actually entitled to — so one real answer proves the URL, the key and the wiring together.

curl -sS -X POST https://www.quorum.dog/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer qk_..." \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

A GET to that URL returns 405. That is correct, not a fault — the server is stateless, so there is nothing for a GET to stream.

Before you put it in a loop

Measured on production, 2026-08-20:

Call	Time	Sample
`estimate`	~0.9 s	10 prompts
`deliberate p50`	28.5 s	3,845 deliberations
`deliberate p90`	88.2 s	—

Asking what a question is costs effectively nothing. Convening the panel does not. The escalation router covers how to decide between them — and the decision is yours to make, not a threshold we set.

Other editors

VS Code Cursor

Claude Code and Cursor nest servers under mcpServers. VS Code uses servers. Same protocol, same URL, different wrapper key — and the wrong one fails silently rather than telling you why.