1 Introduction↩︎

Recent advances in large language models (LLMs) have brought revolutionary changes to the field of natural language processing and understanding [1]–[4]. With their unprecedented performance on language generation tasks such as chat completion, question answering, and code generation, these models are expected to extend their impact to more general and challenging real-world applications, including knowledge-intensive reasoning. However, when it comes to problems involving deep factual knowledge and complex structures, their reasoning abilities still remain limited [5], [6]. For instance, many state-of-the-art models can only achieve about 30% - 40% accuracy on the GPQA benchmark.

To enhance reasoning during inference, several prompting techniques have been proposed, including Chain-of-Thought (CoT) [7], Tree-of-Thought (ToT) [8], and self-reflection [9]. While these approaches significantly improve LLM performance, they operate in a single-agent setting, where the model lacks external feedback and often fails to correct its own mistakes. Motivated by this limitation, recent works have explored multi-agent collaboration, in which agents provide feedback to each other to enhance reasoning. Among these, the Multi-Agent Debate (MAD) framework [10] is the most widely adopted: multiple agents are recruited to tackle the same problem, exchange responses, and refine their answers by considering disagreements, with the final solution derived via majority voting after a round-table discussion.

Despite MAD achieving a significantly improved performance in reasoning, a key drawback is its high resource cost: both token consumption and inference time increase substantially compared to single-agent systems, due to intensive communication among agents. This raises a fundamental question: Can we reduce resource consumption while preserving the response quality of multi-agent reasoning?

To address this challenge, we draw inspiration from two sources: verifier-based architectures and the hierarchical evaluation structure of peer review. On one hand, recent studies on agent tuning with synthesized trajectories incorporate verifiers or critics as key components [11]–[13]. These verifiers, either rule-based or LLM-based, check and filter low-quality trajectories or intermediate results, underscoring the importance of systematic review and quality control. On the other hand, peer review practices demonstrate the effectiveness of hierarchical evaluation: authors (or agents) refine their work based on structured feedback, while final decisions are reached through systematic aggregation. Unlike the round-table discussion in MAD, where agents communicate freely, peer review emphasizes independence: reviewers provide evaluations without direct interaction, yet the process reliably converges to fair and consistent outcomes.

Based on these considerations, we propose Multi-Agent Review System (MARS) for LLM reasoning, in which agents take on the roles of author, reviewers, and meta-reviewer to mimic a structured review process. Given a user query, the author agent first generates an initial response. Instead of producing their own answers from scratch, reviewer agents evaluate this response, focusing on identifying potential errors. Different to the round-table discussion in MAD, where agents engage in frequent communication, reviewers in MARS operate independently, each providing a decision, review comments, and a confidence score. The meta-reviewer then aggregates these evaluations and issues a final judgment with justification: if the decision is accept, the author’s initial response is adopted as the final answer; if the decision is reject, the meta-reviewer generates feedback to guide the author’s revision. By structuring collaboration around independent review and feedback, MARS matches the reasoning quality of MAD while consuming substantially fewer tokens and requiring less inference time.

We conducted a series of experiments on three commonly utilized reasoning benchmarks, using both closed-source LLMs (e.g., ChatGPT) and open-source models. With the same number of agents, MARS consistently reduced the resource usage while keeping the accuracy comparable to MAD across all datasets (Table 1). For example, the token consumption of GPT-4o-mini on GPQA is reduced from 17083 to 7903 per query, while achieving a slightly higher accuracy. These results demonstrated both the effectiveness and efficacy of the MARS framework. In summary, this work has the following major contributions:

• We propose MARS, a role-based multi-agent framework by following a hierarchical evaluation process to increase the computational efficiency and preserve the performance of multi-agent reasoning.

• Experiments on multiple benchmarks validated that MARS matches the accuracy of the SOTA method MAD while reducing token usage by \(\sim\)​50% when implementing with different LLMs.

• We conduct a comprehensive analysis of multi-agent reasoning dynamics, revealing critical insights into how scaling the number of agents, deploying heterogeneous LLMs across specific roles, and enforcing reviewer personas impact overall system performance.

