Agents Are Smarter Together: Model Fusion for Increased Intelligence

One AI agent is one set of blind spots signing off on its own work. The thing that made my agents noticeably smarter wasn’t a better model. It was a second one whose only job was to tear the first one’s answer apart.

The Agent That Wrote It Can’t See the Bug

I found this building our agentic harness at Zipper, and I wasn’t looking for it. We had agents writing code, agents writing plans, agents writing specs, and the output looked fine. Fine in the dangerous way: it passed the tests, it read cleanly, it looked like work a competent engineer would put their name on. Then I changed one small thing. Instead of asking the agent that produced the work to check it, I handed the work to a different agent and told it to assume the thing was broken and prove it.

The quality jump wasn’t subtle. Bugs that had sailed through a green test suite got caught on the first pass. Design calls the first agent had been quietly sure about got challenged with reasons it never surfaced on its own. None of this came from a smarter model or a cleverer prompt. It came from separating the thing that produced the answer from the thing that judged it.

The reason is almost dumb once you see it, and it’s not a knock on the model. The agent that wrote the code is compromised. It just spent its whole context building a case for this exact answer, so asking it to review that answer is asking the defense attorney to also sit on the jury. It reads its own intent back into the code instead of reading the code, and explains why the sketchy line is actually fine. The research people call this an echo chamber, and the model that generated the answer is the worst possible candidate to find the flaw in it.

So the fix was never a smarter author. It was a second one that didn’t write the code and has nothing to defend.

Every model is one training run’s worth of strengths and one training run’s worth of failure modes. It has a way it likes to reason and a category of mistake it makes on repeat, with no awareness of either. Those blind spots aren’t bugs you can prompt around. They’re the shape of the model. Ask it the same question ten different ways and you mostly sample the same competence and the same gaps, because it’s the same mind every time.

That’s why “ask it again” buys you almost nothing and a diverse panel buys you a lot. Two models from different labs, trained on different data toward different goals, don’t share the same blind spots. Where they agree, you’ve got something close to independent confirmation. Where they disagree is the part you actually want: disagreement is a flashing light sitting right on the spot where one of them was about to be confidently, silently wrong. A lone agent never shows you that light. It’s got nobody to disagree with, so it hands you its answer in the same even tone whether it’s rock solid or quietly going to page you at 3am.

This isn’t my hunch dressed up as a principle. It’s the core result of the multi-agent debate work that’s been stacking up since 2023, the “society of minds” research where you run several model instances, have them propose answers, then have them critique each other across a few rounds before converging. The measured outcome is consistent: reasoning improves and hallucination drops. Not because any one model got better, but because the structure drags the failure modes into the open where they get challenged instead of rubber-stamped.

The Second Agent Has to Be Hostile

There’s a soft version of this that doesn’t work. The soft version is “get a second opinion”: run it past another model, see what it says, feel reassured. A second agent asked nicely to “review this” behaves like a polite reviewer. It skims, finds the work broadly reasonable, suggests a tweak, signs off. You get the feeling of verification without the substance. The second agent has to show up with a hostile job description. Its job is to refute, not assess. Assume the answer is wrong and go find the proof.

The asymmetry that makes this work is one of the more striking results in recent code-AI research, and it matches what I saw in our harness. Studies have flagged something like three-quarters of LLM-generated code as carrying a security problem of some kind. Here’s the twist: a model is bad at repairing its own buggy code (the self-repair blind spot, the echo chamber seen from the author’s side), but it’ll fix up to roughly 60% of bugs in code a different model wrote. Same model, two wildly different success rates, and the only variable is whether it wrote the thing it’s looking at.

So the pattern that actually moves the needle keeps the worker and the verifier strictly apart. A Builder agent produces. A Critic agent attacks: fresh session, no shared context, handed only the spec and the diff. The fresh session matters as much as the different model. You’re deliberately denying the critic the rationalizations the author piled up, so it has to judge the artifact cold. The shape I use reads like a debate. Agent A proposes. Agent B is told its only job is to break it. Then they converge, and what survives the exchange is worth a lot more than what either produced alone. The disagreement isn’t noise to resolve away. It’s the product.

The Labs Have the Receipts

I could leave this at “trust me, it worked on my harness,” but the reason I’m confident enough to write it down is that the labs turned the same idea into benchmark numbers, and the numbers are loud. Three independent results, from three directions, land on one finding: a panel beats the best single model.

OpenRouter’s Fusion is the panel-and-judge shape exactly. Fan a query to several models in parallel, then a judge synthesizes one answer from all of them. On Perplexity’s DRACO deep-research benchmark, a budget panel of cheap models (Gemini 3 Flash, Kimi K2.6, DeepSeek V4 Pro) beat both GPT-5.5 and Claude Opus 4.8, the frontier flagships, at about half the cost. Read that twice: three cheap models, deliberated together, outscored the single best model you could buy. A stronger panel of Fable 5 and GPT-5.5 judged by Opus 4.8 pushed it to 69%.

Sakana AI’s AB-MCTS comes at it from inference scaling instead. They let frontier models (o4-mini, Gemini 2.5 Pro, DeepSeek-R1) cooperate at inference time, with the search deciding which model to call next based on how each is doing. On ARC-AGI-2, a genuinely hard reasoning benchmark, the multi-model team solved over 30% of problems, roughly 30% better than the best individual. The line that stuck with me: the cooperating models solved problems no single model could solve alone. That’s not a nudge up a leaderboard. That’s a capability that doesn’t exist until you combine.

