AI Second Opinion

Every AI model knows its own things. Ask several at once and you get not only a check, but advice no single model would have given you — including on what you did not ask.

A panel pays off twice:

1. Different knowledge. Each model was trained on its own data and runs in its own harness: the vendor’s CLI agent or an API, its own web search, its own way of reading pages. So when you ask “how should I design this” or “review this code”, each one answers with its own recommendations, and together they cover more than any one of them.
2. An independent check. The models never see each other’s answers. When they agree, that means something; when they disagree, it means more. One AI agreeing with you proves nothing.

Every review answer ends with an UNASKED section. That is where the model puts a wrong assumption, a risk, a better alternative or the thing worth checking next — only what it would defend as significant, and if there is nothing, it says so. The most valuable finding often comes from there.

Send the same document to several independent AI models at once: GPT, Gemini, Grok, Kimi, Qwen, DeepSeek, GLM, MiMo, Muse Spark, NVIDIA Nemotron, and Claude if you switch it on. You get back:

• what each model found and what it recommends;
• its UNASKED section — what matters that you did not ask about;
• where the models contradict each other;
• a mechanical check that catches AI hallucinations: fabricated citations, invented sources and quiet refusals.

Any AI agent can install it, not only Claude Code. Any agent with terminal access will do — for example Codex CLI, Cursor, Gemini CLI, opencode, Kimi Code or Qwen Code: this is plain Python with no dependencies. Give the agent the repository link and ask it to install the tool (a ready-made request is under «Install»). The repository carries AGENTS.md, the instructions for AI agents on how to install the tool and run a review, so from then on the agent runs the panel itself. The sequence an agent runs — install.ps1, doctor.py and a free --dry-run — was checked on 2026-10-05 from a plain terminal, without Claude Code.

In Claude Code the plugin reacts to “second opinion” by itself. To make another agent do the same, add one line to its standing instructions: “When I ask for a second opinion, run AI Second Opinion following ~/.claude/skills/model-orchestration/SKILL.md”.

Pure Python, zero dependencies, MIT license.

Русская версия · How it works, in technical detail · Install · When something breaks · For AI agents

---

Getting started: accounts and keys

To start you need one OpenRouter key and a couple of free programs. Everything else adds voices but is optional: the tool runs whatever you have and tells you plainly what it skipped.

There is no free Kimi any more. NVIDIA retired its free Kimi K3 on 2026-10-15: the endpoint answers HTTP 410 «end of life». Versions 1.106–1.111 asked for a step «2b» (the Kimi Code CLI and an NVIDIA_NIM_API_KEY); since 1.112.0 nothing uses them, the nvkimik3 channel ships switched off, and the cheap panel has no Kimi voice. Kimi K3 answers in the standard panel through OpenRouter (kimik3, paid). «only kimik3» starts that channel alone; «only kimi» does too on the standard panel, while on the default cheap panel it stops and asks you to name kimik3: a family word never moves you from free to paid in silence.

To check what was found: python doctor.py. It prints which keys and programs it found, and never prints a key itself: only present / absent and the length.

🔴 Do not paste a key into a chat with an AI assistant. Set it yourself in the terminal; why is explained under «Install».

How to ask

In Claude Code with the plugin (and in any agent you gave the line from the top of this page) just say it in plain words:

From a terminal the same is done with flags: --panel cheap (the default), --panel standard, --route "только CLI", --only codex, --skip openrouter. You can see the plan before anything is spent, for free: python routing.py or --dry-run.

Panels: prices as of 2026-10-05, line-up as of 1.112.0

How to read the tables:

• Transport. A CLI agent is the vendor’s program on your computer (opencode, agy, grok, kimi, codex, claude). It runs on your subscription or for free and needs no OpenRouter key. OpenRouter is an API request on your key, paid per token.
• Effort is how hard the model thinks. The tool always sets the highest level the model accepts.
• Price per 1M tokens is from the OpenRouter catalogue on 2026-10-05, input / output.
• Per run is the median of our runs from 1 September to 5 October 2026; n is the number of runs, each counted once. Yours will be higher or lower: it depends on the size of the document and the number of web searches. The tool prints the exact amount at the end of every run.