2 Related Work↩︎

LLM Reasoning. The reasoning capability of LLMs has become a research focus in recent years, with various methods proposed at both the training and inference stages. Prompting-based approaches, such as CoT[7], ToT[8], and self-reflection[9], introduce structured pipelines to guide the model to decompose the problem and think step-by-step before generating the final answer. These methods are more straightforward and efficient, but the effectiveness is limited by the model’s inherent reasoning ability. In parallel, there are also advanced reasoning models or agents which are finetuned with reasoning trajectories[12], [14], [15]. These models come with reasoning and tool usage abilities naturally, but will require more computational resource for model training.

Multi-agent Collaboration. A single agent’s capability is often insufficient for problems that require complex reasoning and specialized knowledge. Recent research also revealed that LLMs tend to adhere to their initial answers and struggle to identify and correct their own mistakes without external information. To address this, many studies have started to explore the collaborative behaviors of multiple agents. MAD is the most prominent framework in this line[10], [16], [17], where multiple agents work on the same problem through round-table discussion, iteratively exchanging responses and refining their answers by leveraging the feedback from others. While effective in improving reasoning, MAD introduces substantial computational overhead: both token consumption and inference time grow rapidly with the number of agents and communication rounds, making it costly for practical deployment.

Answer Verification. Many finetuning methods for LLM agents rely on synthetic reasoning and tool usage trajectories[11], [18]–[20]. To ensure the quality of the structure, intermediate steps, and final results of the trajectories, recent works have designed various verifiers for quality control. These verifiers are either rule-based modules with human-defined principles, or LLM-based utilizing the inherent error-detection and evaluation abilities of large models. Unlike primary agents, verifiers are not required to generate full answers to user queries; instead, they specialize in detecting mistakes in reasoning steps and final results. The effectiveness of this design in improving reliability has been demonstrated in various agent systems. In our framework, reviewer agents serve a similar role: they provide independent decisions, comments, and suggestions, offering the author agent clearer and more explicit feedback to guide revisions of its initial response.

3 Methodology↩︎

3.1 Overview↩︎

In this section, we introduce the MARS framework, which is designed for reducing resource demands in multi-agent systems. We begin with the problem formulation, then describe the roles assigned to different agents, and finally outline the architecture and mechanisms of how the MARS framework works for complex reasoning tasks.

Problem Formulation. For a given reasoning task, let \(x_i\) denote the input prompt (original problem description wrapped by our prompting templates), and let \(y_i\) denote the model’s response containing the final answer. Different from MAD where multiple agents are equivalent to each other, MARS adopts a role-based design. LLMs are employed to play three distinct roles, namely author, who generates initial responses, reviewer, who generates evaluation on the author’s output, and meta-reviewer, who integrates reviewers’ comments and provides feedback for the author. We use \(\mathcal{A}\) to denote the author agent, \(\mathcal{R}_j, j=1,2,...,m\) to denote the reviewer agents, and \(\mathcal{M}\) to denote the meta-reviewer agent, respectively.

3.2 MARS Framework↩︎

The MARS framework implements a structured, role-based collaboration among agents to improve both reasoning accuracy and efficiency (Figure 1). Given a user query, the author agent generates an initial response. This output is then independently evaluated by multiple reviewer agents, each producing a decision, explanatory comments, and a confidence score without interacting with each other. A meta-reviewer agent aggregates these reviews to issue a judgment and, when necessary, provides targeted feedback to guide the author’s revision. This hierarchical evaluation and feedback loop enables efficient parallel review while enhancing robustness through systematic error detection and correction. The details of each component and step are provided below (a summary of the procedures is available in Algorithm 5).

Author’s initial response. For an input prompt \(x_i\), the author agent generates an initial response containing both the reasoning trajectory and the final answer. To make the subsequent review process verifiable, we adopt the Chain-of-Thought (CoT) paradigm, requiring the author to output explicit intermediate reasoning steps alongside the final answer (see Appendix 10.1.1 for the prompt template). Mathematically, this step can be presented as a function: \[\label{eq95author} t_i, y_i = \mathcal{A}(x_i)\tag{1}\] where \(t_i\) denotes the sequence of reasoning steps and \(y_i\) denotes the final answer.

