Apply to my task
arXiv:2605.01566 ★ 71 May 2, 2026

Mixture-of-Agents: several independent answers + a synthesis beat any iterative revision

Key result

Ask a model to "improve your answer" and you get something worse than the first attempt. This isn't a hypothesis — it's a measured failure: self-refinement loses even to a plain one-shot request at any token budget. The Mixture-of-Agents method tackles this differently — it gives the model several independent attempts with no memory of each other, then one synthesis. In tests this delivered +7.1 percentage points of accuracy over a plain request and +2.7 pp over voting across multiple answers (self-consistency), at the same budget.

01

TL;DR

Mixture-of-Agents (MoA) is a technique where several "experts" (the same LLM in different roles) generate answers independently, and then the model synthesizes them into a final output. The key principle: there are always more parallel generations than synthesis rounds — the optimum is reached with N experts and N−1 aggregation layers.

The most important finding: "Improve your answer" — a popular trick — actually hurts quality. Self-refinement performed worse than a plain CoT request at every compute budget. A model that iteratively edits itself doesn't get more accurate — it drifts and degrades. Users who type "now make it better" three times in a row burn tokens and end up with something worse than the first draft.

MoA solves this differently: instead of iteratively editing one answer — several independent attempts, each with no memory of the others, and a single final synthesis. This removes accumulated errors and gives the model a "fresh pair of eyes" on every generation. In the study, MoA added +7.1 percentage points of accuracy over baseline CoT and +2.7 pp over self-consistency at the same budget.

Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.

02

Method Blueprint

STEP 1 (in parallel, in one prompt):
  Expert A → independent answer
  Expert B → independent answer  
  Expert C → independent answer
  [N experts — no references to each other]

STEP 2 (synthesis, once):
  Aggregator → reads all answers → final output

Rule: N experts > N synthesis rounds by 1
Optimum: 3 experts + 1 round | 4 experts + 1 round | 5 experts + 1 round

Both steps run in a single prompt — the model generates both the experts and the synthesizer itself.

03

Example in Action

Task: Alex is launching his own YouTube channel about investing and can't decide whether to make short videos for Shorts or long deep-dives. It's a tricky call: he has to factor in the algorithm, the audience, monetization and his own bandwidth.

Prompt:

I'm launching a YouTube channel about investing for beginners in the US. 
The key strategy question: focus on Shorts (under 60 seconds) 
or long deep-dives (15–30 minutes)?

Step 1. Three experts give independent answers — each 
from their own role, without considering the others' opinions:

Expert A (YouTube algorithms): [a detailed recommendation 
strictly from the standpoint of reach and promotion]

Expert B (monetization and business model): [a detailed 
recommendation strictly from the standpoint of revenue and channel growth]

Expert C (audience behavior in the investing niche): 
[a detailed recommendation strictly from the standpoint of 
what people watch and subscribe to]

Step 2. Synthesizer: read the three answers above, find 
the contradictions, weigh the arguments and give a final 
recommendation with a strategy for the first 3 months.

Result: The model will generate three independent expert positions in sequence — each emphasizing its own angle without looking over its shoulder at the others. In the final block, the synthesizer will compare all three, explicitly flag where the experts disagree and why, and give a balanced recommendation. This is fundamentally different from a single "balanced" answer — the contradictions between experts are visible and explained.

04

Why It Works

The LLM's weakness: When a model "improves" its previous answer, it works like an editor with tunnel vision. It has already "seen" the first version — and the new answer unconsciously gets built around it. Errors in the first answer don't get fixed; they carry over into the second and third. The study shows this isn't a hypothesis — it's a measurable decline.

The LLM's strength: The model is good at looking at one problem from different angles at the same time. When each "expert" is generated with no memory of the others, every attempt is a fresh one. Errors in one branch don't infect the rest.

How MoA uses this: The parallel generations are isolated — no expert sees the others. The final synthesis receives N independent signals and picks the best or weighs them. Control levers:

  • Number of experts → more for complex tasks, 2–3 for simple ones. Beyond 5, returns diminish
  • Expert roles → specific ones (financier, marketer, skeptic) cut sharper than a faceless "expert 1"
  • Synthesize once → a second aggregation round isn't needed and often hurts
  • Task difficulty → on easy questions (a capital, a fact, a formula) MoA is overkill. It shines on tasks with real uncertainty
05

Prompt Template

Task: {task description}

Step 1. Three experts answer independently — each strictly 
from their own role, without considering the others' opinions:

Expert A ({role A}): [answer strictly from the standpoint of {angle A}]

Expert B ({role B}): [answer strictly from the standpoint of {angle B}]

Expert C ({role C}): [answer strictly from the standpoint of {angle C}]

Step 2. Synthesis: read the three answers above. Find 
the contradictions and points of agreement. Give a final conclusion 
with reasoning — what matters more and why.

What to fill in: - {task description} — a specific question or situation - {role A/B/C} — specific professional roles suited to the task: financier, lawyer, marketer, engineer, skeptic, end user - {angle A/B/C} — which aspect of the task this expert looks at

You can cut the number of experts to two on simple tasks. Going beyond four isn't worth it.


🚀 Quick start — paste into the chat:

Here is a template for the Mixture-of-Agents technique. Adapt it to my task: {your task}.
Ask clarifying questions to fill in the fields.

[paste the template above]

The LLM will ask about your task, choose roles and angles for the experts, and fill in the template — because for the method to work, you need a clear picture of which three independent perspectives give the widest coverage of your specific task.

06

Limitations

⚠️ Easy tasks: If the answer is obvious, three experts will say roughly the same thing. The method is overkill. Use MoA only when there's real uncertainty.