The cheap panel — the default: 5 models

If you lack the main transport, a fallback route to the same model takes over:

• Muse Spark. No opencode → spark13cont (Meta key) → orspark13cont (OpenRouter, $0.10 / $0.20, effort xhigh).
• Gemini 3.8 Flash. No agy → orgemini38flash (OpenRouter, $0.75 / $3.75, effort high — this model’s ceiling).
• Kimi K3. Not in the cheap panel since 1.112.0: NVIDIA retired its free Kimi K3 on 2026-10-15 (HTTP 410, «end of life»), so nvkimik3 ships switched off. Kimi answers in the standard panel through OpenRouter (kimik3); «only kimik3» starts it alone (on the cheap panel «only kimi» stops and asks for that name).

In total: about $0.06 a run on your OpenRouter key plus your subscriptions. Expect about 15 minutes: MiMo v2.6 Pro thinks longest, its median is 14 minutes.

If you do not want MiMo Flash (or any other channel)

To stop a channel from starting, put this in ~/.claude/model-orchestration.local.json (your own settings file; updates never touch it):

{ "channels": { "ocmimo26flashfree": { "enabled": false } } }

Any other channel switches off the same way. If the file already exists, add the channel to its channels section. python routing.py shows who will run, spending nothing.

Spark on an OpenCode Go plan. If you have an OpenCode Go subscription and opencode is signed in to it, turn on the ocspark13go channel: the same Muse Spark 1.3, but on your plan instead of the shared free quota (in our runs since 5 October the free version answered in 1 round of 9; the rest hit the quota). The free ocspark13free then stays as the backup: if the plan run gives no answer (limit reached, plan unpaid, timeout), the same brief goes to the free version once.

{ "channels": { "ocspark13go": { "enabled": true } } }

On the plan, Spark costs $0.10 / $0.20 per 1M tokens out of the plan’s limits (opencode.ai/docs/go, 2026-10-08); a live run on a 35,000-character brief used ≈ $0.01. If «Use balance» is on in the opencode console, the plan does not refuse past its limit; it bills your Zen balance instead.

If an answer is «word salad». A model sometimes returns its own control tokens mixed with fragments of words in several languages instead of text: NVIDIA’s free Kimi K3 did so from 6 October until it was retired, and users of other programs reported the same. The run marks such an answer CORRUPTED OUTPUT: REPORT.md says «🔴 CORRUPTED», HANDOFF.md tells you not to open it, and it does not count as an answer.

The standard panel — 12 models: the cheap one + 7

Muse Wonder is Meta’s most capable model (preview) and the most expensive voice here per token: 40× the input and 100× the output price of Spark Contributor. One Wonder runs per round — through the Meta API when MODEL_API_KEY is set, else through OpenRouter. On the API it exists only in Standard mode: what you send is not used for training. orwonder stops at $5 per run; wonder10 has no such ceiling, because Meta runs the whole search loop inside one request. The cheap panel never runs Wonder; --only wonder starts it alone. Since 1.111.0, where the Muse Code CLI is installed and signed in, the round runs Wonder through it instead: mcwonder10cont, the Contributor variant only Muse Code subscriptions offer (Meta may use that content for training), at xhigh (the plan’s measured ceiling), counted against your plan and never against a key. Setup: INSTALL.md, «Muse Code CLI».

ℹ️ Qwen 3.8 Max: until v1.108.0 this line said that 0 of our 8 runs had answered. That was our counting error: the 8 included copies of the same run, and the harness graded real answers as failures because OpenRouter serves the name qwen/qwen3.8-max as its dated snapshot qwen/qwen3.8-max-0902. Counted once per run, all 3 of our runs since 1 September ended with a full answer (22–63 KB). Since v1.108.0 such a snapshot is a note in the report, not a failure.