Reviewer’s evaluation. After the author produces an initial response, the review stage begins with \(m\) reviewer agents, denoted \(\mathcal{R}_1, \mathcal{R}_2, \ldots, \mathcal{R}_m\). Each reviewer receives the author’s output as input and generates a review comprising: (i) a binary decision (accept or reject), (ii) a confidence score, and (iii) textual justification. If the decision is reject, the justification must explicitly identify errors in either the intermediate reasoning steps or the final prediction (see Appendix 10.1.2 for the prompt template). The review process of the \(j\)-th reviewer for the input \(x_i\) can be mathematically presented as a function: \[\label{eq95review} r_{ij} = \mathcal{R}_j(x_i, t_i, y_i), \quad j=1,2,...,m\tag{2}\]

Meta-review and feedback. Unlike the normal peer review process, we do not incorporate direct feedback from the reviewers to the author after the review stage. Instead, a meta-reviewer agent consolidates reviewer feedback, makes decisions, and communicates with the author. This design is driven by two factors: (1) Efficiency — a direct discussion between reviewers and the author would substantially increase token usage and inference time, reducing reasoning efficiency; (2) Role simplification — Exposing the author to multiple, potentially redundant or conflicting comments would impose extra decision-making, such as filtering overlapping feedback or resolving disagreements, which could distract it from revising the response. We consider that by centralizing feedback integration in the meta-reviewer, the author remains focused on updating their answer, thereby maintaining reasoning quality.

The meta-reviewer processes all reviewer outputs, summarizes comments, resolves conflicts or redundancies, and issues a final decision. If the decision is accepted, the author’s initial response is adopted as the final response. If the decision is rejected, the meta-reviewer provides explicit feedback to the author, including (i) the reasons for rejection (e.g., errors in the reasoning path) and (ii) concrete suggestions for improvement (see Appendix 10.1.4 for the prompt template). This meta-reviewer can be mathematically presented as a function: \[\label{eq95meta} m_i = \mathcal{M}(x_i, t_i, y_i, r_i)\tag{3}\] , where \(m_i\) denotes the meta-reviewer’s output, and \(r_i\) is a concatenation of all the reviewer outputs, \(r_i = r_{i1} \oplus r_{i2} \oplus ... \oplus r_{im}\)

Rebuttal stage. After the meta-review stage, a final decision is issued regarding the author’s initial response. If the decision is rejected, the author agent is required to revise the solution by leveraging both its reasoning history and the meta-reviewer’s feedback. Concretely, the author agent will review its step-by-step thoughts \(t_i\) and incorporate the meta-reviewer’s suggestions to identify and correct errors (see Appendix 10.1.5 for the prompt template). Once all steps have been re-examined, the author agent produces an updated answer \(y_i^*\). This process can be formulated as: \[\label{eq95rebuttal} y_i^* = \mathcal{A}(t_i, y_i, m_i)\tag{4}\] Upon generating \(y_i^*\), the updated response is fed back into the review stage. This iterative cycle of review and revision continues until the meta-reviewer issues an accepted decision or a pre-defined maximum number of iterations \(K\) is reached (see Algorithm 5).

3.3 Calibration of Reviewer Confidence↩︎

Reviewers may occasionally make reasoning errors, leading to divergent decisions and uncertainties at the review stage. To assist the meta-reviewer in accurately weighing these evaluations, it is essential to quantify reviewer confidence. As detailed previously, our framework prompts each reviewer to output a verbalized confidence score alongside their decision and justification. However, recent studies demonstrate that LLMs frequently exhibit significant overconfidence when relying on vanilla verbalized confidence elicited via prompting [21].

Conversely, research indicates that the probability distribution of output tokens intrinsically reflects a model’s underlying uncertainty. Building on this insight, we propose utilizing the token-level probability distribution of the reviewers’ responses for confidence calibration. Specifically, for a response \(r_{ij}\) generated by the \(j\)-th reviewer for the \(i\)-th query, consisting of \(N\) tokens \(\{t_1, t_2, \dots, t_N\}\), we first compute the average log probability of the generated sequence: \[\text{AvgLogProb}_{ij} = \frac{1}{N} \sum_{k=1}^{N} \log P(t_k)\]

