Independent
Neither model sees the other's answer before writing its own. Contaminate that and you get agreement instead of review.
Send a question to two frontier models independently, then make each review the other's answer — and its own. You get the disagreements, the retractions, and a durable record of the exchange.
“Pick a known counterexample — the exact 3×3 matrix that disproved the Bessis–Moussa–Villani conjecture in 2013.”
fluent · specific · dated · wrong
BMV was proved true by Herbert Stahl. There is no counterexample to rediscover.
Caught on the next call. Cost of catching it: one extra round. Cost of missing it: a search hunting something that cannot exist.
A single model returns a fluent, plausible, well-formatted answer whether or not it is correct. Nothing in the output distinguishes the two cases. You find out downstream, after you have built on it.
Neither model sees the other's answer before writing its own. Contaminate that and you get agreement instead of review.
Each model is then shown both answers, labelled, and asked where it was wrong. Self-correction is the highest-signal section it produces.
Where they agree, you can move. Where they split, you know exactly which claim to check before building on it.
Pick by how expensive it would be to be wrong.
| Mode | Calls | Typical | Use when |
|---|---|---|---|
fanout | 2 | 1–4 min | Two independent answers, and you will read both. |
synthesis | 3 | 2–6 min | One answer, with conflicts ruled on and flagged. |
debate | 4 | 4–10 min | The answer matters. Each model audits the other — and itself. |
debate returnsAsking two models what they both failed to raise reliably surfaces the point neither volunteered. In our own use it produced the design insight this project now runs on.
A verbal “we checked it with AI” is not evidence. Every consultation is written down: the exact prompt, both independent answers, every critique, model identifiers, token counts, and timestamps to the millisecond — durable across restarts and redeploys.
Which model, which version, what it actually said — not a summary of what someone remembers it saying.
Submitted, started, finished, duration. The record shows when the review happened relative to the decision.
Retrievable by ID for as long as you retain it. The dissent is preserved, not just the conclusion.
That record is the product as much as the answer is. It turns “we considered the alternatives” into something a reviewer, an auditor, or your future self can actually inspect.
Submit, poll or subscribe, read. Consultations are asynchronous because a high-effort review takes minutes, not milliseconds.
# submit — returns immediately with a job id
curl -X POST https://council.smartledger.app/v1/consult \
-H "Authorization: Bearer $COUNCIL_TOKEN" \
-H 'content-type: application/json' \
-d '{"mode":"debate","prompt":"Shard by tenant or by region?"}'
# {"job_id":"04961d7b-…","state":"queued","poll":"/v1/jobs/04961d7b-…"}
curl https://council.smartledger.app/v1/jobs/04961d7b-… \
-H "Authorization: Bearer $COUNCIL_TOKEN"import os, time, requests
BASE = "https://council.smartledger.app"
AUTH = {"authorization": f"Bearer {os.environ['COUNCIL_TOKEN']}"}
job = requests.post(f"{BASE}/v1/consult", headers=AUTH, json={
"mode": "debate",
"prompt": "Shard by tenant or by region?",
"system": "You are a blunt distributed-systems consultant.",
}).json()
while True:
time.sleep(10)
s = requests.get(f"{BASE}/v1/jobs/{job['job_id']}", headers=AUTH).json()
if s["state"] in ("done", "error", "interrupted"): break
# round2 first: each model's corrections to its own answer
for a in s["result"]["round2"]:
print(a["vendor"], a.get("text") or a["error"])// no polling: subscribe and have the result pushed to you
const ws = new WebSocket(
`wss://council.smartledger.app/v1/jobs/${id}/stream?token=${TOKEN}`
);
ws.onmessage = (e) => {
const { event, job, result, error } = JSON.parse(e.data);
if (event === 'done') console.log(result.answers);
if (event === 'error') console.error(error);
};
// Subscribing after the job finished still returns a full snapshot,
// so a late client is never stranded.If reasoning consumes the whole token budget and the model emits no text, the call fails loudly with the reason — instead of handing you an empty answer that looks like a result.
A failing provider gets an error field; the other model's answer
still comes back.
Providers disagree on whether reasoning belongs in the output count. We normalise it, so cost is actually addable.
Full reference — every endpoint, job states, WebSocket events, token budgeting and the operations runbook: API guidance →
Currently in private deployment. Indicative while we onboard early teams.
fanout modeProvider inference is billed through at cost — a debate
makes four upstream calls, and reasoning tokens usually dominate. Bring your own keys on
Team and above and you pay your providers directly.