In total: about $2.5 a run on your OpenRouter key plus subscriptions; Kimi K3 through OpenRouter (≈ $1.38) is the largest part. How long Kimi takes on OpenRouter we have not measured (3 runs). Of the other models added here, GLM 5.3 and Qwen 3.8 Max take longest, medians 16 and 15 minutes (GLM’s longest run: 44 minutes). Most paid channels have a spending ceiling per run ($2–5); a channel that reaches it stops. wonder10 has none: Meta runs its whole search loop inside one request.

By name only

Web search

On the OpenRouter channels the search is done by the Exa plugin: $0.007 a request (up to 10 results). It is billed apart from the tokens, so it is paid even on a free model. The CLI agents search by themselves, within their plan.

python routing.py always prints the live channel list. The tables above are a snapshot of 2026-10-05, and the registry changes most weeks.

Where the prices come from (2026-10-05):

• the OpenRouter catalogue openrouter.ai/api/v1/models, read at 09:15 UTC;
• free-model limits: openrouter.ai/docs/api_reference/limits;
• web search: openrouter.ai/docs/features/web-search;
• the fee: openrouter.ai/pricing;
• MiMo prices match Xiaomi’s own price list: mimo.mi.com/docs/en-US/price/pay-as-you-go;
• NVIDIA’s Kimi K3 (build.nvidia.com/moonshotai/kimi-k3) is gone: on 2026-10-15 from 08:00 UTC its endpoint answers HTTP 410 «end of life» (measured that day);
• plans: help.openai.com/en/articles/11369540, openai.com/index/introducing-chatgpt-go, antigravity.google, gemini.google/subscriptions, x.ai/pricing, x.ai/news/grok-build-for-everyone, opencode.ai/docs/zen, claude.com/pricing, dev.meta.ai/docs/pricing-rate-limits.

The premium panel — a separate script, not a --panel value

True-batch and Flex lanes for the heaviest models at their discounted prices. Batch jobs work nothing like the synchronous channels above, so this deliberately ships as its own script rather than more channels: premium/premium_panel.py, with its own gates — a call-plan file on disk before anything is paid, a secrets scan on every lane with no override, a per-lane discount check (refuses when the discount is gone unless you say --allow-nodiscount), a PII scan on the broker lane, and a pre-submit cost ceiling (a batch cannot be aborted mid-flight, so the ceiling is enforced before submit or not at all).

python premium/premium_panel.py --mode dry --plan PLAN.md --brief BRIEF.md --rundir runs/premium

--mode dry builds everything and bills nothing. Then smoke (a tiny public-fact brief through the same code path), submit, poll, collect. --panel premium on the main tool prints a pointer here.

With only an OPENROUTER_API_KEY, only the broker lane is reachable: run --only solpro. A missing key refuses loudly per lane, and --mode collect aggregates what exists — the report shows the hole rather than papering over it.

Prices resolve from premium/models_snapshot.json (capture dates inside; a price past its validity date refuses rather than inventing a number). Maturity, stated honestly: each lane’s transport was measured against its vendor individually; the assembled panel has not yet run a paid round. Smoke first.

Targeting specific channels

--only codex agy31pro grokbuild     # just the ones named
--skip ornemotron3ultra              # everyone except this one

The live channel list is always python routing.py; the tables on this page are a snapshot dated in the «Panels» heading — channels and their count change most weeks.

The problem this solves

You ask an AI to review your strategy memo. It tells you the memo is strong, adds three supportive points, and cites four sources.

That answer is nearly worthless, for three reasons most people never check:

1. It is built to agree with you. You wrote the memo, you asked the question, and the model optimises for a helpful-feeling reply. Ask the same model to attack the memo and it will find problems it just told you did not exist.
2. One model knows only what it knows. Its ceiling is the data it was trained on and the tools of its harness. Whatever it was weak at yesterday, it is weak at today, and nothing in the answer hints which parts are unreliable or what it simply does not know. Another model, trained differently, will suggest what never occurred to the first.
3. The sources may not exist. Models generate citations that look right — real domain, plausible path, correct-sounding document number — for pages that were never opened and sometimes never existed. In one measured run here, a model produced 11 source links; 3 of them were dead, and its conclusions were still correct. That combination is the dangerous one, because it survives a casual read.

What this does instead

• Different knowledge, different recommendations. Models from different vendors were trained on different data and run in different harnesses. Ask “how should I build this” or “what is wrong with this code” and each proposes its own answer, so you get several options rather than one repeated three times. Every answer also carries an UNASKED section: what matters that you did not ask about.
• A panel of independent models, same document, at the same time. They do not see each other’s answers, so agreement means something and disagreement means more.
• It shows you the disagreement. That is the actual product. Two models calling a claim fine and one calling it fatal is the most useful thing you will read all week.
• It checks the receipts. Every source link each model cites is opened and reported as live / moved / dead. Where the channel supports it, the tool also checks whether the model actually opened the page it cited, or just listed it.
• It catches a model that quietly refused. A model that declines a task still formats its reply correctly, so it passes every naive “did it finish?” check. This catches that.
• Nothing with a password or key ever leaves your machine. Blocked outright, no override. Personal data — ID numbers, SSNs, emails, phone numbers, dates of birth — is found, counted and reported in one line, and then SENT; --warn-pii lists each by kind and line, and --strict-pii turns it into a hard stop. Names and street addresses are not detected at all, at any setting. PRIVACY.md has the reasoning and the measurement behind both.

Who this is for

A note for legal teams

This is a research verification tool, not an advice tool, and the distinction is built into the software rather than written on it. It ships with a mode (--system legal-research) that frames the work as what it is: checking sources for a document a licensed professional will review. Nothing in the output is legal advice, and the models are explicitly instructed not to opine on any named individual’s situation or decide what anyone should file.

That framing is also what makes it work. Asked to “review this filing strategy”, the models refuse on policy. Asked to “verify these six claims against their cited sources”, the same models answer all six with correct citations. The reframing is accurate, not a workaround — checking a document number against the register genuinely is research.

What one run looks like

You write your question in a plain text file and run one command. Below is the real output of a run on 2026-10-05, shortened, from before NVIDIA retired Kimi K3 (so the cheap panel still had six models): it checked five claims about OpenRouter and NVIDIA, one of which we made false on purpose.