A higher average log probability (closer to 0) indicates greater model certainty. To convert this into a normalized confidence score bounded between 0 and 1, we exponentiate the average log probability: \[Conf_{ij} = \exp(\text{AvgLogProb}_{ij})\]

In practice, this sequence-level probability calibrates the initial confidence level of each reviewer. This refined metric is then propagated to the meta-reviewer via the prompt template (10.1.3), providing a statistically grounded indicator of whether a given reviewer’s feedback is reliable.

4 Experiments↩︎

4.1 Setup↩︎

Benchmarks. We evaluate MARS on three commonly utilized reasoning benchmarking sets: (1) MMLU [22] consists of multiple-choice questions across diverse academic subjects such as elementary mathematics, history, computer science, and law; (2) GPQA [23] is a graduate-level QA dataset spanning biology, physics, and chemistry, which is of high-quality and even challenging for domain experts, making it a strong test of reasoning ability; (3) GSM8K [24] is a math word problem dataset that evaluates grade school level mathematical reasoning.

Models and baselines. We use both closed-source (GPT-3.5-turbo, GPT-4o-mini) and open-source (Mixtral-8\(\times\)​7b, Mixtral-8\(\times\)​22b, Llama3.3-70b) models as agent backbones. The open-source model is accessed through NVIDIA NIM platform via API calls. We compare MARS against several single-agent and multi-agent baselines, including Chain-of-Thought (CoT) [7], Self-reflection [9], Self-consistency [25], Multi-agent Debate (MAD) [10], and Diverse Multi-agent Debate (DMAD) [26]. Detailed introductions and experimental settings of the baselines, as well as their corresponding prompts are available in Appendix 8 and Appendix 10.

Metrics. Prior work primarily assessed reasoning methods by the accuracy of the final answer, where MAD has demonstrated strong performance. In contrast, MARS is designed to improve computational efficiency in LLM-based reasoning, with success defined by achieving accuracy comparable to MAD while substantially reducing resource consumption. Accordingly, we evaluate methods based on the integration of three metrics: (i) final-answer accuracy, (ii) average number of tokens generated per query, and (iii) average inference time (seconds) per query.

4.2 Main Results↩︎

The primary experimental results across all models and datasets are summarized in Table 1. We highlight the following key observations:

(1) Accuracy. MAD and MARS consistently rank among the top two methods in final-answer accuracy, outperforming all of the other baselines under most settings. With the expanded evaluation across five diverse LLMs, MARS demonstrates superior or highly competitive performance. Their relative advantage depends on the backbone model and task: for example, on GSM8K with GPT-3.5, MAD reaches 79.00% accuracy versus 75.67% for MARS. However, MARS outperforms MAD on the remaining four models for the same task, including achieving 90.33% with Mixtral 8x22b (compared to MAD’s 87.00%). Furthermore, MARS secures the highest accuracy on the challenging GPQA dataset with advanced models like GPT-4o-mini (48.33%) and Llama3-70b (60.00%). Overall, MARS achieves comparable or superior accuracy to MAD across an extensive array of state-of-the-art models and complex tasks.

(2) Token consumption. Although both MAD and MARS achieve high accuracy across reasoning tasks, their multi-agent design naturally requires higher token usage compared to single-agent baselines. Notably, MARS consistently reduces the average number of tokens per query by roughly 50% relative to MAD, a scaling advantage that holds true across all tested models. For instance, on the GPQA benchmark with GPT-4o-mini, MAD consumes an average of 17,083 tokens per query, whereas MARS requires only 7,903 tokens. Given that MARS achieves comparable or better accuracy, this demonstrates that the framework makes the multi-agent collaboration paradigm substantially more efficient and practical for large-scale deployment while preserving response quality.

