STEP 1: The actor solves the task → answer + reasoning
STEP 2: Evaluate the result → success/failure

[If it failed:]

STEP 3: The judge passes the error to the critics → each persona writes a diagnosis
STEP 4: Debate (1-2 rounds) → critics challenge/complement each other
STEP 5: The judge synthesizes → a consensus reflection
STEP 6: The actor tries again with the new reflection in memory

Every step needs a separate request. One cycle = roughly 3x more tokens than regular Reflexion.

Task: You're weighing whether to launch a new brand of handmade eco-friendly candles on Amazon. Average order value is $24, startup investment is $5,000, competition is fierce. Your first attempt at the analysis got stuck on "low price = lots of sales", but your gut says something's off.

Prompt (STEP 1 — Actor):

Analyze this decision: should I launch handmade eco-friendly candles on Amazon?

Data:
- Average order value: $24
- Startup investment: $5,000
- Competition: high (10+ brands at the top)
- Positioning: eco-friendly, handmade

Give a recommendation with a rationale.

→ The actor gives an answer, e.g.: "Yes, go for it. Cut the price to $18 to compete."

Prompt (STEPS 3-4 — Critics' debate):

The actor gave a recommendation: "Yes, go for it. Cut the price to $18."

I think this may be wrong. Run a debate between critics:

**Verifier** (demands facts): checks the logic against the data: unit economics, real conversion on Amazon, customer acquisition cost.

**Skeptic** (looks for risks): which assumptions could be wrong? What if a low price kills the "premium handmade" perception?

**Logician** (strict about the numbers): let's do the exact math: at $18 with Amazon's 15-20% fees, what's the margin? Will the $5,000 pay off?

**Creative** (alternatives): what if not Amazon at all? Maybe Instagram sales with a personal brand would do better?

Have each critic write a diagnosis, then 1 round of debate (who disagrees with whom and why).

Prompt (STEP 5 — Judge):

Here is the critics' debate [paste the output from the previous step].

You are the judge. Synthesize a consensus:
- Which arguments are the strongest?
- Where do the critics agree?
- What reflection should the actor get to reconsider the decision?

Write a short reflection (3-5 points).

Prompt (STEP 6 — Actor with the reflection):

Here is your first recommendation: "Yes, go for it. Cut the price to $18."

Here is the critics' reflection:
[paste the judge's consensus]

Reconsider the decision in light of this reflection. Give a new recommendation.

Result:

You'll get 3 layers of analysis:

1. The actor's first attempt: often shallow, stuck on a single line of logic.
2. The critics' debate: 4 different angles: one crunches the numbers, another looks for risks, a third checks the assumptions, a fourth proposes alternatives. You can see where they argue and where they agree.
3. The actor's final recommendation: after the reflection, it takes everyone's arguments into account. Usually deeper and more practical than the first attempt.

Format: text blocks with each persona's reasoning, then the judge's synthesis, then the actor's final answer.

The LLM's weakness: The model can't "get out of its own head". When it generates an answer, evaluates it and draws conclusions, it uses the same thinking system. A logic error gets reproduced at all three stages. It's like editing your own text right after writing it: you don't see the flaws because your brain is still in the same groove. The result: the model rephrases the error instead of fixing it.

The LLM's strength: The model is great at playing different roles when given explicit instructions and contrasting mindsets. "You're a skeptic, look for holes in the logic" works differently from "You're an optimist, look for opportunities". When several roles argue, the model generates different reasoning patterns instead of repeating the same one.

How MAR uses this: It splits the process into roles. The actor thinks freely. The critics, each with their own lens (facts/risks/rigor/alternatives), analyze from different sides. The judge picks the strongest arguments. It's like showing your text to an editor, a proofreader and a reader: each one spots something different. As a result, on the second pass the actor gets not "you were wrong because you were wrong" but structured criticism from different points of view.

Prompt control levers:

• Number of critics (4 in the example) → cut to 2-3 for simple tasks or to save tokens. More critics = more angles, but pricier.
• Debate rounds (1-2) → give complex tasks 2 rounds, medium ones 1. A third round adds almost nothing but eats tokens.
• Critic personas → replace abstract roles (Verifier/Skeptic) with specific ones for the task. For code: Senior Engineer/QA/Code Reviewer. For text: editor/SEO specialist/reader. For strategy: finance lead/marketer/operations manager.
• Instruction to the judge → add "highlight the 3 strongest arguments" or "point out where the critics agree" to focus the synthesis.
• Consensus condition → you can set "if the critics diverge, run another round", but that increases cost. Or the opposite: "synthesize even if they disagree".

# STEP 1: The actor solves the task

{task}

Analyze it and give a recommendation/solution.

---

# STEP 2: Evaluation (do it yourself or via an LLM)

[If the result is wrong/incomplete, go to STEP 3]

---

# STEPS 3-4: Critics' debate

The actor gave this answer:
"{actor_answer}"

I think this may be wrong/incomplete. Run a debate between critics:

**{persona_1}** ({focus_1}): {what they check/analyze}
**{persona_2}** ({focus_2}): {what they check/analyze}
**{persona_3}** ({focus_3}): {what they check/analyze}
**{persona_4}** ({focus_4}): {what they check/analyze}

Each critic:
1. Write a diagnosis: what might have gone wrong in the actor's reasoning
2. Read the others' diagnoses: agree/disagree and why

One round of debate.

---

# STEP 5: The judge synthesizes

Here is the critics' debate:
[paste the output from STEPS 3-4]

You are the judge. Synthesize a consensus:
- Which arguments are the strongest?
- Where do the critics agree?
- What reflection should the actor get to reconsider?

Write a short reflection ({number_of_points} points).

---

# STEP 6: The actor tries again

Here is your first attempt:
"{actor_answer}"

Here is the critics' reflection:
[paste the judge's consensus]

Reconsider the decision in light of the reflection. Give a new recommendation.

How to fill in the placeholders:

• {task} — your whole task (question/problem/context)
• {actor_answer} — what the model produced on the first attempt
• {persona_1..4} and {focus_1..4} — critic roles for your task:
  • For business decisions: Finance lead (numbers/unit economics), Marketer (demand/positioning), Skeptic (risks), Creative (alternatives)
  • For code: Senior Engineer (architecture), QA Engineer (edge cases), Code Reviewer (readability/standards), Performance Engineer (optimization)
  • For text: Editor (structure/clarity), SEO (keywords/readability), Reader (is it clear from scratch), Subject-matter expert (fact-checking)
• {number_of_points} — usually 3-5, more for complex tasks

🚀 Quick start — paste this into the chat:

Here is a Multi-Agent Reflexion (MAR) template: a technique of debate between critics for deep analysis.

Adapt it to my task: {describe your task}.

Ask me questions: which critic personas this task needs (given its specifics), how many debate rounds, and what the judge should focus on during synthesis.

[paste the template above]

The LLM will ask about the specifics of the task and the critic roles you need, because a business decision needs one set of personas (finance lead/marketer), code needs another (Senior Engineer/QA), and text needs a third (editor/reader). It will take the "debate → synthesis → revision" structure from the template and slot in personas for your task.

⚠️ Token cost: One MAR cycle = roughly 3x more tokens than regular Reflexion (which is already 2x pricier than a basic prompt). Every failure triggers 4 critics + a debate + a judge + a retry. On complex tasks with several iterations that's hundreds of thousands of tokens. It's for important decisions, not routine work.

⚠️ Overkill for simple tasks: If the question can be handled in one pass (e.g. "rephrase this paragraph" or "find the bug in these 5 lines of code"), you don't need a critics' debate. A basic prompt will be faster and cheaper.

⚠️ Sensitive to how personas are worded: If the critic roles are too similar (e.g. they all "check the logic"), the debate degenerates into rephrasing the same thoughts. You need clearly contrasting focuses: numbers vs risks, facts vs alternatives, rigor vs creativity.

⚠️ Multiple requests: MAR is a workflow of 4-6 prompts, not a one-shot. You have to pass outputs between steps manually (or via a script if you have API access). For people used to "one question = one answer", this can feel unfamiliar.

The researchers took the original Reflexion (where a single agent checks itself and draws conclusions) and reproduced it on two benchmarks: HotPotQA (multi-hop Wikipedia questions where you need to connect facts from different documents) and HumanEval (Python code generation to a spec with unit tests). They used GPT-3.5-Turbo for all roles to isolate the effect of multi-agency from model strength.

They reproduced the problem: In the Reflexion logs they saw systematic looping. Examples: - In HumanEval the model would write a bug (say, an off-by-one in a loop) → write a reflection "need to check the boundaries" → write the same bug again. - In HotPotQA the model would take a wrong logical step → critique itself → repeat the same logic in different words.

This is called degeneration of thought: the model can't get out of its rut because the actor, the evaluator and the reflector are all the same system.

They added multi-agency: They replaced the single reflector with 4 critic personas with clearly contrasting focuses. For HotPotQA: Verifier (demands facts), Skeptic (looks for holes), Logician (strict about the metric), Creative (alternatives). For HumanEval: roles from a real software lifecycle (Senior Engineer, QA, Code Reviewer, Performance Engineer). The critics argue for 1-2 rounds, the judge synthesizes → the reflection goes to the actor.

The size of the gain on code was surprising: On HotPotQA the improvement was modest: 44% → 47% Exact Match (3 points). But on HumanEval it was 76.4% → 82.6% pass@1 (6.2 points). That's significant, given that base GPT-3.5 scores 67% and GPT-4 scores 81.7%. In other words, MAR on a weak model beat a strong model without reflection.

Why did HotPotQA gain less? The researchers dug deeper and found that Exact Match (EM) is too strict a metric. It counts an answer as wrong if there's an extra space, a synonym instead of the exact word, or a changed order of elements. In the logs they found cases where MAR gave a semantically correct answer (e.g. "Smith, John" instead of "John Smith", or "the capital of France is Paris" instead of just "Paris"), but EM marked it as a failure. The model received a false negative signal and swapped a correct answer for a wrong one. It's like studying for an exam where the right solution is marked wrong because of a typo: you start doubting logic that was actually correct.

Practical insight: Multi-agent reflection is especially strong on tasks with precise verification (code, math, logic), where feedback is unambiguous. On tasks with subjective/imprecise evaluation (like HotPotQA with EM) the effect gets diluted because the model receives a noisy signal. If you want to use MAR for text or business decisions, the success criterion has to be clear-cut.

🔧 Technique: Specific names instead of roles → sharper criticism

Instead of abstract "Skeptic" and "Creative", give the critics recognizable names or brands. For business decisions: "Mark Cuban (risks and brutal honesty)" and "Jony Ive (aesthetics and UX)". For marketing: "a performance marketer from Google" and "a brand strategist from BBDO". The model plays the role more sharply when it has a concrete reference.

Sample fragment:

**Mark Cuban** (risks/finance): Tear the unit economics apart. Where are the hidden pitfalls? What kills this business in the first 3 months?

**Jony Ive** (aesthetics/UX): Assess the visuals and the customer experience. Does it look cheap? Why should a customer pick this over a competitor?

It works because the model has these figures' thinking patterns from its training data and generates criticism in their style.

🔧 Technique: Dynamic persona selection → token savings

Don't launch all the critics at once. First have a single triage persona assess the type of error, then run only the relevant critics.

Sample prompt:

The actor gave this answer: "{answer}".

You are the triage persona. Identify the type of error:
- Logical (wrong conclusions) → needs Logician + Skeptic
- Factual (wrong data) → needs Verifier + Expert
- Creative (narrow approach) → needs Creative + Alternatives Seeker

Which 2 critics should we run?

Then you run only the selected roles. This halves token usage while keeping quality.

🔧 Technique: Asynchronous debate → sequential criticism

Instead of a simultaneous debate (all critics answer in parallel, then argue), use a chain: the first critic analyzes the actor's failure, the second critiques the first, the third critiques both, and the judge synthesizes.

Example:

# Round 1: The Logician analyzes the actor's answer
[Logician's output]

# Round 2: The Skeptic critiques the Logician
Here is the Logician's analysis: "{analysis}".
Where might they be wrong? What did they miss?

# Round 3: The Creative proposes an alternative
Here is the Skeptic's critique: "{critique}".
What fundamentally different approach could work?

# Round 4: Judge
Synthesize the chain: Logician's analysis → Skeptic's critique → Creative's alternative.

Pro: each critic sees the previous ones' thinking, so the criticism becomes cumulative. Con: more steps, takes longer.

MAR: Multi-Agent Reflexion Improves Reasoning Abilities in LLMs
Onat Ozer, Grace Wu, Yuchen Wang, Daniel Dosti, Honghao Zhang, Vivi De La Rue
University of Michigan

Repository: https://github.com/danpro1011/reflexion

Related work: - Reflexion (Shinn et al. 2023) — the original self-critique framework - Multi-Agent Debate (Du et al. 2023, Liang et al. 2023) — structured debates between agents - Chain-of-Thought (Wei et al. 2022) — step-by-step reasoning - ReAct (Yao et al. 2022) — reasoning + acting in an environment