⚠️ Self-critique doesn't work: Don't add "now each expert critiques the others" to the template — the study shows that iterative rounds with memory of previous answers make results worse. Synthesis happens once, at the end.

⚠️ More ≠ better: The optimum is N experts and N−1 synthesis rounds. Adding one more aggregation layer reduced accuracy in almost every configuration.

⚠️ Tasks with a single right answer: The method is built for tasks with uncertainty. On questions like "what is 2+2" it's pointless.

07

Resources

Paper: "Multi-Agent Reasoning Improves Compute Efficiency: Pareto-Optimal Test-Time Scaling"
Authors: Florian Valentin Wunderlich, Lars Benedikt Kaesberg, Jan Philip Wahle, Terry Ruas, Bela Gipp
Institution: University of Göttingen, Germany
Contact: [email protected]
Code: https://github.com/Multi-Agent-LLMs/lm-evaluation-harness
Benchmarks: MMLU-Pro, BBH
Related work: Du et al. 2023 (debate), Wang et al. 2024a (MoA), Madaan et al. 2023 (self-refinement), Wang et al. 2023 (self-consistency)

Research digest

Key result

Ask a model to "improve your answer" and you get something worse than the first attempt. This isn't a hypothesis — it's a measured failure: self-refinement loses even to a plain one-shot request at any token budget. The Mixture-of-Agents method tackles this differently — it gives the model several independent attempts with no memory of each other, then one synthesis. In tests this delivered +7.1 percentage points of accuracy over a plain request and +2.7 pp over voting across multiple answers (self-consistency), at the same budget.

Principle

The rule is simple: there's always one more parallel expert than there are synthesis rounds. 3 experts — 1 synthesis. 4 experts — 1 synthesis. Each expert answers blind, without seeing the others — this is essential, no back-and-forth between them. A second aggregation round almost always ruins the result — you synthesize once and that's it.

Why it works

When a model edits its own answer, it works like an editor who has already fallen in love with the first draft. The first attempt's errors don't disappear — they move into the second and third, only now wrapped in more confidence. But when several answers are generated in parallel with no memory of each other, the model starts from a clean slate every time. An error in one branch doesn't infect the others — and the synthesizer at the end sees several genuinely different takes at once and can cross-check them instead of just reinforcing the same logic.

When to apply

Analysis and decision-making → strategy, risk assessment, choosing between options, especially when there's real uncertainty and several plausible answers. NOT a fit for tasks with one exact answer — arithmetic, a fact, a formula — where three experts will just repeat the same thing and waste tokens.

Mini recipe

1. Describe the task concretely: not an abstract question, but a situation with details. 2. Assign 3 (at most 4) roles: each should look at the task from its own angle — not "expert 1" but specifically financier, skeptic, end user. 3. Run them all with no references to each other: tell the model explicitly that the experts answer independently, without seeing anyone else's answers. 4. Synthesize once: ask it to find the contradictions between the answers and explain why the final conclusion was chosen. 5. Don't add a second round: no "let the experts critique each other" — that's exactly the self-refinement that sinks the result.

Examples

[BAD]: `Write a channel strategy. Now make it better. Now even better.` [GOOD]: `Three experts answer independently, without seeing each other: Expert A (YouTube algorithms) — [answer]. Expert B (monetization) — [answer]. Expert C (audience) — [answer]. Synthesis: compare the three positions, find the contradictions and give a final strategy.`

In plain words

Here's the thing: modern AI models aren't all-knowing oracles — they're more like very smart editors wearing blinders. When you ask a model to reread its own answer and fix the mistakes, it falls into a cognitive rut: it has already "fallen in love" with its first draft and simply drags the old screwups into the new version. The study proves that sequential self-correction is a road to nowhere, where answer quality degrades and compute goes down the drain.

It's like writing a script for a YouTube channel and then editing it yourself five times in a row. By the fifth pass your eyes are so glazed over you wouldn't notice an elephant in the room. The Mixture-of-Agents (MoA) method takes a different approach: instead of one lone sufferer, we bring in a crowd of independent experts who can't see each other's drafts. It's like putting an analyst, a hype-chaser and a camera operator in one room, giving them the same task, and then calling in the editor-in-chief to stitch their best ideas into one final masterpiece.

It runs on a strict mathematical scheme: spin up a bunch of parallel opinions, then synthesize them once. The researchers found that the ideal balance is N experts for N−1 aggregation layers. With fewer experts the answer comes out flat; with more synthesis layers the model starts making stuff up and losing the point. The main secret of success here is parallel generation: independent agents light up the problem from different sides, and one agent's mistakes get covered by another's common sense.

Although it was tested on hard logic problems, the MoA principle applies anywhere the cost of a mistake is high and the answer is ambiguous. Whether it's a business launch strategy, writing code or planning a complicated vacation — one model working "with several heads" will deliver a result head and shoulders above the most powerful solo model. It's a shift from the "one very smart processor" concept to a collective mind, where the number of agents converts directly into output quality.

Bottom line: stop torturing one model with requests to "think again" — it doesn't work and only breeds hallucinations. The future belongs to multi-agent systems, where the result comes from independent opinions and one tough filter at the end. Compute efficiency is now measured not by hardware horsepower but by how well you've organized this "digital panel of experts." Whoever keeps using LLMs as a lone chatbot will keep getting mediocre content while everyone else is building meaning factories.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Mixture-of-Agents: several independent answers + a synthesis beat any iterative revision arXiv:2605.01566

Sign in to apply this study New accounts get 50 free credits.