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 discovered this while building our agentic harness at Zipper, and I wasn’t looking for it. We had agents writing code, plans, and specs, and the output looked fine in the dangerous way: it passed the tests, read cleanly, and resembled 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 obvious once you see it, and it’s not a knock on the model. The agent that wrote the code is compromised because it just spent its entire context building a case for that exact answer. Asking it to review the answer is like asking the defense attorney to sit on the jury. It reads its own intent back into the code instead of reading the code cold, then explains why the sketchy line is actually fine. Researchers call this an echo chamber, and the model that generated the answer is the worst candidate to find its flaw.

The fix was never a smarter author. It was a second agent that didn’t write the code and had 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 asking the same model again buys you almost nothing while a diverse panel buys you a lot. Two models from different labs, trained on different data toward different goals, are less likely to share the same blind spots. Agreement gives you something close to independent confirmation, but disagreement is even more useful: it puts a flashing light over the place where one model may be confidently and silently wrong. A lone agent never shows you that light. With nobody to disagree with, it uses the same even tone for an answer that is rock solid and one that will quietly page you at 3 AM.

This isn’t my hunch dressed up as a principle. It’s the core result of the multi-agent debate work that has accumulated since 2023: the “society of minds” research in which several model instances propose answers, critique one another across a few rounds, and then converge. The measured outcome is consistent: reasoning improves and hallucinations decrease, not because any one model got better, but because the structure pulls failure modes into the open where they can be challenged instead of rubber-stamped.

The Second Agent Has to Be Hostile

There’s a soft version of this that doesn’t work: get a second opinion, see what another model says, and feel reassured. An agent asked politely to “review this” behaves like a polite reviewer. It skims, finds the work broadly reasonable, suggests a tweak, and signs off, giving you the feeling of verification without the substance. The second agent needs a hostile job description. Its job is to refute rather than assess, starting from the assumption that the answer is wrong and looking for 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.

The pattern that actually moves the needle keeps the worker and verifier strictly apart. A Builder agent produces the work. A Critic agent attacks it from a fresh session with no shared context and only the spec and diff to inspect. The fresh session matters as much as the different model because it denies the critic all the rationalizations the author accumulated, forcing it to judge the artifact cold. The process reads like a debate: Agent A proposes, Agent B tries to break the proposal, and then they converge. What survives the exchange is worth far more than what either produced alone. The disagreement isn’t noise to eliminate; it’s the product.

The Labs Have the Receipts

I could leave this at “trust me, it worked on my harness,” but I’m confident enough to write it down because the labs have turned the same idea into benchmark results. Three independent efforts approached the problem from different directions and arrived at the same finding: a panel can beat 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 approaches the problem through inference scaling. It lets frontier models (o4-mini, Gemini 2.5 Pro, and DeepSeek-R1) cooperate at inference time, with the search choosing which model to call next based on their performance. On ARC-AGI-2, a genuinely hard reasoning benchmark, the multi-model team solved over 30% of the problems, roughly 30% more than the best individual model. The detail that stuck with me is that the cooperating models solved problems no single model could solve alone. That isn’t just a nudge up a leaderboard; it is a capability that emerges from the combination.

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

Mind the Judge

The working recipe is to send your prompt to a diverse panel in parallel, collect the responses, and hand all of them to a judge. What separates a real result from a demo is requiring the judge to produce a structured decision instead of a blended summary. It should identify where the panel agreed, resolve contradictions, and look for anything every participant missed. The most important instruction in the whole setup is not to split the difference. The judge must choose and defend the strongest reasoning. A judge that averages three answers produces something blander than the best input; a judge that adjudicates can produce something better than all three.

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 directly into that bias. If your panel includes Claude and you also make Claude the judge, you risk building a machine that launders one model’s preferences and returns them in the costume of consensus. The judge leans toward its sibling’s answer, you feel reassured by the agreement, and you’ve quietly paid extra for the same model’s blind spots. This is the failure mode that leads people to try an “AI ensemble,” get a mediocre result, and dismiss the whole idea as overhyped. They didn’t really run a diverse panel; they put one model in a hall of mirrors.

The fixes aren’t exotic; they require discipline and deliberate asymmetry. Diversity is the point, which means using different vendors rather than three sizes of the same model family. A panel from one lab can vote for its shared blind spot in triplicate. Frame the exercise adversarially so contradictions are pressed instead of smoothed over, and escalate intentionally rather than running a panel on autopilot. A panel costs N+1 model runs, so use it when being wrong is expensive: for an architecture decision, a security-sensitive change, or a migration against live data. Run it that way and the panel becomes genuinely smarter. Run it lazily and you’ve paid four times for the same blind spot.

So I Built Parley

Once I believed this was real, the question became how to use it day to day, and none of the available options fit. The labs offer deliberation through hosted APIs: sign up with another vendor, manage another key, and send your code and context to its servers to fan out across its models. That’s a reasonable product but a strange trade for someone who already runs three or four capable coding agents locally, each authenticated in the repository, carrying its own context, and coming from a different lab with genuinely different blind spots. The diverse panel I wanted was already on my machine; it simply had no way to convene.

That’s why I built Parley, a small, dependency-free CLI that drives the agent CLIs you already have and makes them work as a team instead of as silos. The cleanest way I’ve found to describe the difference is that Fusion fuses models, while Parley fuses full coding agents. These aren’t raw model endpoints; they are agents with repository access, their own authentication, and the tools and context they already carry. Send one prompt to a panel in parallel, let one agent judge and synthesize the responses, and your code never leaves your machine. There is no new vendor and no additional set of keys to babysit.

The detail I’m most proud of is that Parley isn’t really a command you have to remember to run. My first version used par fuse to send the prompt to a panel and have Claude judge the responses. It worked, but it kept a human in the loop for a decision the agent should make itself, so I moved the panel into an MCP tool. The agent you’re already working with can now convene a panel in the middle of a task, decide to ask Gemini and Codex to refute a migration plan using the current context, and return with an answer that has already survived adversarial review. When a second opinion requires a separate command, you use it only when you remember. When it becomes a reflex the agent can invoke whenever the stakes warrant, adversarial review stops being a special occasion and becomes part of how the system thinks.

Start With One Hostile Second Opinion

You don’t have to rebuild your workflow tomorrow to get most of the benefit. The on-ramp is cheap: before committing a decision that would hurt to get wrong, hand it to an agent other than the one that produced it and make finding the flaw that agent’s only job. One hostile second opinion from a model with different blind spots is enough to start. You’ll catch things in the first week that would otherwise have become a postmortem.

From there, you can scale gradually. Once the second-opinion habit is automatic, convene a full panel for genuinely expensive decisions, let a judge resolve the contradictions, and read the disagreements yourself instead of skipping directly to the synthesis. Keep the discipline of using different vendors, framing the task adversarially, and spending the extra runs only when the stakes justify them.

Notice the skill this approach rewards, because it’s a continuation of a shift already underway. If typing code was the first thing to be commoditized, blind trust in one model’s answer is next. The leverage moves up a level to knowing when a decision is expensive enough to convene a panel, composing a group diverse enough to produce real disagreement, reading the contradictions, and owning the final call. The upgrade isn’t a smarter model you’re waiting for. It already exists in the collection of agents you’ve installed and paid for; they simply need a way to talk to one another.