(3) Inference time. Another critical aspect of a reasoning strategy is inference time, particularly for interactive applications such as ChatGPT. As shown in Table 4, MARS reduces inference time by more than 30% compared to MAD, enabling more responsive user interactions and more scalable large-scale experimentation.

Our results reveal a key limitation of prior MAD-inspired strategies: their gains in reasoning quality come with prohibitive computational overhead. MARS fills this efficiency gap to a certain level, reducing token usage and inference time by about 50% while preserving accuracy. This advance makes multi-agent reasoning not only more effective but also practical for large-scale and real-time applications. Figure 2 visualizes this efficiency gain, highlighting the favorable trade-off MARS achieves between accuracy and token consumption relative to self-consistency and MAD.

4.3 Additional Analysis↩︎

4.3.1 Scalability↩︎

In this section, we evaluate the scalability of MARS versus MAD to further demonstrate the efficiency advantage of MARS. Figure 3 presents their performance across different backbone models and varying numbers of agents. From the left column of Figure 3, we observe that the accuracy of both methods generally increases as the number of agents grows, consistent with prior findings that collaborative reasoning benefits from larger agent pools. This trend suggests that scaling the number of agents can enhance reasoning performance in multi-agent frameworks. Noted, MAD employs a fully connected communication structure that causes computational cost per query to grow rapidly as the number of agents increases. As shown in the right column of Figure 3, both token usage and inference time grow sharply with additional debaters, severely limiting scalability. In contrast, MARS avoids this bottleneck by designing the parallel reviewer to generate independent evaluations and a meta-reviewer agent to aggregate reviews. This structure enables MARS to improve reasoning efficiency while maintaining performance, with token consumption and inference time growing linearly with the number of reviewers.

4.3.2 Evaluating Different Mixtures of Models↩︎

In this section, we evaluate how utilizing heterogeneous backbone models impacts reasoning outcomes. While our primary experiments deployed the same LLM across all agent roles, recent studies suggest that mixing different models can introduce complementary analytical perspectives. To explore this, we tested various combinations of GPT-3.5-turbo and Mixtral 8x22b within the MARS framework on the GPQA benchmark. As shown in Table 2, three key observations emerge: (1) Stronger auxiliary agents elevate performance. For a GPT author, integrating the more capable Mixtral model into the reviewer or meta-reviewer roles consistently improves the final score, scaling from 35.33 up to 39.00. (2) The author’s inherent capacity bounds the system. Despite the assistance of strong Mixtral reviewers and meta-reviewers, a GPT author (maximum 39.00) cannot match the baseline performance of a Mixtral author (minimum 41.67). The author agent ultimately dictates the overall performance ceiling. (3) Model diversity yields unexpected synergies. The highest overall accuracy (46.40) is achieved when Mixtral serves as the author, but GPT acts as both the reviewers and the meta-reviewer. This configuration even surpasses all-Mixtral settings, indicating that injecting diverse reasoning styles during the review phase is a non-trivial factor that warrants further investigation.

4.3.3 Effect of reviewer personas↩︎

Recent work suggests that assigning distinct personas to agents can improve performance by promoting diversity. Motivated by this, we explored whether diversifying reviewers through predefined personas could enhance feedback quality and overall reasoning performance. In this variant, namely MARS-P, reviewers were instructed to adopt specific roles (e.g., conservative vs. aggressive; see Appendix 10.3 for prompt details) when evaluating the author’s response.

Surprisingly, as shown in Table 3, introducing personas did not yield improvements across tasks (except a marginal improvement on MMLU). Analysis of the review content suggests two main factors: (i) the inherent randomness of LLMs already provides a degree of diversity in reviewer feedback, and persona prompts did not add significant variance; and (ii) when the author’s response is correct, aggressive reviewers often generate unnecessarily critical or noisy feedback, which can confuse the meta-reviewer and cause over-corrections. These results indicate that relying on the model’s natural variability might be more effective than enforcing artificial personas.

10pt

4.4 Case Study↩︎

