Test-Time Recursive Thinking (TRT)

• Test-time Recursive Thinking (TRT) is a family of inference procedures that refines LLM outputs through recursive candidate generation, verification, and aggregation.
• It employs mechanisms like decomposition, self-critique, latent iteration, and dynamic subproblem expansion to boost performance on complex reasoning tasks.
• Empirical results show TRT can improve accuracy by 20–40 percentage points and reduce computational costs compared to one-shot, static inference approaches.

Test-time Recursive Thinking (TRT) refers to a family of inference procedures for LLMs that implement multi-stage, self-improving reasoning loops entirely at test time—without updating model parameters. TRT encapsulates recursive strategies such as decomposition, self-critique, aggregation, latent iteration, and verification, all orchestrated to systematically enhance model outputs via additional computation at inference. Unlike one-shot or static multi-sample approaches, TRT frameworks are structured, adaptive, and grounded in recent advances across language, code, and knowledge-based reasoning tasks.

1. Core Formalism and Algorithmic Template

TRT is fundamentally defined as an iterative, recursive process that interleaves candidate generation, reasoning refinement, and self-guided selection to incrementally improve output quality. Each TRT procedure instantiates three core phases:

1. Exploration/Generation: Produce a diverse set of reasoning chains or candidate solutions for the given input.
2. Selection/Verification: Apply self-guided or contextually aware mechanisms—such as verification prompts, log-odds preference, or latent halting— to evaluate and select preferred or correct candidates without access to ground-truth.
3. Update/Recursion: Aggregate knowledge, distill lessons (e.g., failure modes, partial correctness), and condition subsequent generations or subproblem expansions on the accumulated contextual memory or intermediate states.

A generic TRT loop advances by repeatedly alternating these phases, invoking strategies such as candidate reranking, reflection, aggregation, and dynamic subproblem expansion, until a termination criterion is met (e.g., negligible selection margin, iteration limit, halting confidence, or convergence in answer set) (Chen et al., 11 Oct 2025, Zhuang et al., 3 Feb 2026). The baseline algorithmic outline can be formalized as:

• For each round $t$ (typically $t{=}1..T$):
  • Generate $K$ solutions $\{r_{t,1},..., r_{t,K}\}$ using distinct strategies or conditioned on summary memory.
  • Compute verification scores $v_{t}(r_{t,k})$ via self-checks, preference, or test-execution.
  • Select $r_t^* = \arg\max_k v_{t}(r_{t,k})$.
  • Update an internal knowledge state $\mathcal{K}_{t+1}$ with distilled constraints or insights.
  • (Optionally) Aggregate/summarize the running set of verified answers for the next cycle.
• Final output is deduced by consolidating the last set of answers or summary memory (Chen et al., 11 Oct 2025, Zhuang et al., 3 Feb 2026, Buehler, 2024).

2. Instantiations Across Reasoning and Model Architectures

Multiple instantiations of TRT have been developed and empirically validated:

• Recursive Self-Aggregation (RSA): Maintains a population of candidate reasoning chains, repeatedly aggregates subsets of solutions via model-driven recombination, and iterates the process to harness both diversity (breadth) and cumulative refinement (depth). Each aggregation prompt fuses partial correct substeps, enabling bootstrapped improvement via chain-of-thought fragment reuse (Venkatraman et al., 30 Sep 2025).
• Adaptive Graph of Thoughts (AGoT): Constructs a dynamic directed acyclic graph (DAG) of decomposed subproblems where only "complex" nodes are recursively expanded. This unifies chain, tree, and graph-structured thought processes, dynamically allocating reasoning compute to hard subproblems, and aggregating partial solutions for robust, multi-hop inference (Pandey et al., 7 Feb 2025).
• MatryoshkaThinking: Interleaves candidate generation, self-verification, and summarization in recursive loops, efficiently retaining and amplifying correct solutions while compressing the diversity benefit of large-k sampling into high-confidence single-shot outputs. This approach achieves state-of-the-art benchmark performance with sharply reduced computational cost compared to DeepConf (Chen et al., 11 Oct 2025).
• Latent/Layerspace Recursion (ETD, SELF-Transformer): Test-time looping over select subset(s) of transformer layers—identified as most reasoning-relevant—applies recursive computation at the hidden state level. Adaptive halting and fixed-point self-attention further enable per-token or per-head dynamic recursion, scaling compute to input difficulty and boosting expressivity without externalizing intermediate states (Koishekenov et al., 8 Oct 2025, Mathur et al., 17 Jul 2025).
• Task-Structured Recursion (RTQA): For complex temporal KGQA, recursive decomposition trees are built over sub-questions, each solved bottom-up with LLMs and retrieved knowledge, and results are aggregated with multi-source selectors for increased fault tolerance and multi-constraint coverage (Gong et al., 4 Sep 2025).

