Self-Verification in LLMs

• Self-verification in LLMs is a process where the same model iteratively generates candidate outputs and verifies their correctness for tasks such as reasoning and planning.
• Empirical studies show that self-verification often underperforms due to high false positive rates compared to external or cross-model verification methods.
• Practical recommendations favor hybrid systems that combine LLM generation with external verifiers to ensure robust accuracy and reliability in critical domains.

Self-verification-based LLMs refer to systems and algorithms where an LLM performs both the generation of candidate outputs for reasoning-intensive tasks and an explicit, model-internal process of critiquing or verifying those same outputs, often in an iterative or multi-stage fashion. This paradigm has been investigated extensively in reasoning, planning, and factual domains, using both prompt-based protocols and reinforcement learning (RL). Self-verification is motivated by the putative asymmetry between generative and verification complexity; in many domains, verifying a candidate solution is theoretically easier than generating one. Despite this, the effectiveness of self-verification in LLMs is highly nuanced, being strongly dependent on the trustworthiness of the verifier and the nature of the reasoning task.

1. Mathematical and Algorithmic Formulation

Self-verification is generally implemented as an alternation between two steps using the same LLM: (i) generation of a candidate solution or plan, and (ii) self-judgment (“verification”) of the candidate’s correctness. Formally, for a task prompt $\tau$, the process proceeds as:

• $P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$
• At iteration $k$: $$V^{(k)} \leftarrow \mathrm{LLM{.}verify}(P^{(k-1)})$$
• Update: $P^{(k)} = P^{(k-1)}$ if $V^{(k)} = \mathrm{valid}$; else $$P^{(k)} \leftarrow \mathrm{LLM{.}generate}(\tau \oplus V^{(k)})$$,
• Stop if $V^{(k)} = \mathrm{valid}$ or $k >$ budget.

This models the process as a fix-point iteration with alternating generation and verification steps, yielding a pipeline where the same LLM “back-prompts” itself (Valmeekam et al., 2023, Stechly et al., 2024).

Verification reliability is typically evaluated using a confusion matrix between the LLM’s decisions and those of an external, sound verifier (e.g., a symbolic plan executor, PDDL validator). The following rates are measured:

Metric	Formula
Precision	$TP / (TP + FP)$
Recall	$P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$0
True Pos. Rate	$P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$1
False Pos. Rate	$P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$2
F1	$P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$3

where $P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$4 = true positives, $P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$5 = false positives, $P^{(0)} \leftarrow \mathrm{LLM{.}generate}(\tau)$6 = false negatives.

2. Empirical Findings on Planning, Reasoning, and Verification

Benchmark studies in domains such as Blocksworld planning, symbolic puzzles, and math problem-solving show that naive self-verification by a single LLM frequently fails to outperform either single-shot or externally validated baselines, and in many settings actively degrades performance. For instance, in Blocksworld planning using GPT-4:

• LLM+LLM self-verification (“back-prompting”): 55% valid solutions (per VAL).
• LLM+external (sound) verifier: 88% valid solutions.
• Generator only (no verification): 40% valid solutions (Valmeekam et al., 2023).

Critically, false positive rates for self-verification are extremely high (e.g., 84.4%), leading to premature halting and the entrenchment of invalid solutions. This observation holds across other planning and reasoning domains, emphasizing that LLMs, when used as verifiers of their own outputs, are prone to accepting their own flawed reasoning unless checked by external, symbolic, or orthogonal agents (Valmeekam et al., 2023, Stechly et al., 2024).

Task-specific studies confirm these findings: in hard domains such as STRIPS planning or graph coloring, GPT-4 self-verifiers not only fail to catch errors but also frequently reject correct solutions, stalling the iterative loop (Stechly et al., 2024).

3. Analysis: Causes of Self-Verification Failure

The central failure mode is the conflation of generative and verification modes in autoregressive, retrieval-based LLMs. While, in principle, verification for NP-class problems is often polynomial time, LLMs do not exploit this asymmetry because their objective is to match text patterns, not to instantiate formal decisiveness.

The model checkpoints and training objectives do not create a sharp boundary between the skill for proposing solutions and the skill for invalidating incorrect ones. This produces systematic high false positive rates—LLMs tend to self-certify their own outputs unless specifically penalized for doing so. Conversely, sound external verifiers never accept invalid solutions, guaranteeing monotonic improvements via repeated back-prompting or sampling (Valmeekam et al., 2023, Stechly et al., 2024).

4. Feedback Modality and Its (Lack of) Impact

Varying the granularity of feedback to the LLM (e.g., providing binary valid/invalid signals, single-error messages, or a full listing of all failed conditions) has minimal effect beyond basic binary correctness. The bulk of gains in plan quality or reasoning accuracy derive from the use of a sound verifier, not from the informational richness of feedback: once a binary “invalid” is reliably provided, detailed feedback yields only diminishing returns (Valmeekam et al., 2023).

5. Verification Reliability: Cross-Model, Cross-Family, and Scaling

Extensive cross-family and scaling experiments indicate that self-verification is overall ineffective for large, post-trained LLMs, whereas cross-model verification (pairing a solver from one model family with a verifier from another) yields more substantial, persistent gains. The key metric is “verifier gain”: the asymptotic improvement in final accuracy from rejection sampling guided by the verifier’s accept/reject decision.

Summary of findings from an evaluation on 37 models:

Verification Mode	Typical Verifier Gain (Δ)
Self	~0.0–1.0 pp
Intra-family	~1–2 pp
Cross-family	~2–5 pp

Self-verification gain decreases with model size and post-training, whereas cross-family gain increases. This pattern is especially clear on benchmarks with polynomial-time verifiability (e.g., GSM8K arithmetic), but self-verification remains weak even there. On knowledge-intensive tasks, self-verification brings negligible improvement (Lu et al., 2 Dec 2025).

6. Recommendations for Practice and System Design

• Self-verification pipelines using a single LLM as both generator and verifier should not be trusted for high-stakes domains without external validation.
• For robust reliability in reasoning or planning, hybrid systems combining LLM generation with external, symbolic, or cross-model verification are preferred.
• Self-verification can function as a coarse, first-pass filter for glaring mistakes. However, its false positive rates necessitate a subsequent, more reliable check.
• Feedback granularity beyond binary correctness is generally not worth the engineering or compute cost unless the verifier (or user) is unreliable.
• Cross-family solver–verifier configurations and off-policy rejection sampling should be favored when feasible to maximize verifier gain (Lu et al., 2 Dec 2025).

7. Broader Implications and Outlook

Despite initial optimism that LLMs could iteratively improve their own reasoning via self-critique, empirical evidence indicates that self-verification alone in contemporary LLMs is neither dependable nor sufficient for reasoning domains that require soundness guarantees. The reliance on textual similarity, lack of explicit deductive structure in LLMs, and the collapse of verification–generation asymmetry undermine the goal of reliable self-improvement through naive self-critique (Valmeekam et al., 2023, Stechly et al., 2024, Lu et al., 2 Dec 2025).

Future advances may involve multi-agent or cross-family verification schemes, explicit symbolic constraints, or the integration of formal proof/checking mechanisms into the LLM workflow. For now, critical reasoning and planning systems should treat intrinsic self-verification as an auxiliary heuristic at most, not as a replacement for rigorous solution validation.