To illustrate how MARS operates, we present a case study from the GSM dataset that demonstrates the framework’s step-by-step reasoning process (Figure 4; additional examples appear in Appendix 12). The problem describes four dogs, where the first weighs 10 pounds, and each subsequent dog weighs a constant multiple of the previous one. The task is to determine the weight of the fourth dog.

The author agent began by denoting the first dog’s weight as \(A\) and correctly deriving that the fourth weight should be \(22A\). However, it mistakenly recomputed \(A\) as \(5/11\), which contradicts the given information and led to an incorrect final answer. During the review phase, Reviewer 1 successfully identified this error and explicitly flagged the inconsistency; Reviewer 2 also rejected the author’s answer but failed to provide a clear justification. At the meta-review stage, the meta-reviewer integrated these signals, recognized the erroneous recomputation of \(A\), and instructed the author to recalculate using the correct initial weight. Incorporating this feedback, the author substituted \(A = 10\) pounds and derived the correct result of \(22A = 220\) pounds.

We highlight three insights from this case: (1) Error propagation in long reasoning chains. For tasks requiring multiple reasoning steps (seven in this example), even a minor mistake can cascade into an incorrect final answer, underscoring the importance of intermediate verifications for the reasoning process. (2) Reviewer contributions. Reviewers in MARS can identify errors in the reasoning chain and provide detailed feedback to guide answer revision. While not all reviewers generate high-quality comments, this variability suggests potential benefits from involving multiple reviewers. (3) Effectiveness of MARS. By incorporating external feedback rather than relying solely on self-correction, MARS overcomes limitations of single-agent reasoning and improves final accuracy without incurring excessive computational cost.

5 Conclusion↩︎

In this work, we introduced MARS (Multi-Agent Review System), a framework that enables efficient collaboration among LLMs through a propose–review–feedback–update architecture. MARS addresses the limitations of self-reflection in single-agent settings, improves reasoning quality, and avoids the heavy computational overhead of debate-based approaches. Extensive experiments across diverse benchmarks and models demonstrate that MARS consistently outperforms strong baselines and achieves the same level of accuracy with Multi-Agent Debate, while substantially reducing resource consumption. These results suggest that direct communication among all agents is unnecessary for effective collaboration, and that review-style architectures offer a promising new paradigm for efficient multi-agent reasoning. Limitations and future work are discussed in Appendix 6.

6 Limitations↩︎

Although MARS achieved strong performance in both accuracy and efficiency, there are still several challenges remaining to be solved. (1) Confidence estimation. The reviewer agents output a confidence score, which helps the meta-reviewer to estimate the reliability of the review comments. In this paper, the confidence score is calibrated by a token probability-based uncertainty estimation. However, LLM uncertainty estimation is not yet a definitively solved problem, and incorporating more advanced calibration methods from recent studies remains a promising direction for future work. (2) Over-correction. In MARS, the decision and suggestions of meta-reviewer will highly influence the final answer, especially when the meta-decision is reject. One potential issue is that a correct initial response may be overturned if the meta-reviewer provides negative feedback, guiding the author to a wrong direction. Although we attempted to mitigate this by curating the feedback prompt template (the author is asked to insist on its initial answer when disagreeing with the meta-reviewer), we cannot guarantee to avoid it in our current setting. Future work should include how to design more effective mechanisms to prevent unnecessary revisions. (3) Additionally, our current experiments constrain the maximum number of revision / debate rounds to two for both MARS and MAD due to computational resource and time limits. Systematically investigating the impact of additional interaction rounds on both reasoning performance and token consumption remains an important direction for future work.

7 MARS Algorithm↩︎

The standard workflow of MARS is shown in Figure 5.

8 Baselines and Experiment Details↩︎

We compare MARS against the following baselines:

• Chain-of-Thought (CoT). All models in our experiments are enabled with CoT, which prompts step-by-step reasoning and serves as the most basic baseline.

• Self-reflection. This is a single-agent approach in which the model is prompted to evaluate and revise its own response.

• Self-consistency. This approach exploits the inherent stochasticity of LLMs by sampling multiple reasoning paths for the same query and aggregating them through majority voting to produce the final answer.

