Deliberation, as a call you can make from anywhere. Whatever you point at this endpoint gets several models arguing before it answers — in the editor you already work in, or inside the product you are building for someone else.
Quorum sends one prompt to several models at once, has them deliberate, and returns a single answer with a synthesis pass over their work. The transport is OpenAI-compatible: point base_url at https://www.quorum.dog/v1, set model, and your existing SDK code runs unchanged.
It is also slower than the single model you would otherwise call: 28.5s median, 88.2s at p90 (measured over 3,845 real deliberations, 2026-08-20). That is the trade the product is built on — seconds spent to lower the odds of being confidently wrong. It is a bad trade on most questions. The rest of this page is mostly about deciding, per request, which ones it is a good trade on.
Both run the same deliberation. They differ in who the better answer is for, what you install, and whose provider account the seat calls land on.
You are the one who benefits. The decision you were about to make alone — a schema, a migration strategy, a library choice — gets three frontier models disagreeing about it first.
deliberate, estimate, list_modes, get_receipt, certify_mode, run_test.Your users benefit, and they never hear the word Quorum. Your product’s AI feature answers from a panel instead of a single model, and you did not build the orchestration, the judging, or the receipts.
base_url and model. Existing OpenAI SDK code runs unchanged./v1/estimate first and route only the questions worth the wait to a panel./v1/receipts to show your own users what convened on their question.Short answer on BYOK: it belongs to the second path. One developer using Quorum inside an editor has nothing to gain from routing seat traffic through their own provider accounts. A product shipping deliberation to its own users usually does. What BYOK does and does not move →
Two lines change. Send Idempotency-Key on every request — a deliberation costs real money and a retried POST should not run the panel twice.
curl https://www.quorum.dog/v1/chat/completions \
-H "Authorization: Bearer $QUORUM_API_KEY" \
-H "Idempotency-Key: 8f2c1a90-..." \
-H "Content-Type: application/json" \
-d '{
"model": "quorum-standard",
"messages": [{"role":"user","content":"Which of these two contracts carries the renewal risk?"}]
}'
Server-to-server only. A request arriving with a browser Origin header is rejected with browser_origin_not_allowed. That is why there is no in-browser playground on this page and will not be one: a playground would need a key in a browser.
Every response carries an additive quorum object alongside the OpenAI-shaped fields. It reports what actually happened rather than what was requested: how many rounds ran, whether the panel converged or hit its cap, and which model families saw the prompt.
"quorum": {
"request_id": "req_8f2c1a90...",
"rounds": 2, // rounds actually run, not the cap
"seats": 3,
"converged": true, // false + capped:true means it ran out of rounds
"capped": false,
"surcharge_usd": 0.0180,
"billed_usd": 0.0417,
"latency_ms": 27412,
"engines": ["anthropic", "google", "openai"]
}
Field values above are illustrative and taken from a real call shape. They are a schema reference, not a price: what a call costs you depends on the mode, the difficulty tier and the length of your prompt, and the only authoritative figure is the one on your own receipt.
converged: false with capped: true is the case worth handling: the panel was still disagreeing when it ran out of rounds. It is not an error, and the answer is still returned — but it is the signal that this question was genuinely contested, which is often more useful to log than the answer itself.
The expensive question isn’t what deliberation costs. It’s which of these questions deserved it.
POST /v1/estimate answers the second one for free, before you spend anything on the first. It classifies a prompt with the same classifier the billed call uses and returns the price the billed call would charge — without running the panel and without touching your balance.
Most integrations put it immediately in front of a deliberation, where it works as a confirmation dialog: it fires only on turns you already decided to escalate, saves a little money, and changes nothing structurally. It is worth more at the top of your own router, where it fires on every turn and the escalation threshold is a number you own and move as your own evidence accumulates. We do not set it. You do.
light or deep. The coarse gate — light means do not escalate.difficulty_score is the one that matters. It is the field that makes this a control surface you own rather than a vendor feature you accept.
429 with Retry-After on breach. An agent calling it on every turn needs its RPM sized for total turns, not for escalations. This is the single most likely cause of a bad first week in production.The model string does not name an engine. It names a mode — a configuration of which engines sit in which seats, whether critique runs on every question or only hard ones, how many rounds, and which model judges and synthesises. Which engines that resolves to is ours to keep current; how deeply it deliberates is yours to choose.
Entitlements are per-organisation, so this table is a hint and GET /v1/models is the answer. It returns what this key can call, with real pricing including any difficulty-tiered surcharge. Building your own mode and exposing it here: authoring a mode. How a mode’s performance is actually measured: Testing.
dry_run supported.GET /v1/receipts/:request_id returns the structured accounting for a past call: per-seat model and judge score, the difficulty and task-type signal that drove pricing, cost, latency, and mode_config_hash.
Aggregate metadata is the default. Full seat text requires ?include_transcript=true — a deliberate opt-in, because the transcript contains three models’ unsynthesised drafts and most systems should not be storing those by accident.
mode_config_hash is the field worth building on. It hashes the mode’s real configuration at the moment of the call, so you can prove the panel behind two answers was the same one — or detect that it wasn’t. Hosted models change under you without notice. This is how you find out.
The same rig Quorum’s own Optimization Lab runs on, exposed as two endpoints. Both are blind and comparative: answers are anonymised and order-randomised before a judge panel sees them. What that rig currently says about Quorum’s own default mode, including where it loses, is on Testing.
A fixed run, so results are comparable across modes: 150 questions, 3 judges, 2 repeats, $50 flat.
The verdict is a three-state ladder driven by the lower bound of a clustered 95% CI, not the point estimate — a mode that wins 58% of the time on a wide interval does not certify. That is deliberately conservative, and it is the reason a certification means anything.
The configurable form: your own question buckets, judges and repeats. Bills at 25% off the mode’s normal price. Caps at 300 questions and 3 judge repeats.
dry_run: true prices a run without spending anything.
Both return a batch_id immediately and are polled. The shared execution engine runs about one question per minute, so a full 150-question certification takes roughly two and a half hours. Size your timeouts for that, not for an HTTP request.
The same capabilities are exposed as MCP tools, so an agent — or a person inside a tool that speaks MCP — can reach Quorum without an HTTP client.
{
"mcpServers": {
"quorum": {
"type": "http",
"url": "https://www.quorum.dog/mcp",
"headers": { "Authorization": "Bearer qk_..." }
}
}
}
Scope, stated plainly: the hosted server is live at https://www.quorum.dog/mcp and speaks stateless Streamable HTTP, so any client that supports remote MCP can point at it with your API key as the bearer token. It is not yet listed in any connector directory, and it has had no external callers — you would be the first. All six tools above are hosted; run_test and certify_mode joined the other four on 2026-08-22. Both spend real money — run_test bills per question at 25% off deliberate pricing and takes dry_run: true to price a run for nothing, and certify_mode commits $50 flat for 150 questions. A GET to that URL returns 405, which is correct rather than a fault.
Every error carries a typed error.type, a stable error.code, and quorum.request_id — including errors thrown before a request had a body worth billing. An agent that reads code recovers; one that retries on any non-200 burns budget on a model_not_found.
Origin header.Retry-After is set. Also applies to estimate.One shape that surprises people: cost scales faster than input length, because the prompt fans out to every seat before anything comes back. A long document is not one long call, it is three or more.
Deliberation means more than one company’s model sees the prompt. There is no version of this product where that is not true, so the answer is disclosure rather than reassurance: quorum.engines on every response names the model families that saw that call. Not a policy page, not a quarterly report — the response body, every time, without asking.
Two boundaries worth stating, because together they look like an inconsistency and are not. Provider brands are public. A mode’s gallery card names the providers it draws on — Anthropic, Google, OpenAI — because you should be able to read the ingredients before you buy. Specific model identifiers are not. They appear in quorum.engines, in a per-call record delivered to the caller who paid for that call, and nowhere on a public or shareable surface.
The third rule follows from both: the answer is Quorum’s. It is not decomposed into which engine wrote which paragraph, and no seat is labelled with a vendor’s name on anything you can print, export or share — a seat is a shape and a colour. That is a trademark position, not a modesty one.
Organisational data-handling, billing and compliance questions: /enterprise.
Live and self-serve today for OpenAI, Google, Groq and Bedrock, owner-only, configured from your organisation dashboard. Seat traffic then runs through your own provider accounts and your own provider billing.
Bedrock connects by cross-account IAM role ARN with an STS assume-role per request — Quorum never stores a long-lived AWS secret. Anthropic-direct is deliberately not offered; Claude runs via Bedrock.
The residual, stated rather than buried: orchestration always runs on Quorum’s keys. The judge and synthesis passes see the seats’ output. BYOK moves the seat calls, not the whole pipeline.
Create an organisation, add a prepaid balance, issue a key. No sales contact, no call, under a minute. The key is shown once.
Every new org gets a $10 credit to try the platform and see if it could help their organisation deliberate better, so your first calls run before you add a balance. Anything unused after 30 days is deducted.