SSR: Socratic Self-Refine for Large Language Model Reasoning (2511.10621v1)

Abstract: LLMs have demonstrated remarkable reasoning abilities, yet existing test-time frameworks often rely on coarse self-verification and self-correction, limiting their effectiveness on complex tasks. In this paper, we propose Socratic Self-Refine (SSR), a novel framework for fine-grained evaluation and precise refinement of LLM reasoning. Our proposed SSR decomposes model responses into verifiable (sub-question, sub-answer) pairs, enabling step-level confidence estimation through controlled re-solving and self-consistency checks. By pinpointing unreliable steps and iteratively refining them, SSR produces more accurate and interpretable reasoning chains. Empirical results across five reasoning benchmarks and three LLMs show that SSR consistently outperforms state-of-the-art iterative self-refinement baselines. Beyond performance gains, SSR provides a principled black-box approach for evaluating and understanding the internal reasoning processes of LLMs. Code is available at https://github.com/SalesforceAIResearch/socratic-self-refine-reasoning.

• The paper introduces SSR, an iterative protocol that decomposes LLM reasoning into sub-questions and sub-answers for targeted error correction.
• SSR leverages zero-shot prompting and controlled re-solving to verify each reasoning step using confidence scores and self-consistency measures.
• Empirical results show SSR outperforms existing methods with up to 8.89% improvement on benchmarks, demonstrating enhanced debugging and scalability.

Socratic Self-Refine: Step-Level Iterative Reasoning for LLMs

Introduction and Motivation

LLMs exhibit strong multi-step reasoning capabilities, particularly when guided by Chain-of-Thought (CoT) prompting. Nonetheless, existing test-time frameworks for refining LLM output—primarily sample selection (self-verification) and iterative self-refinement—operate either at the coarse granularity of whole reasoning trajectories or via holistic feedback, resulting in limited detection and correction of step-level errors. This limitation frequently causes error propagation: a single faulty intermediate step may cascade, yielding incorrect or incoherent final predictions.

The paper introduces Socratic Self-Refine (SSR), an iterative reasoning refinement protocol in which model responses are decomposed into verifiable (sub-question, sub-answer) pairs (Socratic steps). SSR leverages controlled step-level re-solving and consistency checks to pinpoint unreliable sub-answers, then selectively refines problematic segments while preserving the overall trajectory. This fine-grained decomposition provides a black-box mechanism for improved confidence estimation, debugging, and interpretability without requiring architectural or training-time modifications.

Figure 1: SSR achieves a substantial scaling advantage over standard CoT and Self-Refine by decomposing responses, performing step-wise verification and refinement, and maintaining comparable runtime cost.

SSR Architecture and Algorithm

SSR comprises three principal operations at test time:

1. Decomposition: Given an initial CoT-generated reasoning trace, SSR applies zero-shot prompting to extract a sequence of $(\text{sub-question}, \text{sub-answer})$ pairs reflecting the semantic steps of reasoning.
2. Verification: For each Socratic step, SSR independently re-solves the sub-question multiple times in controlled context, collecting a reference answer set and computing a confidence score (e.g., via self-consistency or LLM-based expression comparison). Step-level confidence scores serve as proxies for reliability.
3. Refinement: Locating the step with minimum confidence (highest uncertainty), SSR majority-votes among reference answers and injects the refined sub-answer back into the reasoning process. The model is instructed, via tailored prompt engineering, to regenerate the full trace, preserving valid context while correcting only the targeted error.

Variants of SSR balance cost and accuracy:

• SSR-Lin: Applies SSR blocks at every iteration for maximal precision—a high compute option.
• SSR-Ada: Combines standard Self-Refine with SSR, gating the fine-grained step-level operation to cases where Self-Refine identifies no errors or perfect confidence.
• SSR-Plan: Adds high-level plan refinement (summary and adequacy judgement of sub-question sequence) before applying SSR.

  Figure 2: SSR decomposes reasoning into atomic steps, verifies each via self-consistency, and refines the weakest element, with optional preliminaries addressing plan soundness.

Empirical Results: Robustness and Scaling