[agy38flash] OK  275.2s  model=Gemini 3.8 Flash [gemini-3.8-flash]
[grokbuild] OK  251.0s  model=Grok 4.7 [grok-4.7]
[nvkimik3] OK  666.6s  model=Kimi K3 (via Kimi Code CLI + NVIDIA free endpoint) [nvidia/moonshotai/kimi-k3]
[ocmimo26flashfree] PROBLEM  0.8s  model=MiMo v2.6 Flash Free (via opencode) [opencode/mimo-v2.6-flash-free]
    FAIL: EXIT 1: {"type":"error", ... "error":{"type":"provider.quota", ...
[ocspark13free] PROBLEM  1.1s  model=Muse Spark 1.3 Contributor Free (via opencode) [opencode/muse-spark-1.3-contributor-free]
    FAIL: EXIT 1: {"type":"error", ... "error":{"type":"provider.quota", ...
[ormimopro] OK  185.0s  model=MiMo v2.6 Pro (OpenRouter) [xiaomi/mimo-v2.6-pro]
4/6 channels returned a verified review.
cost reported BY THE VENDORS for this round: $0.0697 across 1 channel(s) (ormimopro $0.0697)
Citation existence check (no vendor cost; fetches the cited pages directly):
  [agy38flash] 6 cited, 6 probed  LIVE=6
  [grokbuild] 12 cited, 12 probed  LIVE=10  MOVED=1  UNKNOWN=1
  [nvkimik3] 9 cited, 9 probed  LIVE=6  MOVED=3

Every line names the model, not just the channel: “the channel answered” is not a fact you can act on; “Kimi K3 answered through NVIDIA’s free server” is. The two free opencode models hit the free service’s quota this time (provider.quota), and the run said so plainly instead of passing an empty answer off as a review. The tool checks the links itself by opening every cited page: one that moved is marked MOVED, one that would not open is UNKNOWN.

Plus one file per model with its full report, a HANDOFF.md summary to read first, and a diagnostics file if anything went wrong.

REPORT.md has a «Tokens per model» table: how many characters and roughly how many tokens (≈, by the «bytes ÷ 4» rule) we sent each model and how much it wrote back, and beside them the vendor’s own meter (billed in, out tok), or unknown where the vendor reports no such number. For a CLI agent the vendor’s count is usually 10-50 times what we sent: the agent reads files and pages on its own and re-sends the whole conversation at every step. For the opencode channels the tool takes tokens and cost from opencode’s own session store, because its output stream sometimes drops the per-step totals.

The one habit worth stealing

Put a claim you know is false into every document you send for review.

It costs nothing. A model that “confirms” your planted falsehood has just told you exactly what all its other confirmations are worth. In the three-channel rounds this test was built on, all three models caught both planted claims — which is the only reason to believe the things they did confirm. (Scope stated on purpose: that measurement is from a three-channel round. Later, larger panels kept refuting the planted claim — 4 of 4 in the 1.46.0 review and 12 of 12 readable answers in the thirteen-channel round behind 1.44.0, per CHANGELOG.md — but a number is worth only the run it came from.)

What it costs, honestly

In short, from our runs of September–October 2026:

• the cheap panel — about $0.06 a run on your OpenRouter key plus subscriptions;
• the standard one — about $2.5: Kimi K3 now always answers there through OpenRouter (≈ $1.38 of it);
• CLI only — $0 on the key, subscriptions only.

The per-model breakdown is in the tables above. The accounts, none of which this tool provides, are listed under «Getting started». Optional: the GEMINI_API_KEY, XAI_API_KEY and MIMO_API_KEY keys reach the same Gemini, Grok and MiMo models through the vendors’ own APIs; those channels are off by default, details in INSTALL.md.

You do not need them all, and you should not start with them all. Missing a key or a CLI is a normal condition, not an error — the tool runs whatever is available and tells you plainly what it skipped. Start with one.

🔴 Do not count the channels from this file. The number is whatever channels.json enables and it has changed most weeks. python routing.py prints the live list and spends nothing. (Every prose copy of that list in this repository has been wrong within days of being written — including, at one point, two different numbers four lines apart in this very file.)

Some channels are cheap because of their data terms, not despite them. As published, ocspark13free, spark13cont and orspark13cont run the same Muse Spark 1.3 Contributor tier — through opencode, directly and through OpenRouter respectively — and ornemotron3ultra runs a free tier; on every one of them the vendor may use prompts and completions for training. That is the trade being made, it is stated in PRIVACY.md with each vendor named, and the tool prints each channel’s data policy in the plan before it spends anything — that line, not this paragraph, is the current list. If a brief should not be trained on, drop those channels for that run: --skip ocspark13free spark13cont orspark13cont ornemotron3ultra.

Nothing else in this file will tell you when to avoid a channel, and that is deliberate. An earlier version carried a loud warning here and in the registry, and it was obeyed twice in ways that were worse than the risk: once a run silently substituted a different model — destroying the comparison the panel exists to produce — and once it dropped a reviewer nobody had decided to drop. The facts belong in front of the person spending the money; the choice does not belong to a sentence in a config file.

Do not share one API key across a team. It bills to whoever owns it, nobody can be attributed, and revoking it cuts everyone off at once. One key per person — which is the whole reason this is a repository you clone rather than a service you log into.

Install

The fastest way: hand this repository to your AI assistant

Paste this into Claude Code (or any coding assistant with shell access), replacing the URL:

Set up this tool for me: https://github.com/igorsaevets/ai-second-opinion
Read its INSTALL.md and follow it. I will set my own API keys myself —
do not ask me to paste a key into this chat, and do not run the key
commands for me. When you are done, run doctor.py and show me the output.

Those last two sentences are not politeness, they are the security model. An assistant that sets the key for you must first receive the key, and the conversation is written to disk, replayed into later context, and often archived. A key that has appeared in a chat transcript is leaked and must be rotated, not deleted. The tool is built around this: it never prints a key, doctor.py reports only presence and length, and orchestrate.py refuses to send a payload containing anything secret-shaped even if you ask it to.

INSTALL.md contains an explicit instruction block addressed to the assistant itself, so a competent one will decline to touch your keys without being told twice.

Or do it yourself

Three ways, in order of how much you want to think about it. Full detail in INSTALL.md.

1 — Plugin (easiest). In Claude Code:

/plugin marketplace add igorsaevets/ai-second-opinion
/plugin install model-orchestration@review-channels

2 — Installer script. Download the repo, then:

.\install.ps1        # Windows
./install.sh         # macOS / Linux

3 — Just copy the files. No git, no plugin system, no installer. Copy one folder:

plugins/model-orchestration/skills/model-orchestration/

into

Windows:        %USERPROFILE%\.claude\skills\model-orchestration\
macOS / Linux:  ~/.claude/skills/model-orchestration/

That is the entire installation. It is plain Python with no dependencies to install — nothing is compiled, nothing runs in the background, and nothing is downloaded until you ask for an update.

Already have it? Updating is one command

python ~/.claude/skills/model-orchestration/update_check.py --apply

Run it from the copy you have: it finds the newest release on GitHub, downloads and verifies it, backs up the old folder, carries your settings across, prints what changed between the two versions and runs the checks (--dry-run shows all of that without changing anything). A plugin install is updated through Claude Code by the same command. You will not have to remember it, either: once a week the kit checks for a release — at session start and after a real round — and prints that command when there is one. The same machinery is what install.ps1 / install.sh call when an install already exists, so “install again” and “update” are the same safe operation.

If you are an AI assistant asked to update an existing install: run update_check.py --apply from the installed folder (or, given a downloaded copy, its upgrade.py). Do not copy files over the old folder by hand, and do not reinstall from scratch. Before 1.7.0 there was no way to do this correctly — no installed copy carried a version number, and the user’s own settings lived in a file that every update path overwrote. If the install you are updating has no VERSION file, it predates the fix and upgrade.py will migrate it. Run python doctor.py afterwards and report its version line.

Your own settings live outside the skill folder, in ~/.claude/model-orchestration.local.json, precisely so that no update can touch them:

{ "channels": { "goog36flash": { "enabled": true } } }

Every run prints that file’s path and each value it changed, so it can never quietly explain a channel that is not doing what you expect.

From 1.8.0 that file may change anything — repoint a model, add a whole channel or your own tier ("_new": true marks an addition, so a misspelt name fails loudly instead of quietly becoming a second channel). 1.7.0 refused those, and it was wrong to: your settings file and the shipped registry have the same write permissions, so refusing a field in one only pushed the change into the other — and the other was the file nothing announced before a run. Both are reported now, with transport changes marked. The one restriction left is about provenance, not about you: if you move the file with MODEL_ORCH_LOCAL, only the “how hard does it work” knobs are accepted from it, because a repository you cloned can set an environment variable and cannot set your home directory.

Then, once per machine:

python ~/.claude/skills/model-orchestration/doctor.py

It checks everything, reports what is missing in plain language, and prints your exact run command with the real path already filled in.

When something goes wrong

Every run writes two files next to its results:

• run.log — everything that happened, written as it happens, so it survives a crash.
• diagnostics.json — a structured report: what is installed, what each model did, what failed, and for each problem a plain-language cause and a suggested fix.

Both are automatically stripped of keys, tokens and personal data, so you can paste them straight into a chat with an AI assistant and ask it to fix the problem, or attach them to a bug report, without checking them first.

That is the intended workflow when you are stuck: hand diagnostics.json to your AI assistant and ask it to diagnose the cause. See TROUBLESHOOTING.md.

Adding a model

Every model this tool knows about lives in a single channels.json registry: adding a channel is an edit to that file, not new code, and your own additions go in the local settings file described above, where no update can touch them. What changed recently is in CHANGELOG.md; the live channel list is python routing.py.

(An earlier version of this section was a roadmap. Its main items shipped — OpenRouter is now the biggest group in the table above, and every run reports its own cost — while the section went on promising them as future work for weeks. A list of plans in a README rots faster than anything else in it, so this is now one line: the registry is the roadmap.)

What this is not

• Not ChatGPT, not Perplexity, not a single-model tool. Those give you one answer from one model — fast and useful, but with one set of blind spots you cannot see. This gives you several answers from models that do not see each other, plus a mechanical audit of their work. The disagreement between independent reviewers is the product.
• Not a fact database. It reads the live web through the models’ own search tools. It can be wrong, which is exactly why it shows you several answers instead of one.
• Not a replacement for an expert. It is very good at finding what an expert should look at.
• Not “deep research” mode. Those are separate, separately-billed products at several vendors and are not reachable from a normal subscription. This runs every model at its maximum depth with a source-discipline instruction — the same shape, but with multiple independent answers and an audit of every citation, which no deep-research product gives you.
• Not a benchmark or eval harness. Benchmarks measure models against known answers. This puts models to work on your question, where no answer key exists — and lets their disagreement tell you what a benchmark never could.
• Not automatic. You still read the disagreement and decide. The tool’s job is to make sure you are deciding with the objections in front of you.

Frequently asked questions

Why not just ask ChatGPT / Claude / Gemini directly? A single model has a single set of blind spots, and nothing in its answer tells you which parts are weak. A panel of independent models — each blind to the others’ answers — surfaces disagreements that one model alone will never show you. Two models saying a claim is fine and one calling it fatal is the most useful signal you will find.

How is this different from Perplexity or AI search? Perplexity gives you one synthesised answer with sources. This gives you several independent answers, shows you where they contradict each other, and then mechanically checks whether the sources each model cited actually exist and were actually opened. The disagreement and the audit are what you are paying for.

Can I use this from Cursor / Windsurf / another coding tool? Yes. It is plain Python with no dependencies. Any tool with shell access can run it. There is also a one-command Claude Code plugin install — see Install.

Does this work with OpenRouter models? Yes. OpenRouter is the biggest single-account group: one API key unlocks Kimi, Qwen, Gemini, MiMo, Grok, GLM, DeepSeek, Muse Spark and NVIDIA Nemotron. Start with that and add direct vendor access later for the models that benefit from it.

Is this expensive? No. The cheap panel costs about $0.06 a run on your OpenRouter key, plus subscriptions you most likely already have. Say “CLI only” and there is not one paid request on the key. The standard panel costs about $2.5 a run: since 1.112.0 Kimi K3 always answers there through OpenRouter. These are the medians of our runs in September–October 2026; the tool prints the exact amount of your run at its end. See what it costs.

Found a bug? Want a feature? Want to work together?

Maintained by Igor Saevets (@igorsaevets), Los Angeles.

There is deliberately no contact email in this repository. A public address in a public repo is harvested within days, and the address on the commits here is GitHub’s no-reply relay, which has no mail exchanger at all — mail sent to it is not delivered anywhere, quietly. A channel that silently swallows a bug report is worse than no channel, so the links above are the real ones.

Licence

MIT — see LICENSE. Use it commercially, fork it, ship it inside your own product.

---

Every rule enforced by this tool exists because something failed on a real run. The measurements quoted above are from actual runs, not estimates. Details and dates are in TECHNICAL.md.