Multi-Model Code Review: Disagreement as Signal

Where this fits

You're about to merge a branch that touches a legacy module with subtle state handling. You run one AI review, get a confident report, and still have a nagging feeling. The code-review skill replaces that single opinion with three independent model passes—Claude sub-agents, OpenAI Codex, and a cheap third reviewer via OpenCode—reconciled into one report. The disagreement between models becomes the signal that points you to the actual risk.

Why agents benefit

• Cross-model disagreement detection: Instead of trusting one model's hallucinated bugs, the skill surfaces where models diverge—those spots are where real issues hide.
• Scope-aware review: You can point it at a diff, a branch, specific files, a single function, or a whole repo. The agent adapts its reading strategy to the target.
• Configurable depth and cost: From lite to ultra review depth, and model choices from haiku to opus—you control the trade-off between thoroughness and expense.
• Reconciled output: The agent doesn't dump three raw reports. It merges findings, deduplicates, and marks consensus vs. conflicting opinions.
• Automated probe setup: The skill self-checks its scripts and tells you if the environment is misconfigured, so you don't debug the tooling instead of the code.

Practical scenarios

Pre-PR cross-check for a risky refactor

You've extracted a state machine into a new class. Run code-review on the diff with normal depth. The three models disagree on whether the error path is reachable—that disagreement flags the exact line you need to test manually.

Second opinion on a legacy module

A module has been untouched for two years, and you need to add a feature. Run an ultra review on the whole file. The cheap third reviewer catches a memory leak that both Claude and Codex missed, while Claude spots the concurrency issue the others ignored.

Consensus check before a security-sensitive merge

You're merging a PR that handles user input. Use code-review with high effort and sonnet as the middle model. The reconciled report shows two models agree on a potential injection path, giving you evidence to push back on the author with confidence.

Add it to your agent workflow

Install the skill with a single command:

npx skills add szarkans/multi --skill code-review

Then invoke it with natural language plus optional parameters. For example, to review a branch with medium depth and balanced cost:

Review the branch feature/payment-fix, lite depth, sonnet model, medium effort.

The skill handles the rest: spawns sub-agents, runs the reviewers, and reconciles the output. For more context on how this fits into a broader agent skill ecosystem, see the skill page on OpenAgentSkill.

Compare before adopting

Before making this a permanent part of your pipeline, compare it against alternatives. Check whether the reconciled output actually reduces false positives in your codebase—run it alongside your existing single-model review on a few PRs and measure how often the disagreement points to a real bug. Look at the GitHub repo's freshness: it has 4 stars and is early stage, so verify the scripts work with your Claude and Codex versions. Also consider whether you need the cost overhead of three models when a single pass might suffice for trivial changes. Finally, assess workflow fit: does it integrate cleanly with your CI, or is it best as an interactive pre-merge tool?

Why it is worth tracking

This skill is worth watching because it tackles a real limitation of single-model reviews: confident hallucination. The multi-model consensus approach is a pattern likely to spread, and this skill is an early, practical implementation. Its low star count means it's unproven, but the design is sound and the author is actively iterating. Track it for a few weeks—if the repo keeps updating and the community adopts it, it could become a standard step in high-stakes code reviews. Even if you don't install it now, the idea of using model disagreement as a review signal is one you'll want to borrow.