Agent-Guided Process Verification for Mathematical Self-Correction

Rui Zou, Mengqi Wei, Xin Zhao, Ji-Rong WenarXiv 2026 · arXiv

TL;DR

Researchers have developed Agent-Guided Process Verification (AGPV), a multi-agent framework that allows Large Language Models (LLMs) to self-correct mathematical reasoning by decomposing solutions into verifiable "key claims." By stopping at the first detected error and using a symbolic mathematical toolbox for verification, AGPV achieves a 13.5% accuracy boost over state-of-the-art baselines and uniquely identifies "completeness" errors, such as missing roots in an equation.

What Problem Does This Paper Address?

LLMs have become surprisingly good at math, but they suffer from two major "Achilles' heels" in complex, multi-step reasoning:

  1. The Domino Effect: A single logical slip in step two propagates through the entire solution. Current "self-reflection" methods often ask the model to look at the whole thing and "find the error," which usually leads to vague feedback or unnecessary, wholesale rewriting of perfectly good steps.
  2. The Omission Trap: Most verifiers check if the provided answer is correct (outcome verification). However, they often fail to notice if the solution is incomplete. For example, if a problem asks for all real roots of $x^2 = 4$ and the model only finds $\{2\}$, an outcome verifier might see that $2$ is indeed a root and mark it "pass," missing the fact that $\{-2\}$ is absent.

Methods

The authors introduce AGPV, a structured pipeline that treats mathematical correction as a surgical operation rather than a rewrite. The workflow involves several specialized agents:

  • Key Claim Decomposition: Instead of checking raw "steps," a generation agent parses the solution into an ordered sequence of key claims—independently verifiable mathematical propositions.
  • Sequential Verification & The "First Error" Rule: A verification agent checks these claims one by one. Crucially, it stops the moment it hits the first failure. This prevents the model from trying to "fix" subsequent steps that were only wrong because they relied on an earlier error.
  • The Mathematical Toolbox: To ensure verification is reliable, the agents can invoke a shared toolbox containing symbolic solvers (SymPy), SMT solvers (Z3), and Python execution.
  • Diagnosis & Localized Correction: A summarization agent turns the failure evidence into a precise diagnosis. A correction agent then re-derives the solution starting only from that specific point.
  • Completeness Verification: AGPV explicitly generates claims to check if all necessary branches or solutions have been covered, integrating completeness directly into the process-verification chain.

Datasets

The framework was evaluated on 170 problems from five high-difficulty "hard-test" competition math datasets:

  • AIME 2024 & 2025 (American Invitational Mathematics Examination)
  • BRUMO 2025
  • HMMT February 2025 (Harvard-MIT Mathematics Tournament)
  • AMO Bench (Advanced Math Olympiad)

These datasets are significantly more challenging than standard benchmarks like GSM8K, requiring deep integrated reasoning across algebra, geometry, and number theory.

Key Insights and Ideas

  • Surgical vs. Holistic Correction: The "aha moment" here is that providing the exact location of the first error is more effective than providing general feedback. It prevents "unfocused rewriting" where a model might accidentally break a correct part of the solution while trying to fix a wrong one.
  • Completeness as a Verifiable Claim: By treating "have we found all solutions?" as a claim that requires exhaustive enumeration or constraint checking, the authors move beyond simple correctness to ensure total solution coverage.
  • Conditional Reliability Proof: The authors provide a theoretical proof showing that if the key claims provide sufficient coverage and the local verification is reliable, AGPV guarantees both the correctness and completeness of the final answer.
  • Context Compression: To handle long reasoning chains, the system uses a compression agent to summarize older working context while retaining key computations and tool results, keeping the "working memory" efficient.

Key Results

AGPV was tested across four backbone models: DeepSeek-V4.1-Flash, DeepSeek-V4-Pro, Qwen3.6-35B, and GPT-5.6-Luna.

  • Accuracy Boost: AGPV achieved an average accuracy of 63.8%, outperforming the strongest baseline (Self-Refine at 50.3%) by 13.5 percentage points.
  • Repair Coverage: AGPV repaired 152 initially incorrect answers while only "damaging" (turning a correct answer into an incorrect one) 5. This is a significantly better ratio than baselines like CoT-Tool, which damaged 18 answers for every few it fixed.
  • Difficulty Scaling: The gains were most pronounced on "Very Hard" problems (those solved by 0 or 1 model at initialization), where AGPV showed an absolute gain of 28.0% over the initial scores.

Limitations and Future Work

  • Extraction Dependency: The system's success relies heavily on the generation agent's ability to extract all necessary key claims. If a critical logical leap is skipped in the decomposition, the error might go undetected.
  • Computational Cost: AGPV is token-heavy. On DeepSeek Flash, it used ~89k tokens per problem compared to ~36k for simpler self-refinement. While more accurate, it is more expensive.
  • Domain Specificity: Currently optimized for mathematics, the authors suggest future work should extend this "traceable intermediate process" verification to code generation, scientific reasoning, and data analysis.
  • Not a Formal Prover: While it uses symbolic tools, AGPV is still an agent-based system, not a formal proof checker like Lean or Coq; it can still be misled if the "toolbox" results are misinterpreted by the LLM.

Summary updated

Abstract

Large language models have made substantial progress in mathematical reasoning, yet in complex multi-step reasoning, an error at any step may propagate along an incorrect path, and the resulting solution may omit necessary branches. Existing natural-language reflection methods often struggle to locate critical errors precisely, while outcome verification typically checks only whether the available candidate answers satisfy the problem conditions and can therefore overlook necessary branches. To address these limitations, we propose Agent-Guided Process Verification (AGPV) for mathematical self-correction. AGPV decomposes the current solution into an ordered sequence of key claims, verifies them individually while invoking a shared mathematical toolbox when needed, and stops upon detecting the first error. A summarization agent converts the failure evidence into a diagnosis that guides a correction agent to re-derive the subsequent solution from that point; AGPV then adapts the next verification iteration to the revised solution. AGPV also verifies solution completeness. We further prove that AGPV guarantees solution correctness and completeness when key claims provide sufficient coverage and local verification is reliable, provided that all key claims pass verification. The implementation compresses long working contexts and reuses successful tool results within each problem. We evaluate AGPV on five challenging mathematical reasoning datasets with four models from DeepSeek, Qwen, and GPT. AGPV achieves an average accuracy of 63.8%, outperforming the strongest among the representative baselines evaluated (50.3%) by 13.5 percentage points, with higher repair coverage than the programmatic-verification baselines.
BibTeX
@misc{zou2026agent,
  author = {Rui Zou and Mengqi Wei and Xin Zhao and Ji-Rong Wen},
  title = {{Agent-Guided Process Verification for Mathematical Self-Correction}},
  year = {2026},
  eprint = {2611.19122},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.19122},
}

Loading related content...

Figure