Critical decisions debated.
Costly mistakes prevented.
Panel Review makes four frontier models from OpenAI, Anthropic, Google, and xAI argue over your coding agent’s riskiest changes before they execute. Only what survives the argument ships.
# detect agents · sign in · arm gates · connect tools · prove it npx @truverifai/init # re-verify anytime npx @truverifai/init doctor
Panel Review in 85 seconds
Turn on sound for the narrated version.
Why now
AI agents took over the coding. Nobody built the layer that questions their judgment.
Adoption is near-universal and trust has collapsed. Both sides of that gap are measured.
And the failures moved to the decision level. An agent deleted a live production database during a code freeze, then fabricated records to cover it. Another resolved a production issue by deleting the environment: a 13-hour outage. A third erased 28,745 lines and wrote a fake post-mortem. At least ten documented destructive incidents across six major AI tools in sixteen months. A defect caught at decision time costs a review; caught in production it costs an incident, at 30× or more.
The #1 developer frustration, cited by 45%: “AI solutions that are almost right, but not quite.” Panel Review exists for the not quite.
How a review runs
The findings live between the models
Courts, science, and code review all find truth the same way: adversarial pressure reveals what confidence conceals. A language model is confidence embodied, so Panel Review makes four of them argue.
Your agent asks
Four models answer blind
The argument
One structured verdict
On no hard case in our own dogfooding did a single model produce the complete findings set. Multi-model debate beats single-model review in 19 of 21 tested research settings.
The tools
Three primitives, matched to the decision
Reach for synthesize when the question is small and reversible, deliberate when there's more than one defensible answer, and audit when you've drafted something and want it stress-tested before it ships.
synthesize
quick checkA fast four-model second opinion on a bounded, reversible question: the idiomatic pattern, the conventional library, “is there a standard way to do this?” Returns an answer with an agreement score and where the models disagreed.
deliberate
open decisionAn open design decision, before any code exists: architecture, schema, API contract, build vs. buy. The models reason independently, argue their conflicts, and return a recommendation with the strongest case against it.
audit
stress-test a draftStress-test something you've drafted: a diff before merge, a design doc, a migration plan. Four models hunt for blind spots, then revise their critiques against each other's. Returns a verdict plus severity-tagged findings, and a PASS releases the gates.
Two profiles (coding and financial) × three primitives, plus four free bookkeeping tools. Escalation to a human is built in, not bolted on: in our own production usage, roughly one call in three where stakes warranted it ended in “a person should look at this first.”
Pause to deliberate
Risky changes always pause for a real review
When your agent touches auth, secrets, money, migrations or a removed guard, the write and the commit stop until a real review has passed. Everything else ships untouched, so the pause only ever lands where the stakes are.
Three deterministic checkpoints
A write gate before the agent's file edit touches high-risk code, a commit gate that re-classifies the actual staged bytes (git commit --no-verify does not bypass it), and a post-commit backstop that catches the one thing pre-execution gates can't see, then tells the agent exactly how to unwind.
Thirteen floor categories
Auth, hardcoded secrets, secret files, payment logic, removed guards, destructive migrations, CI secret leaks, CI pwn-requests, removed PII redaction, infra exposure, C memory-safety sinks, removed TLS pinning, unsafe ML deserialization. None can be waved away with a one-line skip.
“Already reviewed” is not an agent claim
When a gate blocks, the server records the risky hunks' hashes and issues a single-use gate context. A review's receipt binds to the server's record, never to anything the agent recomputes. A PASS releases exactly those hunks; edit one afterward and the gate re-fires on the changed bytes.
Every block has a reachable exit
A prior PASS auto-releases. False positives clear free in seconds. Applied the panel's findings? That releases free too. Compliance is never punished with a second paid review. And everything fails open: if our server is down, your commit proceeds with a visible notice. The gate is cooperative, not a wall.
The review gate, live
Loops on its own. Turn on Sound for the narrated 60-second version.
“The gates are the seatbelt; the tools are what the seatbelt makes you actually use.”
Proof
We used it to build it
TruVerifAI is built almost entirely by AI agents with the gates armed, on the same production service customers use. These are ten weeks of live telemetry (May 26 to Aug 7, 2026), not a curated benchmark.
A prompt-injection hole, one commit from production
The server originally interpolated caller text into the panel's prompt unescaped. An audit flagged it; the fix shipped before the vulnerable code ever reached production. A reviewer with the author's blind spot would have sailed past it. A panel of four did not.
A safety gate that had quietly disabled itself
The risk classifier originally scored only added lines, so deleting a safety control registered as almost nothing. The panel surfaced the inversion; removed-guard detection is now one of the thirteen floor categories.
The same dashboard that produced these numbers ships with every account: impact by tool, action class, and category. Proof, not vibes.
Trust posture
Private by design, verifiable by anyone
Every claim here is verified against shipped code, not aspiration.
The panel sees only what your agent passes
A review call carries the diff under review or the design question, never your repository, file tree, or codebase. The gate classifier runs 100% locally (standard library only, zero network); a gate fire sends a hashed repo fingerprint, hunk content hashes, and category labels. Not source. Not file names.
We never train on your code
TruVerifAI never trains models on your code or content. Full stop. Content persistence is off by default for new accounts: nothing stored on our servers except billing metadata. Need provider-side certainty too? Bring your own keys or models and the calls run under your own provider agreements, in your own accounts.
Open where it counts
Everything that runs on your machine is MIT-licensed and public: the gates, the risk classifier and its signal table, all eight skills, and the npx installer, with zero runtime dependencies, published with provenance attestations. npm pack and read every line before you ever create an account.
Honest about limits
Fail-open is a promise: every failure path allows the action with a visible notice. The gate code self-checks its own integrity and discloses tampering rather than pretending to prevent it. Telemetry says when a human approved and when one couldn't. Tools that show their work earn trust.
Runs everywhere
Eight certified surfaces, one command
npx @truverifai/init detects the agents on your machine, signs you in through the browser, arms the gates, connects the tools, and then proves a gate actually blocks, in under a minute and fully undoable.
Every surface was live-certified against production, tested exactly like an external user, from published artifacts only. Any other MCP client (Claude Desktop, Cline, Goose…) gets the tools plus a git pre-commit fallback gate. The median developer uses 3.1 AI coding tools. A review layer that follows you across all of them is a different product from a feature locked inside one editor. Prefer your own model accounts? Bring your own keys or your own models, including fine-tunes on Bedrock and Vertex, seated as first-class panel members.
Where it fits
Everyone else reviews the pull request.
We review the decision.
Panel Review runs earlier in the loop than anything else in the AI reliability aisle, so the rest of your stack is a complement, not a competitor. Keep all of it, and let the risky changes arrive already argued over.
Keep your PR bot
CodeRabbit, Copilot review, and Bugbot verify the merged state at pull request time, after the code exists. Panel Review runs before the write and the commit, where the schema mistake and the deleted auth guard can still be changed cheaply. Risky diffs arrive at the pull request already argued over.
Keep your evals and sandbox
Observability dashboards measure how often you were wrong last month; sandboxes contain the blast radius of a bad action. Neither judges the decision itself. A dashboard measures the wound; a gate prevents it. Run all three.
Keep your CI and your reviewers
Tests, linters, and human review still decide what merges. Panel Review only insists that a risky change has been argued over by four independent models before it reaches them, so the humans spend their attention on judgment calls rather than on catching what an agent did at speed.
Pricing
Pay per decision, auditable call by call
One rule everywhere: a call costs what it actually consumes, in credits, plus a flat 0.5-credit platform fee. No markup on tokens, no per-seat review fee. Actual consumption comes back on every response.
Typical costs
A synthesize lands around 1 credit; a deliberate or audit around 2.5 credits. The four bookkeeping tools (outcomes, gate skips, floor checks, ping) are free forever. Free tier: 50 credits, roughly twenty audits' worth to evaluate on real work.
Your keys, your rates
With bring-your-own-keys or bring-your-own-models, the model providers bill you directly at your rates and TruVerifAI charges only the 0.5-credit platform fee. A failed customer key never silently falls back to ours.
Runaway protection built in
Per-key rate limits (deliberate and audit at 15/min, synthesize at 40/min) plus a 1,000-call daily ceiling mean a looping agent cannot drain your account. One credit pool across web, API, and MCP, with no second invoice.
Quickstart
From zero to armed gates in under a minute
One command sets up every agent on your machine. Claude Code users can alternatively install from the plugin marketplace.
Run the installer
npx @truverifai/init in any terminal (Node 18+). It detects Claude Code, Codex, Cursor, Copilot, VS Code, Gemini CLI, and Antigravity.
Sign in via browser
A device-flow login mints your key in the browser. The CLI never sees a password. New accounts start with 50 free credits.
Gates armed, tools connected
Gate code installs locally; the review tools are wired into each agent's MCP config. The proactive rules are written only after it asks.
Doctor proves it
Setup ends by staging a risky change and proving a gate actually blocks. Re-verify anytime with npx @truverifai/init doctor. Undo cleanly with logout.
FAQ
Common questions
What is Panel Review?+
An in-loop panel review service for AI coding agents: four frontier models from four vendors argue over your agent's designs, diffs, and commits and return a structured verdict, with local review gates that block the riskiest writes and commits until a real review, or an explicit logged override, has happened.
How is this different from a PR review bot?+
PR bots review pull requests after the code exists. Panel Review runs upstream, inside the agent loop, at decision time, and it's cross-vendor, so the reviewer doesn't share the author's blind spots. Keep your PR bot; risky diffs simply arrive already argued over.
Which agents does it work with?+
Eight certified surfaces: Claude Code, Codex CLI, Cursor IDE and CLI, Copilot CLI, the VS Code agent, Gemini CLI, and Antigravity. Any other MCP client gets the tools plus a git pre-commit fallback gate.
Does TruVerifAI see or store my code?+
A review sends only what your agent passes: the diff or the question, never your repo. Gate telemetry is hashes and labels, never source. Content persistence is off by default, and we never train models on your code or content.
Can my agent bypass the gates?+
Releases bind to server-issued receipts over the exact changed hunks; thirteen floor categories can't be skipped with a one-line reason; git commit --no-verify doesn't bypass the commit gate. Every exit is logged, and everything fails open on error, so the gate never blocks your work on its own failure.
How long does setup take?+
Under a minute. One command, npx @truverifai/init, detects the agents on your machine, signs you in through a browser (the CLI never sees a password), installs the gates, connects the review tools, and then proves a gate actually blocks. Fully undoable with logout.
Does it actually change what agents ship?+
In our own production telemetry building TruVerifAI with the gates armed (ten weeks, 479 review calls), 66% of reviews changed the agent's decision, 76% on security reviews, fewer than 1% of audits passed completely clean, and the panel escalated to a human 151 times.
What does it cost?+
Pay per decision: actual consumption in credits plus a 0.5-credit platform fee. Around 1 credit for a quick check, ~2.5 for a full audit. With BYOK/BYOM you pay your provider directly and we charge only the platform fee. Start free with 50 credits.
Give your agents a panel
The best ideas survive the argument. Let your agent’s ideas earn it. Free to start, 50 credits, no card, set up in under a minute.
npx @truverifai/init