• Multi-agent Debate (MAD) is a framework in which multiple agents engage in a round-table discussion, with each agent generating an answer by combining its own reasoning with the responses of others. All agents play equivalent roles in this process.

• Diverse Multi-agent Debate (DMAD) is a recent variant of the MAD framework. Unlike traditional MAD, where all agents uniformly employ Chain-of-Thought (CoT) reasoning, DMAD assigns distinct reasoning strategies to different agents to explicitly foster cognitive diversity.

In our experiments, we followed the standard manner of CoT by asking the model to think about the user query step-by-step. For a fair comparison, we adopt a consistent prompt design: all methods use CoT prompting for the initial reasoning process. For example, the initial reasoning step in self-reflection and each reasoning path in self-consistency share the same CoT prompt template. Reflection, debate, review, and feedback methods require distinct prompt styles due to their structural differences. Detailed prompt templates are provided in Appendix 10.

We used the standard OpenAI SDK for API calls of all the models used in this work. All of the parameters are set as their default values. For fair comparison, we use the same number of agents in MARS and MAD. Both methods will run one update round after the initial round. While MARS is naturally extendable to multiple rounds of review and revision, we leave a systematic study of this setting to future work due to time and cost constraints.

For each dataset, we randomly sample 100 problems in each experiment, and report the averaged performance after 3 runs.

9 Additional Experimental Results↩︎

The averaged inference time per query of MARS and the compared baselines are shown in Table 4.

10 Prompt Templates↩︎

In this section, we provide prompt templates for all the methods used in this paper, including both MARS and the compared baselines.

10.1 Prompt Templates for MARS↩︎

10.1.1 Author Agent↩︎

The author agent is prompted to give its initial response using chain-of-thoughts. The following prompt shows that the author receives the user query, generates intermediate thoughts on the problem, and then the final answer. Specifically, the answer format shown here is for QA problems. When applied to math datasets, the format could be changed to

“Answer: [the final numerical answer]”
“Your final answer must be a single numerical number at the end of the response.”

You are an assistant. Please help to solve the following problem:
{user_query}

Give your thoughts about the question and the final answer in the following format:
Thoughts: [your thoughts with immediate results]
Answer: [the final single capital letter answer in the form (X). X is chosen from [A,B,C,D]]

Your final answer must be a single capital letter in the form (X) 
at the end of the response.

10.1.2 Reviewer Agent↩︎

You are an objective reviewer. The author has submitted an answer to a problem.
Your goal is to check for correctness, NOT to find faults that don't exist.

Criteria: Check for factual correctness and reasoning. Verify why the other options are wrong.

Question: {user_query}

Author's Answer: {author_response}

