Source-linked AI summary
Recursive Agentic Reasoning
Shengxin Zhang, Xiaomin Wu, Xiyang Wu, Jing Xie
TL;DR
The paper addresses the lack of comparable evidence about how to spend fixed test-time compute across reasoning methods. It unifies iterative refinement, decomposition, and repeated sampling as recursion operators and evaluates them under identical conditions. BRANCH is consistently strongest, with gains linked partly to recovery from budget-exhausted outputs, while paired scoring avoids misleading comparisons.
Problem
Test-time reasoning methods are commonly evaluated with different models, benchmarks, extraction, and grading code, leaving equal-compute comparisons across tasks and models unresolved.
Method
The paper defines GROW, PRUNE, and BRANCH as recursion operators over reasoning traces and compares them with single-pass chain-of-thought under identical prompts, token budgets, graders, and paired scoring.
Results
Across 14 model-benchmark cells, BRANCH improves accuracy in every cell and is best in 12, with a mean gain of +5.98 points over the COT baseline.
Takeaways & Limitations
At this abstraction level, the data do not support routing among operators; repeated branching is consistently dominant, and much of its benefit comes from recovering budget-exhausted outputs.
Takeaways & Limitations
BRANCH uses fixed N = 5 unweighted voting without early stopping or verifier- or confidence-weighted selection, and the study reports no significance tests.
Abstract
from arXiv · showhide
Test-time reasoning methods such as iterative refinement, decomposition, and repeated sampling are often evaluated in isolation, making their gains difficult to compare across models, benchmarks, and evaluation pipelines. We introduce a unified view of these methods as recursion operators over an agent's reasoning trace: GROW, which deepens a single reasoning path; PRUNE, which decomposes and recomposes the problem; and BRANCH, which samples alternative reasoning paths and selects among them. We evaluate all three operators against a single-pass chain-of-thought baseline under a shared harness with identical prompts, token budgets, and grading code. Across five benchmarks and three frontier models, comprising 14 model-benchmark settings, 49,327 graded items, and 151,876 model calls, BRANCH improves accuracy in all 14 settings by an average of 5.98 percentage points and is the best-performing operator in 12. In contrast, GROW yields a mean gain of 2.18 points and degrades performance in two settings, while PRUNE improves accuracy by 0.94 points on average. Analysis shows that BRANCH's advantage arises not only from exploring multiple reasoning paths, but also from recovering from truncation: its gains strongly correlate with the baseline rate of empty, budget-exhausted outputs (r = 0.72). These results weaken the hypothesis that different problems require routing among test-time reasoning operators; at this level of abstraction, repeated branching is consistently dominant. Finally, we show that unpaired evaluation and treating scoring-pipeline failures as model errors can materially change, and even reverse, comparative conclusions, motivating paired scoring as a standard protocol for test-time-compute evaluation.
1 INTRODUCTION
The paper frames test-time reasoning as three recursion operators and compares them under a shared evaluation setup. Across 14 controlled model-benchmark cells, BRANCH consistently outperforms the alternatives, while paired scoring addresses evaluation hazards.
- Motivation: Test-time reasoning methods are difficult to compare because they are usually evaluated with different benchmarks, models, extraction, and grading code.This prevents practitioners from answering which method is best at equal inference compute and whether the choice depends on model or task.
- Framing: The paper defines GROW, PRUNE, and BRANCH as recursion operators over a reasoning trace and evaluates them against single-pass chain-of-thought.The comparison holds the base model fixed and asks which operator provides the most accuracy and why.
- Evaluation: The study adopts paired scoring and excludes unrecoverable transport failures rather than marking them as model errors.This avoids comparing operators on different item sets and avoids penalizing methods that issue more calls.
- Findings: BRANCH improves accuracy in all 14 cells and wins in 12, whereas GROW and PRUNE are inconsistent.The study covers five benchmarks, three models, 49,327 graded items, and 151,876 model calls under identical prompts, budgets, and graders.
2 RELATED WORK
Related work organizes prior test-time reasoning around decomposition, iterative refinement, sampling, search, recursive systems, and compute allocation. The paper positions its operators as lightweight black-box comparisons rather than learned recursive policies, with unweighted voting as a key limitation.
- Prompting and decomposition: PRUNE descends from prompting methods that decompose problems into sequential sub-problems conditioned on earlier answers.Its decomposition is produced by the same model that solves the sub-questions, with a direct-solve fallback when only one sub-question is proposed.
- Iterative refinement: GROW is a minimal iterative-refinement operator that re-solves with the previous attempt in context and halts on answer stability.Unlike methods using separate critics or verbal feedback, it uses normalized answer agreement as its stopping signal.
- Sampling and search: BRANCH relates to self-consistency and differs from tree and graph search because it samples flat alternatives rather than expanding partial reasoning states.The paper compares lightweight operators while prior work also explores policy-guided expansion, backtracking, and hybrid search.
- Recursive agentic systems: Learned recursive systems study trained recursive policies, whereas this paper compares black-box recursion operators layered onto existing frontier models.This distinction keeps the paper focused on immediately deployable operator comparisons.
- Limitations and compute scaling: Unweighted voting is the study’s clearest limitation relative to verifier- or confidence-weighted selection methods.The paper also distinguishes BRANCH from tree search and reports no significance tests, leaving small effects difficult to interpret.
3 METHOD
The method represents inference-time reasoning as recursion over model traces, using a shared solving primitive and distinct control graphs for GROW, PRUNE, and BRANCH. All operators use the same extracted-answer normalizer and require no trained verifier or ground truth.
- Agentic recursion: A recursion operator composes multiple calls M(p) into one answer, allowing the model to issue calls conditioned on intermediate products.The baseline is y = extract(M(x)), while operators are characterized by their computation graphs and halting rules.
- Shared solving primitive: The shared solve function detects budget-exhausted hidden reasoning and reprompts the model to finalize an answer from its truncated reasoning.This prevents empty, successful length-stop completions from automatically being treated as wrong answers.
- GROW: GROW extends one path for up to three rounds and halts when consecutive normalized answers match.Each round receives the previous attempt as context.
- PRUNE: PRUNE decomposes the problem into ordered sub-questions, solves them sequentially with prior answers in context, and composes the result.A one-question decomposition falls back to a direct solve.
- BRANCH and control: BRANCH samples five independent solutions, normalizes their answers, and returns the plurality key while discarding empty samples from winning votes.Its control signal is the agreement ratio, shared with the other operators’ extracted-answer-based control signals.
4 EXPERIMENTAL SETUP
The experiments compare three text-only frontier models across headroom-selected benchmarks with conservative shared grading and paired item sets. The protocol handles endpoint failures, deduplicates retries, and evaluates accuracy changes against the COT baseline across 14 cells.
- Models: Three frontier models were accessed through one evaluation proxy, keeping routing, retry policy, and token accounting identical.All models emit hidden deliberation streams, making truncation behavior relevant to the study.
- Benchmarks: The benchmarks were selected below ceiling and span multi-hop retrieval, expert questions, general reasoning, graduate knowledge, and olympiad mathematics.Saturated mathematics sets were discarded because they could not reveal differences between test-time methods.
- Grading: Shared grading uses letter extraction for multiple-choice items and symbolic or string normalization for freeform answers.For HLE, this grading is a strict lower bound relative to the official LLM judge but is applied equally within each cell.
- Failure handling: 709 items ended in unrecoverable transport failures after seven retries with exponential backoff, so the protocol separates infrastructure failures from model errors.The study excludes unresolved failures rather than scoring them as incorrect.
- Paired protocol: Paired evaluation intersects the resolved item sets of all four methods so every comparison uses identical questions.Attrition is zero in six cells and below 1% in four additional cells.
- Comparative evaluation: Figure 2 reports accuracy changes from COT across 14 cells, with BRANCH positive in every cell and GROW and PRUNE negative in two each.Table 2 reports accuracy, baseline deltas, paired item counts, and the missing Omni-MATH-by-Qwen3.6-plus cell.
5 RESULTS
Across 14 model-benchmark cells, BRANCH is the strongest operator overall, while its gains are closely tied to recovering baseline truncations. Evaluation choices and compute costs materially shape the comparison.
- Overall operator comparison: +5.98 points: BRANCH improves baseline accuracy in all 14 cells and is best in 12.GROW averages +2.18 points and PRUNE +0.94 points.
- Routing hypothesis: The results do not support routing among operators at this granularity: BRANCH is best across all DeepSeek-V4-Pro and MiniMax-M3 cells.Only Qwen3.6-plus splits, two to two, with one exact tie.
- Truncation recovery: Sampling five times reduces empty outputs because budget-exhausted samples are discarded by plurality voting.DeepSeek-V4-Pro’s HLE empty rate falls from 51.2% to 32.2%, while MiniMax-M3’s BBEH rate falls from 35.0% to 15.5%.
- Truncation recovery: BRANCH gains correlate strongly with baseline empty-output rates (r = 0.72 over 14 cells).Its empty-output rate falls in all ten cells with any truncation.
- Cross-model effects: Qwen3.6-plus never truncated, and BRANCH’s gains there were smallest, including one non-tied loss to GROW.Its BRANCH gains were +0.66, +1.38, +2.33, and +5.73.
- Compute and efficiency: BRANCH achieves the highest accuracy ceiling but is less efficient per extra call than GROW.GROW returns +1.77 points per additional call versus BRANCH’s +1.55; PRUNE is dominated on both axes.
- Compute and efficiency: BRANCH’s fixed N = 5 and lack of early stopping are an acknowledged inefficiency.The authors identify majority-decision halting as an unimplemented cost reduction.
- Evaluation protocol: Cross-model HLE comparisons require a shared item set because different attempted subsets change model rankings.On the shared 305-item set, MiniMax-M3 leads at 31.80%.
6 DISCUSSION
The paper claims novelty in its controlled comparison of recursion operators, its truncation-recovery explanation for BRANCH, and its negative result on operator routing. It also shows that unpaired scoring and small pilots can produce misleading comparative conclusions.
- The paper claims novelty for the controlled comparison, not for GROW, PRUNE, or BRANCH as algorithms.
- BRANCH’s benefit on long-reasoning models partly comes from recovering answers omitted by single-pass truncation, not only from path marginalization.
- Unpaired scoring turned a Qwen3.6-plus HLE result into an apparent regression: BRANCH fell from 14.20% to 11.20% under baseline-style scoring, but was +0.66 on the paired set.
- BRANCH uses unweighted majority voting, while the study reports no significance tests and cautions that small BBEH and Omni-MATH effects are provisional.
- A 50-item pilot suggested task-dependent operator effectiveness, but its uncertainty was near 7 points and the full data contradicted that pattern.
7 CONCLUSION
Under identical conditions, repeated sampling improved accuracy across the evaluated cells, while single-path refinement and decomposition were inconsistent. The findings identify budget exhaustion as a specific target and support paired scoring for comparative test-time-compute studies.
- Sampling and voting improved accuracy in all 14 model-benchmark cells by a mean of six points, while GROW and PRUNE were inconsistent and sometimes harmful.
- Much of sampling’s benefit came from recovering answers that a single pass never emitted under finite token budgets.
- The paper’s routing hypothesis did not survive the full data, and it recommends paired scoring and separating infrastructure failures from model failures.
- Per-item records for 49,327 graded items were retained so every reported figure can be recomputed without requerying models.
A PER-CELL ATTRITION
Table 3 compares attempted with paired item counts across 14 cells. Six cells were unaffected, while the HLE Qwen3.6-plus cell was the attrition outlier.
- Attrition counted items that at least one method failed to resolve after seven retries; all failures were transport-level.
- Table 3 reports attempted and paired item counts for each model-benchmark cell.
- Six of the fourteen cells were unaffected by attrition.
- The HLE Qwen3.6-plus cell was the attrition outlier discussed in Section 6.
B OPERATOR PSEUDOCODE
The pseudocode defines GROW as iterative refinement, PRUNE as decomposition with sequential subproblem solving, and BRANCH as independent sampling followed by majority selection. All operators use shared solving and answer normalization primitives.
- The shared solve primitive includes a finalization retry for budget-exhausted generations, while norm provides answer normalization.
- GROW: GROW begins with a direct solve, repeatedly solves using the prior answer, and stops when normalized answers stabilize.
- PRUNE: PRUNE decomposes the input, solves subquestions sequentially with earlier answers available, and composes the results; one subquestion triggers a direct-solve fallback.
- BRANCH: BRANCH draws five independent solutions at temperature 0.7 and returns the normalized answer with the largest vote count.