Quorum is a hosted MCP server. Any client that speaks remote MCP can call it with your API key as a bearer token — no package to install, nothing running on your machine.
https://www.quorum.dog/mcp| 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.
Claude Code and Cursor both nest servers under mcpServers. VS Code uses servers. Same protocol, same URL, different wrapper key — and a config with the wrong one fails silently rather than telling you why.
Each block below is written for its own client. They are not interchangeable.
.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_..." }
}
}
}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 is better written as "Bearer ${QUORUM_API_KEY}" and interpolated from your own environment than pasted in.
There is a fuller guide for the agent-loop patterns this enables: Quorum with Claude Code.
.vscode/mcp.json (workspace) · or your user profile
{
"inputs": [
{
"type": "promptString",
"id": "quorum-key",
"description": "Quorum API key",
"password": true
}
],
"servers": {
"quorum": {
"type": "http",
"url": "https://www.quorum.dog/mcp",
"headers": { "Authorization": "Bearer ${input:quorum-key}" }
}
}
}${input:...} makes VS Code prompt for the key on first use rather than storing it in a file you might commit — password: true masks it as you type. You can hardcode the token instead, but a checked-in API key is a bad afternoon.
The inputs array is the half that is easy to leave out. ${input:quorum-key} is a reference; with no matching id declared alongside servers there is nothing to resolve it against, and the placeholder is what gets sent as your bearer token. The server then answers 401 invalid_api_key, which reads as a bad key rather than an absent one and sends you hunting for a credential that was never wrong.
.cursor/mcp.json (project) · ~/.cursor/mcp.json (global)
{
"mcpServers": {
"quorum": {
"type": "http",
"url": "https://www.quorum.dog/mcp",
"headers": { "Authorization": "Bearer ${env:QUORUM_API_KEY}" }
}
}
}Cursor interpolates ${env:...} in both url and headers, so the key can live in your environment rather than in a file you commit.
Cursor infers a remote server from url alone, so this block used to omit "type": "http" while the two above it carried it. Three configs for one server that differ in ways nothing on the page explains is how a reader concludes the difference is meaningful. All three now state the transport.
Cursor has a reported issue where a server that advertises OAuth discovery endpoints causes it to ignore the headers block entirely and attempt OAuth instead. Quorum deliberately does not advertise those endpoints, so bearer auth works — but if a future version starts and your Cursor connection breaks while Claude Code and VS Code keep working, this is the first thing to check.
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 a real answer proves the URL, the key and the wiring all at once.
If you would rather test outside the editor first:
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.
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.
This page gets Quorum wired into whatever editor you already run. AI Deliberation & Your Editor is the other half: when convening a panel from inside an agent loop is worth the wait, the jobs it pays off on, and the ones it does not, with the exhibits behind each. 14 pages, PDF.
Every paper in the series sits on the whitepaper shelf — one per surface.