---
OUTPUT FORMAT:
My Independent Analysis: [Analyze the question and evaluate each option A, B, C, D]
My Selected Option: [e.g., (A)]
Comparison: [Does your option match the Author's?]
Decision: [right | wrong] (Vote 'right' if the Author's option matches yours)
Confidence: [1-5]
Justification: [Explain why the Author's reasoning is correct or incorrect]
---

10.1.3 Confidence Calibration↩︎

NOTE ON RELIABILITY SCORES:
- Each Reviewer provides a 'Reliability Score' (0.0 to 1.0) based on their internal model uncertainty.
- High Score (>0.8): The Reviewer is mathematically confident. Trust their specific calculations/facts.
- Low Score (<0.6): The Reviewer is uncertain or confused. You should be skeptical of their critique, especially if they disagree with a High-Score reviewer.

10.1.4 Meta-Reviewer Agent↩︎

You are the meta-reviewer. The author has submitted an answer.

Question: {user_query}
Answer: {author_response}

You must decide whether the answer is correct based on both your own 
knowledge and the reviewers' comments below:

--- Reviewer Feedback ---
{combined_reviews}

Do not only rely on the reviewers, you must also think by yourself.

Provide your conclusion in the following format:

Decision: [right | wrong]
Justification: [reasons of your decision]
Suggestions: [your suggestions for updating the answer, only needed
              when decision is wrong]
Answer: [your recommended answer]

10.1.5 Feedback to Author↩︎

To avoid over-correction, the author is prompted to think carefully before accepting the meta-reviewer’s suggestions. The author will only start to revise its initial answer when it strongly agrees with the meta-reviewer. After the decision is made, it will move on to update its answer following the feedback.

Your answer was reviewed and marked as incorrect by the meta-reviewer.

--- Meta-reviewer Feedback ---
{meta_decision}

If you strongly agree with the meta-reviewer's suggestions, revise your
answer accordingly. If you disagree, insist on your initial answer and 
repeat it. Do not always trust the meta-reviewer -- you must think for 
yourself whether to trust the suggestions.

Make sure to state your reasoning and final answer in this format:

Reasons: [your reasons of accepting or rejecting the suggestions]
Thoughts: [your new step-by-step thoughts on the problem after 
           considering the suggestions]
Answer: [the final single capital letter answer in the form (X). 
         X is chosen from [A,B,C,D]]

10.2 Prompt Templates for baselines↩︎

In this section, we show the prompt templates for the baselines. For a fair comparison, the same CoT template is applied to the initial input of all the techniques. Therefore, we did not include the prompts for self-consistency here since it just applies the same prompt several times. For self-reflection, we provide the prompt for the reflection step. For MAD, we provide both the prompts for the initial response and the debate process for each agent.

10.2.1 Self-Reflection Prompts↩︎

You wrote the following response to a problem:

Question: {user_query}
Answer: {response}

Carefully review your own answer. Are there any mistakes or thoughts not grounded in the given problem or known facts?
- If yes, explain the problems and revise your answer accordingly.
- If not, confirm and repeat your initial answer.

Your final response must follow this format:
Mistakes (if any):
Answer: [the final single capital letter answer in the form (X). 
         X is chosen from [A,B,C,D]]

10.2.2 Debate Prompt↩︎

You are an assistant. Please help to solve the following problem:
{user_query}

Give your thoughts about the computation steps and the final answer in the following format:
Thoughts: [your step-by-step thinking process with immediate results]
Answer: [the final single capital letter answer in the form (X). 
         X is chosen from [A,B,C,D]]

Your final answer must be a single capital letter at the end of the response.

These are the solutions to the problem from other agents:

One agent solution: ```{response_1}```
One agent solution: ```{response_2}```
...

Using the solutions from other agents as additional information, 
can you provide your final answer to the problem?

Make sure to state your thoughts and new answer with this format:
Thoughts: [your step-by-step thinking process]
Answer: [the final capital letter answer]

Your final answer must be a single capital letter at the end of the response.

10.3 Reviewer Personas↩︎

Conservative Persona

Your decision should be conservative.

Goal:
Minimize false alarms. Only label 'wrong' when there is a decisive, 
demonstrable error that changes the final answer.

Heuristics:
- Require at least TWO independent checks (e.g., recomputation + boundary/unit check) before declaring 'wrong'.
- Minor arithmetic slips that do not affect the final answer => prefer 'right' with notes in Justification.
- Missing small steps != 'wrong' if the step is standard and the result follows.

Confidence:
- 5 only if two checks agree
- 4 if one check is strong
- <=3 if any uncertainty remains

Aggressive Persona

Your decision should be aggressive.

Goal:
Minimize false acceptances. Label 'wrong' when any essential step is missing, unjustified, or numerically inconsistent.

Heuristics:
- Penalize ambiguous leaps, missing assumptions/units, and unverified claims even if the final number looks plausible.
- If any step is unsupported or contradicts problem constraints, prefer 'wrong'.
- If correct, still list at least two vulnerabilities the author should fix.

Confidence:
- 5 if multiple issues are found or if cross-checks clearly contradict
- 4 when evidence is strong but not exhaustive
- <=3 if partial doubt

11 LLM Usage Statement↩︎

Large language models (LLMs) were used solely as general-purpose assistive tools for this work. Their usage was limited to grammar checking, language polishing, and LaTeX table formatting. LLMs were not involved in research ideation, methodological design, data analysis, or substantive writing of the manuscript.

12 Additional Case Studies↩︎

6pt

6pt

References↩︎