The third one is older and foundational. Mixture-of-Agents layers several models, feeds each layer’s outputs to the next, and finishes with an aggregator that fuses everything. Using only open-weight models, it beat GPT-4o on AlpacaEval 2, 65.1% to 57.5%, and the researchers showed the aggregator wasn’t just picking the best response and tossing the rest. It was synthesizing, building an answer better than any single input. My harness wasn’t a fluke. It was a hand-rolled instance of a property these models already have.

Mind the Judge

The recipe, in working form: fan your prompt to a diverse panel in parallel, collect the answers, then hand all of them to a judge. The part that separates a real result from a demo is making the judge produce structure instead of a blended summary. Where did the panel agree? Treat that as high-confidence. Where did they contradict each other, and who’s actually right? What did all of them miss? The single most important instruction in the whole setup: don’t split the difference. Pick the strongest reasoning and back it. A judge that averages three answers gives you something blander than the best input. A judge that adjudicates gives you something better than all of them.

Now the trap nobody putting this in a launch post wants to sit with. Your judge is also a model, so your judge also has blind spots, and one of them points straight at this job. LLM-as-judge research has documented a real, measured self-preference bias: models rate their own output higher than a neutral evaluator would, partly because their own text reads as more fluent to them. They also over-reward answers that are longer and more authoritative-sounding, whether or not those answers are correct. A 2026 RAND analysis found no judge model was uniformly reliable, with frontier models blowing past 50% error on the hardest bias benchmarks. The judge isn’t a neutral arbiter. It’s one more opinionated participant you handed a gavel.

The naive setup walks right into it. Run a panel that includes Claude, then make Claude the judge, and you haven’t built a panel. You’ve built a machine that launders one model’s preferences and hands them back wearing the costume of consensus. The judge leans toward its own sibling’s answer, you feel the warm glow of agreement, and you’ve quietly bought one model’s blind spots with extra steps. This is the failure mode that makes people try an “AI ensemble,” get a mediocre result, and write the whole idea off as overhyped. They didn’t run a panel. They ran one model in a hall of mirrors.

The fixes aren’t exotic. They’re discipline, and they come down to breaking that symmetry on purpose. Diversity is the actual point: different vendors, not three sizes of the same family, because a panel from one lab votes for its shared blind spot in triplicate. Frame it adversarially so the contradictions get pressed instead of smoothed over. And escalate; don’t autopilot. A panel costs N+1 model runs, so you reach for it when being wrong is expensive: an architecture decision, a security-sensitive change, a migration against live data. Run it that way and the panel gets genuinely smarter. Run it lazily and you’ve paid four times over for the same blind spot.

So I Built Parley

Once I believed this was real, the question was how to live in it day to day, and the available answers all had a shape I didn’t love. The labs ship deliberation as a hosted API: sign up with one vendor, get one more key, send your code and context off to their servers to fan out across their models. Fine product. Strange trade, though, for someone who already runs three or four good coding agents locally (Claude, Codex, Gemini, Cursor, whatever your stack is), each already authenticated and sitting in the repo with your context, each from a different lab with genuinely different blind spots. The diverse panel I wanted was already on my machine. It just had no way to convene.

That’s why I built Parley. It’s a small, dependency-free CLI whose whole job is to drive the agent CLIs you already have and make them work as a team instead of as silos. The cleanest way I’ve found to say what’s different: Fusion fuses models, Parley fuses agents. Not raw model endpoints. Full coding agents, with repo access, their own auth, the tools and context they already carry. Send one prompt to a panel of them in parallel, one of them judges and synthesizes, and your code never leaves your machine. No new vendor, no keys to babysit.

The detail I’m actually proud of is that it isn’t really a command you have to remember to run. My first cut was a command: par fuse, fan out to a panel, Claude judges, here’s your answer. It worked, but it put the human in the loop for something the agent should reach for itself. So I moved it. The panel is an MCP tool now. The agent you’re already working with can convene its own panel mid-task, deciding on its own to “ask Gemini and Codex to refute this migration plan, with my context, then resolve it,” and coming back with an answer that already survived an adversarial review. When the second opinion is a command, you use it on the rare day you remember. When it’s a reflex the agent reaches for whenever the stakes warrant, adversarial review stops being a special occasion and becomes part of how the thing thinks.

Start With One Hostile Second Opinion

You don’t have to rebuild your workflow tomorrow to get most of this. The on-ramp is cheap. Next time you’re about to ship a decision that would hurt to get wrong, before you commit it, hand it to a different agent than the one that produced it and tell that agent its only job is to find the flaw. That’s the whole move. One hostile second opinion, from a model with different blind spots, on the calls that matter. You’ll catch things in the first week that would otherwise have been a postmortem.

From there it’s a gradient. Once the second-opinion habit is automatic, escalate to the full panel on the genuinely expensive decisions, let a judge resolve the contradictions, and read the disagreements yourself instead of jumping to the synthesis. Keep the discipline: different vendors, hostile framing, only when the stakes earn the extra runs.

And notice what skill this rewards, because it’s a continuation of something already underway. If typing code was the first thing to get commoditized, blind trust in one model’s answer is next. The leverage moves up a level, to how you run the panel. Knowing when a call is expensive enough to convene one. Composing a panel diverse enough to actually fight. Reading the contradictions and owning the final call. The upgrade isn’t a smarter model you’re waiting on. It’s already on your machine, in the agents you’ve installed and pay for, with no way to talk to each other until you give them one.