3. Component Mechanisms and Variants

TRT pipelines combine a set of modular, interchangeable mechanisms:

• Reasoning/Thinking Blocks: Internal tokens or layer blocks that encapsulate intermediate reasoning steps, e.g., <|thinking|>...<|/thinking|> tokens (Buehler, 2024), latent "thinking" layer blocks (Koishekenov et al., 8 Oct 2025, Mathur et al., 17 Jul 2025).
• Reflection and Critique: Multi-agent or self-critique systems, using either separate critic models or reflection tokens, to propose refinements at each recursion (Buehler, 2024).
• Self-Verification: Prompts or mechanisms for verifying candidate answers in the absence of external labels—unit test generation for code (Zhuang et al., 3 Feb 2026), answer range exclusion for math, or triggered checklists.
• Preference Optimization and Rejection Sampling: Lightweight pairwise log-odds selection on answer tokens, masking out internal thoughts, to enforce mode-seeking behavior during candidate resampling (Buehler, 2024).
• Dynamic Knowledge/Solution Graphs: Retrieval-augmented or semantic summarization of past context, growing evidence graphs, or verified answer sets as ground for successive recursions (Buehler, 2024, Pandey et al., 7 Feb 2025, Chen et al., 11 Oct 2025).

The following table summarizes representative components in recent TRT systems:

TRT Variant	Internal Recursion	Candidate Selection	Contextual Memory
PRefLexOR/Reflection-based	Thinking/Reflection tokens	Log-odds, Critic selection	Dynamic knowledge graph
AGoT	Recursive DAG expansion	Finality/completeness check	DAG of partial answers
MatryoshkaThinking	Summarization recursion	LLM-based self-verification	Growing set of verified answers
RSA	Aggregation over chains	LLM aggregation	Population of chains
ETD/SELF	Layer (latent) iteration	Halting router, ε-convergence	Latent activations per token
RTQA	Subproblem tree recursion	Answer aggregator (LLM/rules)	Subtree partial results

4. Empirical Performance and Computational Analysis

TRT frameworks consistently yield substantial gains across a diverse range of tasks:

• On combinatorial math (AIME-25), code (LiveCodeBench), and scientific benchmarks (GPQA, Reasoning Gym), TRT lifts LLM accuracy by up to 46.2 percentage points vs. direct outputs (Zhuang et al., 3 Feb 2026, Chen et al., 11 Oct 2025, Pandey et al., 7 Feb 2025). For example, MatryoshkaThinking achieves 99.79% Pass@1 on AIME2025 at merely 4% of DeepConf’s computational budget (Chen et al., 11 Oct 2025).
• RSA demonstrates +29.3 pp gains for AIME-25 and +20.4 pp for HMMT-25, with monotonic improvement as depth or population size increases (Venkatraman et al., 30 Sep 2025).
• Latent recursion (ETD) on OLMo-2 1B shows +28.4% improvement on GSM8K, +36% on MATH for k=3 latent recursions (Koishekenov et al., 8 Oct 2025). Adaptive SELF-Transformers yield up to 20% increases on encoder-style QA, with modest compute overhead (Mathur et al., 17 Jul 2025).
• In multitask settings, TRT bridges large gaps between Pass@k and Pass@1, compressing gains from k-shot diversity into a single recursed output, and outperforming both majority-voting and one-shot self-refinement (Chen et al., 11 Oct 2025).