SSR was evaluated across five reasoning datasets (MATH-Level-5, AIME24/25, HLE, Zebra Puzzle, Mini-Sudoku) and multiple LLMs (GPT-4.1-nano, GPT-5-mini, Gemini-2.5-Flash). SSR variants consistently outperform state-of-the-art self-refine baselines (Self-Refine [madaan2023self], Debate [du2023improving], AoT [teng2025atom], MCTSr [zhang2024accessing]) not just in last-round accuracy but also in Best-of-K and Pass@K performance metrics.

Strong numerical findings include:

• SSR-Plan attains highest or second-best scores on nearly all metrics, with margins up to $+8.89\%$ on challenging mathematical benchmarks.
• SSR maintains superior accuracy under increased test-time computation, with scaling benefits persisting when baseline approaches plateau.
• Gains manifest both with smaller backbones (GPT-4.1-nano, Gemini-2.5-Flash-Lite) and leading-edge models (GPT-5, Gemini-2.5-Flash), indicating generalizability with respect to model strength and compute budget.

  Figure 3: Parallel test-time scaling on AIME25 shows SSR outpacing both Self-Refine and CoT at comparable sample sizes.

  

  Figure 4: Iterative scaling maintains SSR’s performance edge across increasing refinement rounds, confirming robust monotonic improvement.

On difficult tasks (e.g., text-only math in Humanity’s Last Exam), SSR surpasses baseline CoT and Self-Refine by up to $+8.89\%$ with smaller models and $+5.23\%$ with GPT-5.

Model Calibration, Judge Analysis, and Granularity Effects

SSR’s step-level confidence scores are less correlated with final correctness (lower AUROC) than holistic LLM-as-a-Judge approaches, yet demonstrate far higher recall of genuinely erroneous traces—a critical property for robust error containment in iterative refinement. SSR’s complementary noise tolerance is validated by the fact that LLMs generally recover well despite imperfect feedback.

Granularity control experiments reveal that SSR-Plan provides stability and strong performance regardless of step count, whereas SSR-Lin exhibits higher variance. Excessively fine decomposition (i.e., too many steps) may introduce diminishing returns or semantic drift, suggesting an optimal regime for step-wise breakdown exists.

Figure 5: SSR yields higher recall of incorrect reasoning traces compared to LLM-as-a-Judge, enabling more effective iterative correction.

Figure 6: SSR-as-a-Judge maintains competitive detection on process evaluation benchmarks, complementing standard judge protocols.

Qualitative Comparison and Practical Implementation

Case studies highlight SSR’s distinct capability to diagnose, localize, and correct error propagation. SSR’s intervention occurs at the step most implicated by low confidence, preventing erroneous downstream reasoning and achieving more succinct and interpretable revision trajectories than Self-Refine.

Figure 7: CoT response before refinement, illustrating the interwoven nature of raw reasoning traces.

Figure 8: Self-Refine revises the full trace via generic feedback but may retain latent errors.

Figure 9: SSR applies targeted Socratic decomposition, verifies sub-answers, and revises only the erroneous segment, achieving higher fidelity and coherence.

Implementation involves careful prompt engineering to balance injection of Socratic context, preservation of natural reasoning trace, and minimal disruption to instruction-tuned response formats. Trade-offs exist between computational cost and accuracy, but gating and planning mechanisms yield flexible deployment across different environments.

Limitations and Future Perspectives

SSR's reliance on LLM-based decomposition introduces stochasticity and potential inconsistency for ambiguous problems. The computational requirements for step-wise confidence estimation are non-trivial relative to standard test-time methods, which may pose scalability constraints for extremely large datasets or long multi-step problems. SSR's effectiveness is primarily validated on mathematical and logical reasoning; its transferability to domains with highly open-ended or multi-modal structure requires further investigation.

The conceptual advance of SSR—transitioning from outcome-level to process-level reasoning verification—lays a foundation for future, more controllable and interpretable LLMs. Research directions include extending SSR to scientific and multi-modal tasks, integrating with human-in-the-loop debugging, and exploring efficient, model-driven confidence estimators.

Conclusion

SSR demonstrates that explicit, step-level decomposition, verification, and targeted correction yield consistent improvements in the reliability, interpretability, and scaling of LLM reasoning. The approach is black-box, generalizes across model scales, and achieves state-of-the-art performance on both moderate and frontier reasoning benchmarks. Fine-grained control over reasoning trajectories, combined with adaptive gating and preliminary plan evaluation, establishes SSR as a strong base for trustworthy and scalable reasoning systems in both NLP and AGI research.