paid mcp · bring your own keys
Multi-LLM Sorcery.
Build, design, research.
Faster — for less.
Ask once. Get the answer frontier models reach independently — with the places they disagree called out instead of averaged away. That’s confer, and it’s the one people reach for most.
When a task needs more than an answer, crosscheck picks the panel and the protocol — confer, verify, debate, audit — then makes them check the answer. No “this-for-that” rules, no knocking the model down for simple work. It figures it out for you.
A router chooses an endpoint. crosscheck assembles a panel and chooses how it should check the answer. Your machine, your keys, content-free telemetry.
recommended: Claude Code in VS Code · $20/seat/month through Aug 2026, then tiered pricing
✓ Activated
✓ Provider keys saved locally
✓ Registered with Claude Code
“use crosscheck to confer on this design”
how selection works
You stop deciding which model deserves the job.
Most people carry a private ruleset — the big model for hard things, the cheap one for simple things, and a guess in between. The guess is where the money goes. crosscheck makes that call per task, every task.
01
You describe the task
Normal instruction, in the tool you already code in. No model names, no flags, no picking a tier.
02
crosscheck picks the panel and the protocol
Which models are fit for this task, how many, and what they should do. Most of the time that's confer — independent answers with the disagreement surfaced. When the work needs more, it escalates to debate, audit, or verification on its own. The choice and its reasoning are visible, not hidden behind a score.
03
You get a result you can weigh
Not five transcripts to reconcile yourself. Independent answers come back with the agreement and the disagreement made explicit — and on the protocols that call for it, the models examine each other's work before you see any of it.
use cases
Specific jobs, not a capability list.
confer
Get a second, third and fourth opinion at once
The decision you'd normally make on one model's say-so. Where independently-trained models converge is real signal; where they split is exactly the part worth your attention.
confer
Design a document-processing pipeline
Two consultations across five frontier models while scoping the work. 21,542 tokens, $0.40 in panel spend, on the developer's own keys. The kind of decision normally made alone, on one model's word.
confer
Pressure-test something before you commit to it
A design, an estimate, a diagnosis. One model tells you what it thinks. A panel tells you whether that view is widely held or an outlier — which is the thing you actually needed to know.
audit
Review a risky change before it merges
One model misses the failure mode its own training bias creates. A panel catches what any single reviewer structurally cannot see in itself.
verify
Check whether an API actually exists
A model invents a plausible method with total confidence. Two others flag it in seconds — before you build on it.
debate
Settle an architecture decision
Get an argued case with the tradeoffs surfaced and a written rationale, instead of the first approach one model happened to reach for.
triangulate
Root-cause a bug that shouldn't happen
Independent hypotheses from independent models, ranked by where they agree. Convergence is the signal.
verify
Check a migration before you run it
The case where being wrong once costs more than a year of seats.
plan
Break down work you haven't scoped yet
Cross-checked steps and the dependencies a single pass reliably forgets — which is what stops the rework before it starts.
what work actually costs
Don’t look for a cheaper model — make fewer round trips.
A panel uses more tokens per call than one model. That part is true, and it isn’t the interesting number.
The expensive part of building something with an LLM was never the call. It was the eleven rounds of re-prompting, the wrong turn taken at step three, and the context resent every single turn. crosscheck front-loads the plan so the work arrives in a handful of passes instead of discovering the requirement by trial and error.
Measured per call, a panel costs more. Measured per finished feature, that ordering reverses.
// measured, not estimated
- One consultation4–5 models, ~16k tokens
- $0.21$0.15–$0.27
- Scoping a pipeline feature2 consultations, 5 models, 21,542 tokens
- $0.40
Panel spend only. These are what the models cost, on your own keys. They do not include your coding agent’s own tokens, which are the larger share — we started measuring that separately and won’t quote a cost-to-done figure until we can stand behind it.
8 real runs, 26–30 Aug 2026, one seat. Fable 5, GPT‑5.6, Gemini 3.1 Pro, Kimi K3, Grok 4. List rates at time of call. Audit your own with crosscheck explain.
already built something like this?
Three questions worth asking your internal tool.
Plenty of teams have wired several models together, and some of those systems are good. These are the questions that tell you whether yours already does this — no sales call required.
- 01Does it choose the protocol per task, or only the model?
- 02Does it run debate, verification, and audit as distinct executable protocols — or is it a fan-out that returns several answers?
- 03Can an evaluator inspect what was selected, why, and every call that ran?
| a router / a fan-out script | crosscheck |
|---|---|
| Picks a model per request | Picks the models AND the protocol per task |
| Returns one answer | Makes the models check the answer, and shows the disagreement |
| Fan-out gives you N transcripts | One result, with dissent surfaced |
| Proxies your tokens through a vendor | Your keys, your bill, no middle hop |
| A dashboard to context-switch into | Runs inside the tool you already code in |
If your internal tool genuinely does all of this — keep it. If it’s a fan-out script, trying the alternative takes one command.
five patterns
Stop reinventing the prompt. Pick the pattern.
confer
The workhorse. Same question to every model on the panel, independently — so agreement means something and disagreement is visible rather than averaged away.
debate
Bounded multi-round back-and-forth. The moderator synthesizes. Early-stop when convergence hits.
audit
One model proposes, others review. Catches errors the proposer can't see in its own output.
plan
Collaborative planning across models. Each contributes; the synthesis is structured for execution.
panel-pick
Smart router picks the right panel by purpose + historical reliability. Lower cost, equivalent answers.
the flagship panel
One top model per provider, or whichever ones you pick.
Ask for super and the panel becomes the current flagship from each provider instead of each one’s everyday default. These are the defaults — not a ceiling.
Anthropic
Fable 5.1
falls back to claude-fable-5 if your account lacks access
OpenAI
GPT-6 Astra
when released — falls back to gpt-5.6 until then
Google Gemini
Gemini 3.8 Flash
falls back to gemini-3.1-pro-preview if your account lacks access
xAI (Grok)
Grok 4
provider default
Don’t like the lineup? Change it in the browser.
Pick a model per provider from a dropdown, separately for confer and confer super, on every machine on your account. Add fallbacks if you want a pinned model to degrade rather than fail. Leave anything alone and you get the engine default, which the page names so you know what that is.
// or from the terminal
crosscheck models set anthropic claude-fable-5-1 crosscheck models fallback anthropic claude-fable-5 crosscheck models sync
Either side pushes to the other, so the browser and the terminal always agree.
nine providers, one panel
Every model you'd want, bring your own key.
Anthropic, OpenAI, Gemini, and Grok are tested end to end. Kimi K3 and Qwen just shipped. DeepSeek, Groq, and Mistral are experimental — provided as-is.
- Anthropicclaude-opus-5
- OpenAIgpt-5.6
- Google Geminigemini-3.1-pro-preview
- xAI (Grok)grok-4-latest
- Kimi K3 (Moonshot)kimi-k3New
- Qwen (Alibaba)qwen3.8-maxNew
- Mistralmistral-large-latestExperimental
- Groqllama-3.3-70b-versatileExperimental
- DeepSeekdeepseek-chatExperimental
Live usage
trust posture
Three invariants we won't break.
01
Server never sees prompts
Telemetry schema rejects prompt-shaped keys at the boundary. CI enforces it in every PR.
02
Server never sees keys
Upstream LLM API keys live locally on your machine. There's no server route that accepts them.
03
Activation is privacy-preserving
Per-machine fingerprint is a one-way scrypt hash. Not a serial, not a MAC, not reversible.
current version
The CLI and engine ship together — npx -y crosscheck-cli@latest always installs the latest of both.
crosscheck-cli
v0.0.56 · 2026-09-04
crosscheck-mcp (engine)
v0.2.17 · 2026-09-04
pricing
Per-seat. Your LLM bill stays yours.
You pay us for the orchestration, dashboard, and activation. You pay Anthropic, OpenAI, Gemini, xAI, and the rest directly for your model usage — through your own accounts, with keys we never see.
- · cancel anytime in the stripe billing portal
- · per-seat, single-machine activation, self-serve re-activation
- · student licenses & volume discounts available
$20/seat/month, through Aug 2026
New tiered pricing — $99 single seat, $199 small orgs, $499 enterprise — takes effect September 1, 2026. Existing customers keep their current rate.
secure checkout via stripe · cancel anytime
faq
Questions worth answering.
We already built something like this internally. How is this different?
Ask your tool three questions. Does it choose the protocol per task, or only the model? Does it run debate, verification, and audit as distinct executable protocols, or is it a fan-out that hands you several answers to reconcile? Can an evaluator inspect what was selected, why, and every call that ran? Plenty of internal systems do the first part well. If yours does all three, keep it — genuinely. If it's a fan-out script, trying the alternative costs one command.
Doesn't a panel use more tokens than a single model?
Per call, yes — more. That's arithmetic, and we're not going to pretend otherwise. Per finished piece of work it usually goes the other way, because the expensive part was never the call. It was the repeated re-prompting, the wrong turn taken early, and the context resent every turn. crosscheck front-loads the plan so the work lands in a handful of passes. We're measuring this per feature now rather than asserting it — and the numbers come from your own runs on your own keys, auditable on your machine with `crosscheck explain`.
Do you see my prompts or model responses?
No. crosscheck's telemetry contains only token counts, cost estimates, latency, and the pattern name. The Zod schema at the ingest boundary rejects any prompt-shaped key (prompt, messages, content, input, text, completion, response, output). CI enforces it on every PR.
Do you store my LLM API keys?
No. By default your upstream keys are saved in an encrypted file on your machine (0600, AES-256-GCM) — no system password required — and you can opt into your OS keychain instead. There is no server route that accepts them. The crosscheck CLI loads them from that local store into the engine subprocess's environment — the only place they exist outside it.
What does my subscription cover?
The orchestration engine, the dashboard, the better-use analyzer, single-machine activation, and the server-side infrastructure that issues activation JWTs and accepts content-free telemetry. It does not cover your spend with Anthropic, OpenAI, Google, or xAI — those are your own provider accounts. See /pricing for current rates and what each plan adds.
Which providers are tested?
Anthropic, OpenAI, Google (Gemini), and xAI (Grok) are tested integrations. Kimi K3 (Moonshot) and Qwen (Alibaba) are newly supported. DeepSeek, Groq, and Mistral are experimental and provided as-is — we don't ship breaking changes around them but coverage is lighter.
Can I cancel anytime?
Yes. Self-serve cancellation from the Stripe billing portal. Takes effect at the end of your current billing period; no pro-rata refunds outside what applicable law requires.
Try it on us for thirty days.
Apply WELCOME100 at checkout. Cancel before the first renewal and you owe us nothing.