Practical compute trade-offs are favorable: typically, 2-4 recursions or loops suffice for >90% of the cumulative gain, with selection and summarization operating within context or memory budgets via adaptive early exit, prompt compression, or latent state re-use (Buehler, 2024, Koishekenov et al., 8 Oct 2025, Chen et al., 11 Oct 2025).

5. Model and Domain Generality

TRT does not require any model re-training, fine-tuning, or architectural changes beyond possible mid-training layer role identification (in the case of latent iteration). Most methods are directly applicable to any frozen LLM and are model-size agnostic (Pandey et al., 7 Feb 2025, Chen et al., 11 Oct 2025, Zhuang et al., 3 Feb 2026). Domain generality is also supported; distinct instantiations exist for:

• Open-domain QA with knowledge graph or tabular retrieval (Gong et al., 4 Sep 2025, Pandey et al., 7 Feb 2025).
• Mathematical and scientific reasoning (Venkatraman et al., 30 Sep 2025, Chen et al., 11 Oct 2025, Zhuang et al., 3 Feb 2026).
• Code generation with model-generated test cases (Zhuang et al., 3 Feb 2026, Venkatraman et al., 30 Sep 2025, Chen et al., 11 Oct 2025).
• Reading comprehension, factual QA, and multi-modal reasoning (Chen et al., 11 Oct 2025).
• Latent computation for both autoregressive and encoder-style transformers (Mathur et al., 17 Jul 2025, Koishekenov et al., 8 Oct 2025).

The TRT paradigm further generalizes classical chain-of-thought (CoT) and tree-of-thought (ToT) strategies by introducing adaptive recursive expansion, aggregation, and verification, as well as context compressive summarization and latent recursion (Pandey et al., 7 Feb 2025, Chen et al., 11 Oct 2025).

6. Limitations, Open Questions, and Future Directions

TRT methods require careful design of selection, verification, and summarization mechanisms tailored to target domains. Self-verification is domain-specific and may necessitate new signals (e.g., formal proof checkers, empirical test generators) for broader applicability (Zhuang et al., 3 Feb 2026). Incomplete or noisy test generation can limit selection reliability; robust ranking and aggregation-aware RL offer partial mitigation (Venkatraman et al., 30 Sep 2025).

Computational overhead is nontrivial but often linear in recursion depth or number of candidates sampled; however, adaptive schemes recover much of the gain at reduced cost (Koishekenov et al., 8 Oct 2025, Chen et al., 11 Oct 2025). Over-iteration beyond optimal convergence can sometimes be detrimental; convergence thresholds and halting routers address this but trade off completeness for budget control.

Open questions remain regarding knowledge sharing across problems, extension to domains lacking clear self-verification, and further efficiency gains from global memory or cross-instance distillation. Aggregation-aware RL during post-training amplifies RSA/TRT performance, suggesting synergy between test-time recursion and training-phase optimization (Venkatraman et al., 30 Sep 2025).

7. Summary

Test-time Recursive Thinking constitutes a rigorous, modular paradigm for enhancing LLM reasoning by interleaving recursive exploration, reflection, verification, and aggregation purely at inference. TRT unifies and generalizes previous breadth/depth scaling approaches (CoT, ToT, population decoding), supports adaptive compute allocation, and delivers robust, state-of-the-art gains across domains and model sizes without modifying model weights. Recursion—operating at the level of candidates, knowledge, graphs, or latent layers—enables LLMs to "think more deeply" per query and adapt computation to the intrinsic complexity of each task, establishing TRT as a theoretical and practical foundation for performant, flexible, and efficient test-time reasoning (Chen et al., 11 Oct 2025, Zhuang et al., 3 Feb 2026, Buehler, 2024, Venkatraman et al., 30 Sep 2025, Pandey et al., 7 Feb 2025, Koishekenov et al., 8 Oct 2025, Mathur et al., 17 Jul 2025, Gong et al., 4 Sep 2025).