The escalation router.

The problem with putting a panel in a hot path

A Quorum deliberation runs several frontier models, has them critique each other, judges the result and writes a synthesis. That is not free and it is not fast.

If your agent calls that on every turn, one in ten users waits a minute and a half, and you pay panel prices to have three models agree that Paris is the capital of France.

The fix is not a faster panel. It is not convening one unless the question earns it.

The move

POST /v1/estimate classifies a prompt and prices it without running it. It is always free — the response carries billed_usd: 0 on every call, by design, not as a trial allowance.

curl https://www.quorum.dog/v1/estimate \
  -H "Authorization: Bearer $QUORUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "quorum-standard",
    "messages": [{"role":"user","content":"Should we migrate off the monolith this quarter?"}]
  }'

{
  "request_id": "0f5c…",
  "model": "quorum-standard",
  "mode_key": "standard",
  "depth": "deep",
  "difficulty_score": 0.78,
  "task_type": "strategy",
  "estimated_price_usd": 0.15,
  "billed_usd": 0,
  "deliberation_value": {
    "verdict": "likely_helps",
    "reason": "multi_step_conclusion",
    "basis": "hypothesis",
    "evidence": "LiveBench 2026-08-22, n=36, plus tier"
  }
}

Five fields do the routing work:

• deliberation_value — whether a panel is expected to help, rather than what it would cost. The strongest single signal here, and the one to branch on first.
• difficulty_score — 0 to 1. The main dial.
• depth — light, medium or deep.
• task_type — what kind of question it is, which is how you exempt whole categories.
• estimated_price_usd — what the real call would cost, so you can put a budget in front of it.

The field that answers the actual question

difficulty_score tells you how hard something is. That is not quite the question a router is asking, which is would arguing about it produce a better answer. deliberation_value is the field for that one, and it comes back on every estimate call at no cost.

It carries basis: "hypothesis" and an evidence line rather than presenting itself as measurement, and that distinction is deliberate. The evidence is a LiveBench run of n=36 on 2026-08-22, one tier, one run: the panel beat every one of its own engines on the four tasks whose answer is a conclusion, and lost to a single Gemini seat by 23 points on the one task whose answer is a corrected passage. The per-task pattern is strong and the mechanism is understood; the magnitude is not established. Do not build a billing decision on it thinking it was measured — the field says so itself so that you do not have to take our word for it.

How much traffic this actually diverts

Across 3,947 classified questions on Quorum’s own traffic:

Mean difficulty across that set was 0.456.

That is our traffic, not a recommendation. It is here so you have something to compare against — if your own distribution looks nothing like it, that is information about your product, not a sign you are holding it wrong. The classification call that measures it costs nothing, so measure rather than assume.

Whose decision this is

Worth being exact, because it determines what you actually have to build.

On the API, every deliberation runs at full depth. The request pins the deliberation tier internally; there is no per-call dial that makes Quorum “deliberate less” on an easy question. Your two levers are which mode you call — a mode’s configuration decides how its panel behaves — and quorum.max_cost_usd. Be precise about what that second one does: it is a ceiling on what you are billed, applied after the fact. The deliberation still runs, you still get the answer, and the response comes back with finish_reason: "cost_cap" — Quorum absorbs the difference. It protects your budget; it does not prevent the work or save you the wait.

So the escalation decision is not a setting inside Quorum you tune. It is a branch in your code: for this turn, do I call a single model, or do I call a panel? Quorum’s job is to hand you the facts that branch needs, priced at nothing. The threshold is yours, it belongs in your codebase, and you should expect to move it as you learn.

The router

Classify, branch on your own rule, keep a budget ceiling. The thresholds below are placeholders — they are the shape of the decision, not values we are recommending.

const QUORUM = 'https://www.quorum.dog/v1';

async function estimate(messages, model = 'quorum-standard') {
  const r = await fetch(`${QUORUM}/estimate`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.QUORUM_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ model, messages }),
  });
  if (!r.ok) return null;          // fail OPEN -- see below
  return r.json();
}

async function route(messages, { maxUsd = 0.25 } = {}) {
  const est = await estimate(messages);

  // Classification unavailable: do not block the user on our router.
  if (!est) return singleModel(messages);

  const tooExpensive = est.estimated_price_usd != null
                    && est.estimated_price_usd > maxUsd;

  // Questions that cannot really be disagreed about.
  const mechanical = ['lookup', 'formatting', 'extraction'].includes(est.task_type);

  // The strongest single signal, and free: estimate's own read on whether a
  // panel is expected to HELP here, not just what it would cost.
  if (est.deliberation_value?.verdict === 'likely_hurts') {
    return singleModel(messages);
  }

  if (est.difficulty_score < 0.35 || mechanical || tooExpensive) {
    return singleModel(messages);
  }

  return deliberate(messages);     // POST /v1/chat/completions
}

Fail open, not closed

If the classification call fails, answer the question with your single model rather than erroring or defaulting to the expensive path. A router that breaks your product when our endpoint has a bad minute is a worse router than no router.

Why deliberation_value is checked first

The two gates below it are about cost: is this hard enough, is this cheap enough. likely_hurts is about outcome — it says a panel would make the answer worse, and a question can be difficult, expensive and still fall into that category. Checking it last would mean paying for a deliberation the free call had already warned you against.

Where this does not pay

Stated plainly, because a guide that only argues one way is marketing.

• You are already latency-bound at every turn. Classification is a round trip. It is far cheaper than a deliberation, but it is not zero, and on a stream-every-token chat UI it is a real addition.
• Your traffic is uniformly hard. If nearly everything you send scores above the threshold, the router adds a hop and diverts nothing. Measure first — it costs nothing to find out.
• Your traffic is uniformly easy. Then you do not need a panel at all, and we would rather you knew that than paid for one.
• The classifier is not infallible. It is a model reading a prompt. It will occasionally call something light that deserved a panel. Where being wrong is genuinely expensive, escalate on task_type or on your own signal rather than on the score alone.

Tuning it

Pick a starting threshold from your own measured distribution rather than from ours, then move it with evidence:

• Every deliberation returns a request_id. GET /v1/receipts/{'{'}request_id{'}'} tells you which engines ran, how much they disagreed, and what it cost.
• If receipts on your escalated traffic keep showing the panel converging immediately with no dissent, raise the threshold — you are paying for agreement.
• If your users keep pushing back on answers that were routed to a single model, lower it.

That loop is the actual product: not "always use a panel", but "know which questions deserve one".

The paper

This page is the branch. AI Deliberation & the Router is the argument behind it: what the classification actually measures, where a threshold belongs for different shapes of traffic, and the worked cases where sending a question to a panel was the wrong call. 13 pages, PDF.

Every paper in the series sits on the whitepaper shelf — one per surface.