acceptodds
Under review as a conference paper at ICLR 2027

Recursive Language Models Meet Uncertainty: The Surprising Effectiveness of Self-Reflective Program Search for Long Context

Abstract

Long-context handling remains a core challenge for language models: even with extended context windows, models often fail to reliably extract, reason over, and use the information across long contexts. Recent works like Recursive Language Models (RLMs) have approached this challenge by agentic way of decomposing long contexts into recursive sub-queries through programmatic interaction at inference. While promising, the success of RLMs critically depends on how these trajectories of context-interaction programs are selected, which has remained unexplored. In this paper, we study this problem and introduce Self-Reflective Program Search for Long Context (SRLM), a framework that augments programming-based context interaction with uncertainty-aware self-reflection. SRLM leverages three intrinsic signals: self consistency, reasoning trace length, and verbalized confidence. These serve as complementary indicators of a model’s internal uncertainty, and the model uses them to evaluate and compare candidate context-interaction programs. Extensive experiments across diverse benchmark datasets, context lengths, and backbone models, show that SRLM consistently outperforms state-of-the-art base- lines, yielding up to 22% improvement over RLMs under the same time budget. Our findings show that recursion itself is not the primary driver of performance in RLMs, and a simple self-reflective program search can match or surpass RLM without requiring self-query or explicit recursion mechanisms. We find that for context lengths within the model’s context window, RLMs with recursion often degrade performance relative to the base model, whereas SRLM yields consistent and robust gains across both short and long contexts. We also find that RLM is less effective in tasks with semantically intensive nature, where heuristic program search is insufficient and broader contextual understanding is required, while self-reflection in SRLM provides a semantic signal that better steers reasoning in these challenging long-context scenarios.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Large Language Models, Long Context, Program Search, Self-Reflection

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_yTVJOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies Recursive Language Models (RLMs) and points out that selection among candidate interaction programs under uncertainty rather than recursion itself is the key to success in long-context reasoning; programmatic interaction contributes majorly for the success of RLM. Based on this, the paper proposes Self-Reflective Program Search for Long Context Method (SRLM), which samples different trajectories, conducts majority voting, and selects the one with highest confidence and longer reasoning length. On several benchmarks and two different models, the proposed method outperforms several baselines.

Critical strengths
  1. This paper studies an interesting question on recursive language models, which is timely in today's LLM community with long-context tasks. The conclusion that the gain of RLM mainly comes from programmic context interaction is quite insightful.

  2. The proposed method achieves significant performance improvement compared to RLM and other baselines.

Critical weaknesses
  1. I think the key concern about this paper is that the design of SRLM feels somewhat ad-hoc. Compared to RLM, SRLM is different only with majority voting and a heuristic tie-breaker (indicated from Fig. 1, which somewhat contradicts with line 169-170; see questions for details) that uses a product of LLM-generated confidence score and response length. Judging from line 186, the verbalized confidence is a sum across steps instead of mean, which is negatively correlated with reasoning length.

Among the three components:

a) Majority voting is a common technique for test-time scaling that improves performance at the cost of multiple times of token consumption. While wall-clock time consumption is reported in Fig. 3, multiple rollouts can be completed in parallel (especially for GPT-5), giving majority voting a hidden and unfair advantage.

b) LLMs are known to be overconfident [1] as a judge; thus, it is not sure whether the confidence score generated by LLM is reliable or not. While the paper reports the relation between confidence, length and accuracy in Fig. 5 and 13, the distribution of confidence reported by LLM is not known.

c) Reasoning length also does not necessarily indicate more intricate reasoning, especially for very strong models such as GPT-6 Astra which can hide CoT [2] or weaker models which can fall into repeat loops during reasoning [3].

  1. The central question raised in line 103-104 feels somewhat unconvincing. Fig. 4 shows significant improvement of adding recursiveness (i.e. sub-call) to both RLM and SRLM. Also, "The real bottleneck is how we select among candidate interaction programs under uncertainty" seems to be leveraging the unfair advantages of more test-time resources (multiple trials) that RLM has no access to.

References

[1] https://arxiv.org/pdf/2508.06225

[2] https://arxiv.org/abs/2609.26637

[3] https://arxiv.org/abs/2512.12895

Questions for authors
  1. Since after majority voting for self-consistency, as suggested by Fig. 1, all remaining responses have the most frequent answer, the other two factors (reasoning trace length and verbalized confidence) are only tie-breakers among these answers. The problem is: how often does this tie-breaker mechanism come into effect? Also, the definitions in line 169-170 seems to indicate that only one plurality answer is selected. In this case, reasoning trace length and verbalized confidence should not have any effect on accuracy since the candidate answer is unique. Could the authors explain this?

  2. Why the authors would use LLM judges for all three benchmarks tested in this paper (BrowseComp+, OOLONG-synth and LongBench-v2)? LLM judges could introduce additional hallucination and inaccuracies in scoring, while both OOLONG-synth and LongBench-v2 has verifiable answers that does not require LLM judges (especially LongBench-v2, which are multiple choice questions). Is there any empirical evidence on the accuracy of LLM judge?

6 comments
AuthorsOpenReview ↗

Response to reviewer yTVJ (1)

Thank you for dedicating your time and expertise to review our submission. Please find our responses below.

  • This paper studies an interesting question on recursive language models, which is timely in today's LLM community with long-context tasks. The conclusion that the gain of RLM mainly comes from programmic context interaction is quite insightful.
  • The proposed method achieves significant performance improvement compared to RLM and other baselines.

Thank you for recognizing the strengths and novelty of our work.

I think the key concern about this paper is that the design of SRLM feels somewhat ad-hoc. Compared to RLM, SRLM is different only with majority voting and a heuristic tie-breaker ... . Judging from line 186, the verbalized confidence is a sum across steps instead of mean, which is negatively correlated with reasoning length. Among the three components: a) Majority voting is a common technique for test-time scaling that improves performance at the cost of multiple times of token consumption. While wall-clock time consumption is reported in Fig. 3, multiple rollouts can be completed in parallel giving majority voting a hidden and unfair advantage b) LLMs are known to be overconfident [1] as a judge; thus, it is not sure whether the confidence score generated by LLM is reliable or not. While the paper reports the relation between confidence, length and accuracy in Fig. 5 and 13, the distribution of confidence reported by LLM is not known. c) Reasoning length also does not necessarily indicate more intricate reasoning, especially for very strong models such as GPT-6 Astra which can hide CoT [2] or weaker models which can fall into repeat loops during reasoning [3].

Thank you for the comment. We would like to highlight that most of the uncertainty quantification metrics in LLM literature are in fact heuristic (including self-consistency [1], verbalized confidence [2], and trace-length-based uncertainty [3], or their integrations) and our metric is also built motivated by these prior works. The contribution of this paper is not that we have proposed a new and better uncertainty quantification metric, but that programmatic interaction is a new way of handling long context through inference-time compute, and the choice of inference-time scaling approach plays an important role here. There could be different ways to spend additional inference compute for this purpose, we can spend additional inference compute through recursion sub-calls (sub-agent setting) or we can spend that compute through simpler ways like best of N and self-reflection, similar to the step-wise uncertainty-based self-reflection we have in SRLM. We wanted to share the insight that even simpler inference-time scaling approaches could be as effective or even better than the recursion in this long context interaction setting, which has been proposed as the key direction for long context handling based on the claim of "recursive" language models.

References:

[1] Wang, X. et al. "Self-Consistency Improves Chain of Thought Reasoning in Language Models.", 2022

[2] Xiong, M. et al. "Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation in LLMs.", 2023

[3] Devic, S et al. "Trace Length is a Simple Uncertainty Signal in Reasoning Models.", 2025

Since after majority voting for self-consistency, as suggested by Fig. 1, all remaining responses have the most frequent answer, the other two factors (reasoning trace length and verbalized confidence) are only tie-breakers among these answers. The problem is: how often does this tie-breaker mechanism come into effect? Also, the definitions in line 169-170 seems to indicate that only one plurality answer is selected. In this case, reasoning trace length and verbalized confidence should not have any effect on accuracy since the candidate answer is unique. Could the authors explain this?

Thank you for raising thoughtful question. We would like to clarify that in SRLM, the three signals work at different levels. Verbalized confidence and reasoning length are applied per step: they guide which intermediate steps are kept as each context-interaction trajectory is built. Self-consistency is applied over the full sequence of steps, based on the final answers of the completed trajectories. They are not a re-ranking inside a fixed answer group, so the reviewer's statement that “reasoning trace length and verbalized confidence should not have any effect on accuracy” is not true as with these signals, the candidate pool itself can be different. This also explains our component ablation results in Fig. 5 where we show combination of all three metrics is helpful to performance. We agree that our current writing could be clearer and thank reviewer for bringing this to our attention. We have now revised Section 2.2 to state where each signal acts, and we added a short algorithm description to make the procedure clearer (edits highlighted with blue).

AuthorsOpenReview ↗

Response to reviewer yTVJ (2)

The central question raised in line 103-104 feels somewhat unconvincing. Fig. 4 shows significant improvement of adding recursiveness (i.e. sub-call) to both RLM and SRLM. Also, "The real bottleneck is how we select among candidate interaction programs under uncertainty" seems to be leveraging the unfair advantages of more test-time resources (multiple trials) that RLM has no access to.

We are not fully sure we have understood the reviewer's comment, we appreciate if the reviewer can further clarify on this and let use know if any further clarification from us could help. As it can be observed from Fig 4, the gain from recursion differs significantly between different domains and this gain is more significant in search-oriented domains like CodeQA and Structured Data QA compared to more semantic domains like single or multi-doc QA. What we wanted to share as insight in this paper was that the choice of inference-time scaling approach plays an important role in these frameworks and there could be different ways to spend additional inference compute for this purpose, we can spend additional inference compute through recursion sub-calls (sub-agent setting) or we can spend that compute through simpler ways like best of N and self-reflection, similar to the step-wise uncertainty-based self-reflection we have in SRLM. We wanted to share the insight that even simpler inference-time scaling approaches could be as effective or even better than the recursion in this long context interaction setting and recursion is not as fundamental as it’s claimed for long context in “recursive” language model (RLM).

Why the authors would use LLM judges for all three benchmarks tested in this paper (BrowseComp+, OOLONG-synth and LongBench-v2)? LLM judges could introduce additional hallucination and inaccuracies in scoring, while both OOLONG-synth and LongBench-v2 has verifiable answers that does not require LLM judges (especially LongBench-v2, which are multiple choice questions). Is there any empirical evidence on the accuracy of LLM judge?

We use an LLM judge to make scoring robust to how answers are formatted. Rule-based answer extraction can mark a correct answer wrong just because it is phrased differently, and this adds wrong penalties to evaluations. It’s important to note that the judge’s task is quite simple here: it only checks whether the LLM final answer matches the ground truth. So it adds very little judgment of its own while removing errors caused by formatting. In response to reviewer's comment, we also measured agreement between the judge and human scoring among 50 random samples and found complete agreement.


We hope that our rebuttal address the reviewer's concerns, and if so, they would consider updating their score. We'd be more than happy to engage in further discussions

Thank you for your response, and thank you for explaining how the three components of SRLM works together at different levels. Here are my follow-up questions:

  1. Regarding heuristic designs: I agree that heuristic methods are not necessarily bad. My point is that the metrics (length and self-generated confidence score) chosen by this paper is found to be potentially problematic as stated in my reference papers, and there is no rationale on why the way that the authors combine these metrics at each step (by using product) is the best way. Also, my question " the distribution of confidence reported by LLM is not known" is not answered: this is an empirical validation to my concern "LLMs are overconfident to be the judge" on the confidence score.

  2. Regarding the statement in your response "we can spend that compute through simpler ways like best-of-N and self-reflection": this is not verified in the experiment result; currently, the paper misses key baselines which applies those "simpler ways". While Fig. 5 provides some ablation, there is no formal results with baseline using the same number of candidates. There is also no report on the total token / function call consumption of each baseline (Fig. 3 reports the time consumption, but it does not reflect the actual usage of tokens as trajectories can be produced in parallel to reduce time).

  3. Regarding line 103-104: The question asked in your paper is "Is recursion itself the key ingredient for long-context reasoning, or is the real bottleneck how we select among candidate interaction programs under uncertainty"? My point is:

a) Since adding recursiveness to both RLM and SRLM both improves performance, I think it can be called a key ingredient for long-context reasoning; it's just that it works better with SRLM. Maybe recursiveness is not the sole or most important ingredient, but it still can be listed as a key ingredient.

b) to select some candidate under uncertainty, one must have multiple candidates to choose from. However, the most important baseline, RLM, does not have such candidates of parallel trajectories to begin with. Thus, I think "selecting candidates as a bottleneck" (if we are allowed to do parallel runs) has no contradiction with the statement "recursion is the key ingredient for long-context reasoning (on the RLM's setting where one is not allowed to do parallel runs)". They should not be connected with the word "or".

c) In your response to the other reviewers, you mention "each RLM score is the average over 8 samples, so RLM and SRLM draw on the same number of trajectories." This comparison is unfair - 8 samples for RLM is essentially 8 independent trials while only 1 trial for SRLM. A fair comparison would be using majority@8 (especially for multiple choice benchmarks) or any other "simpler ways" to aggregate the result (e.g. self-reflection). The performance of SRLM against majority@8 (+self consist.) seems relatively limited in Fig. 5.

Reviewer_SWFvOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes Self-Reflective Program Search for Long Context , an inference-time framework that improves long-context reasoning by selecting context-interaction programs using three uncertainty signals. Experiments on LongBench-v2, BrowseComp+, and OOLONG demonstrate improvements over RLMs across different backbone models and context lengths. The paper further investigates the role of recursion and suggests that uncertainty-guided program selection can be an effective alternative to explicit recursive reasoning.

Critical strengths

1.The paper investigates an interesting and important question regarding the role of recursion and trajectory selection in long-context reasoning.

2.The experiments cover multiple benchmarks, backbone models, and context lengths, providing useful empirical insights into the effectiveness of SRLM.

Critical weaknesses
  1. Insufficient comparison with compute-matched sampling baselines. SRLM samples eight candidate trajectories, while the RLM baseline does not appear to use an equivalent multi-trajectory selection procedure. Therefore, it remains unclear whether the improvements mainly come from the proposed uncertainty-guided selection mechanism or simply from additional inference-time sampling.

  2. Insufficient justification of the uncertainty-guided scoring function. The joint score is defined as the product of accumulated log-confidence and reasoning trace length, but the motivation for this particular formulation is not sufficiently explained. Moreover, the paper states that lower scores indicate better candidates while selecting the trajectory using an argmax operation, which appears inconsistent.

  3. The conclusion regarding the limited importance of recursion is not fully supported. The paper argues that recursion is not the primary driver of performance in RLMs, based mainly on comparisons between recursive RLM and nonrecursive SRLM. However, these methods differ in both their recursion mechanisms and trajectory-selection strategies, making it difficult to isolate the contribution of recursion itself.

Questions for authors

1.How does SRLM compare with RLM using the same number of sampled trajectories and a standard majority-voting strategy under matched inference-time budgets?

2.Could the authors clarify the optimization direction of the joint uncertainty score and explain why a multiplicative formulation is preferred over alternative combinations?

2 comments
AuthorsOpenReview ↗

Response to reviewer SWFv (1)

Thank you for dedicating your time and expertise to review our submission. Please find our responses below.

  1. The paper investigates an interesting and important question regarding the role of recursion and trajectory selection in long-context reasoning.
  2. The experiments cover multiple benchmarks, backbone models, and context lengths, providing useful empirical insights into the effectiveness of SRLM.

Thank you for recognizing the strengths and novelty of our work.

  • How does SRLM compare with RLM using the same number of sampled trajectories and a standard majority-voting strategy under matched inference-time budgets?
  • Insufficient comparison with compute-matched sampling baselines. SRLM samples eight candidate trajectories, while the RLM baseline does not appear to use an equivalent multi-trajectory selection procedure. Therefore, it remains unclear whether the improvements mainly come from the proposed uncertainty-guided selection mechanism or simply from additional inference-time sampling.

Thank you for raising this point for discussion. We would like to clarify that the baseline reviewer asks for ("same-sample RLM with standard majority voting") is already reported in Figure 5 (purple bar). Fig. 12(a) in the appendix also breaks this out for runs with recursive sub-calls. Also, it's important to note that the RLM numbers reported in paper are not single-sample results: each RLM score is the average over 8 samples, so RLM and SRLM draw on the same number of trajectories. We will make sure to state this clearer in the paper.

Insufficient justification of the uncertainty-guided scoring function. The joint score is defined as the product of accumulated log-confidence and reasoning trace length, but the motivation for this particular formulation is not sufficiently explained. Moreover, the paper states that lower scores indicate better candidates while selecting the trajectory using an argmax operation, which appears inconsistent.

Thank you for the comment. We would like to highlight that most of the uncertainty quantification metrics in LLM literature are in fact heuristic (including self-consistency [1], verbalized confidence [2], and trace-length-based uncertainty [3], or their integrations) and our metric is also built motivated by these prior works. The contribution of this paper is not that the scoring function has a strong theoretical grounding, but that these three signals are complementary and that their combination provides a better self-reflection signal than any individual signal alone in the scope of long context interaction.

On the direction of the score, it's important to note that since VC(p) ≤ 0 (log of probabilities) and Len(p) > 0, s(p) ≤ 0, so the best candidates are those with scores closest to zero and that is why argmax is the right operator here. We are sorry that the writing has caused confusion and have modified writing to make it clear.

References:

[1] Self-Consistency Improves Chain of Thought Reasoning in Language Models, 2022

[2] Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation in LLMs, 2023

[3] Trace Length is a Simple Uncertainty Signal in Reasoning Models, 2025

The conclusion regarding the limited importance of recursion is not fully supported. The paper argues that recursion is not the primary driver of performance in RLMs, based mainly on comparisons between recursive RLM and nonrecursive SRLM. However, these methods differ in both their recursion mechanisms and trajectory-selection strategies, making it difficult to isolate the contribution of recursion itself.

We are not fully sure we have understood the concern of this reviewer's comment, we appreciate if the reviewer can let use know if any further clarification from us could help.

We would like to highlight that this paper does not claim that recursion is not the primary driver of performance in RLMs , the main message is that programmatic interaction is a new way of handling long context through inference-time compute, and the choice of inference-time scaling approach plays an important role here. There could be different ways to spend additional inference compute for this purpose, we can spend additional inference compute through recursion sub-calls (sub-agent setting) or we can spend that compute through simpler ways like best of N and self-reflection, similar to the step-wise uncertainty-based self-reflection we have in SRLM. We wanted to share the insight that even simpler inference-time scaling approaches could be as effective or even better than the recursion in this long context interaction setting, which has been proposed as the fundamental ingredient for long context handling based on the claim of "recursive" language models.


We hope that our rebuttal address the reviewer's concerns, and if so, they would consider updating their score. We'd be more than happy to engage in further discussions

AuthorsOpenReview ↗

Message from Authors

Dear Reviewer SWFv,

If there were any leftover concerns, we would sincerely appreciate the opportunity to clarify them before the discussion period for the authors ends. We believe our responses have addressed in detail the full set of questions/concerns you raised. Thank you for your time and thoughtful feedback!

Reviewer_rosfOpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper introduces Self-Reflective Program Search for Long Context (SRLM), an inference-time framework for selecting programmatic context-interaction trajectories. Building on Recursive Language Models (RLMs), SRLM samples multiple candidate programs and uses three intrinsic signals—answer self-consistency, verbalized confidence, and reasoning trace length—to select a trajectory without external supervision. The paper evaluates recursive and nonrecursive variants using GPT-5 and Qwen3-Coder-480B on OOLONG, BrowseComp+, and LongBench-v2. It reports improvements over RLM and argues that programmatic context interaction and trajectory selection, rather than recursion alone, account for much of the benefit in long-context reasoning.

Critical strengths

Relevant research question about inference-time context interaction. The paper investigates whether explicit recursion is necessary for effective long-context reasoning or whether alternative trajectory-selection strategies can provide comparable benefits. Separating the effects of context externalization, recursive calls, and inference-time search is a useful research direction.

Lightweight approach without additional model training. The proposed signals are derived from sampled outputs and generation statistics, requiring neither a trained reward model nor annotated process supervision. If validated, this would make the approach relatively accessible to existing programmatic reasoning systems.

Evaluation across multiple backbones, context lengths, and task domains. The experiments include both GPT-5 and Qwen3-Coder-480B, recursive and nonrecursive settings, and contexts ranging from thousands to millions of tokens. Extending LongBench-v2 evaluation beyond CodeQA provides a broader assessment than relying exclusively on search-oriented tasks.

Potentially useful observations about the limitations of recursion. The reported results suggest that recursive sub-calls are not uniformly beneficial and that their effects depend on the backbone and task. These observations could inform the design of more efficient long-context systems, provided that inference budgets and sub-model choices are adequately controlled.

Critical weaknesses

The stated selection algorithm makes confidence and trace length irrelevant to the final answer. Section 2.2.1 first selects the plurality answer (\hat a) and restricts candidates to [ S={p:\operatorname{out}(p)=\hat a}. ] Section 2.2.2 then selects (p^\in S) using confidence and trace length and returns (\operatorname{out}(p^)). Consequently, the final prediction must remain (\hat a), regardless of the confidence–length score. Under the described procedure, the last two signals cannot improve answer accuracy beyond self-consistency on the same candidate pool. This conflicts with the component ablations. The manuscript does not specify an intermediate selection-and-continuation mechanism that would resolve this issue. There is also a directional inconsistency: the text states that lower scores are better, while the equation uses an argmax.

The claimed inference-budget fairness is insufficiently established. SRLM samples eight candidate trajectories, whereas the experimental setup does not clearly establish an equivalent sampling and resource allocation for RLM and other baselines. A shared 600-second limit per trajectory step does not establish an equal end-to-end wall-clock budget, particularly if candidates run in parallel. The paper needs explicit concurrency, total model-call counts, token usage, and monetary or compute costs. A critical missing control is eight-sample RLM with ordinary self-consistency under the same budget. Without it, improvements may reflect additional sampling rather than uncertainty-guided selection.

The uncertainty interpretation is not sufficiently validated, and the combined score confounds confidence with trajectory length. The verbalized-confidence score sums log confidence across steps, so it already penalizes trajectories with more steps. Multiplying it by total token length introduces another length dependence. The resulting preference for short, high-confidence trajectories is not sufficient evidence that the score measures epistemic uncertainty or semantic understanding. The paper does not establish calibration or within-question candidate-ranking quality, and pooled accuracy plots can be confounded by task difficulty. Length-normalized confidence, confidence-only, length-only, and simple voting controls on identical candidate pools are needed.

The evaluation and recursion-related conclusions require stronger controls and uncertainty estimates. Several headline comparisons use only 50 tasks, without reported confidence intervals or repeated-run variability. The manuscript also introduces an LLM judge across benchmarks, including multiple-choice LongBench-v2, while OOLONG uses a numerical partial-credit metric; the relationship between official scoring and judge-based scoring is not fully specified. Finally, recursive calls use GPT-5-mini, including with a stronger GPT-5 root model. Performance degradation could therefore reflect weaker sub-models or information loss rather than a general limitation of recursion. These issues weaken both the empirical reliability and the broader causal interpretation.

Questions for authors

Regarding Weakness 1: After restricting candidates to programs producing the same plurality answer, how can confidence- and length-based selection change the final prediction? Please provide executable pseudocode and explain whether selection occurs before trajectory completion, whether selected programs undergo further generation, or whether the implementation differs from the equations. Please also reconcile the “lower is better” statement with the argmax.

Regarding Weakness 2: Could you compare SRLM against eight-sample RLM with ordinary self-consistency using identical candidate-generation settings, concurrency, and total resource budgets? Please report end-to-end latency, total input/output tokens, root/sub-model calls, and API cost, and clarify how the per-step timeout yields the claimed matched wall-clock comparison.

Regarding Weakness 3: Could you evaluate the signals’ calibration and their ability to rank correct versus incorrect candidates within the same question? Please include mean log-confidence, length-only, confidence-only, and combined-score controls on fixed candidate pools to separate uncertainty information from the score’s built-in preference for shorter trajectories.

Regarding Weakness 4: Could you report official benchmark scores alongside judge-based scores, explain how numerical partial credit is handled, and provide paired confidence intervals and repeated-run results? For the recursion analysis, could you additionally control sub-model strength—for example, by using the same model for root and sub-calls—before attributing degradation to recursion itself?

3 comments
AuthorsOpenReview ↗

Response to reviewer rosf (1)

Thank you for dedicating your time and expertise to review our submission. Please find our responses below.

  • Relevant research question about inference-time context interaction. The paper investigates whether explicit recursion is necessary for effective long-context reasoning or whether alternative trajectory-selection strategies can provide comparable benefits. Separating the effects of context externalization, recursive calls, and inference-time search is a useful research direction.
  • Evaluation across multiple backbones, context lengths, and task domains. The experiments include both GPT-5 and Qwen3-Coder-480B, recursive and nonrecursive settings, and contexts ranging from thousands to millions of tokens. Extending LongBench-v2 evaluation beyond CodeQA provides a broader assessment than relying exclusively on search-oriented tasks.
  • Potentially useful observations about the limitations of recursion. The reported results suggest that recursive sub-calls are not uniformly beneficial and that their effects depend on the backbone and task. These observations could inform the design of more efficient long-context systems, provided that inference budgets and sub-model choices are adequately controlled.

Thank you for recognizing the strengths and novelty of our work.

  • Several headline comparisons use only 50 tasks, without reported confidence intervals or repeated-run variability.
  • The manuscript also introduces an LLM judge across benchmarks ... ; the relationship between official scoring and judge-based scoring is not fully specified.
  • recursive calls use GPT-5-mini, including with a stronger GPT-5 root model. Performance degradation could therefore reflect weaker sub-models rather than a general limitation of recursion.

Thank you for the comment. We address each concern below:

  • Evaluation scale and protocol. Our evaluation protocol follows the original RLM paper, so our results can be compared directly with prior work. We even go beyond it and extend our evaluation to more LongBench-v2 domains and more OOLONG context lengths ((than just CodeQA and 131k in the original paper).
  • LLM judge and evals. We use an LLM judge to make scoring robust to how answers are formatted. Rule-based answer extraction can mark a correct answer wrong just because it is phrased differently, and this penalizes some methods more than others. The judge’s task is quite simple here: it only checks whether the LLM final answer matches the ground truth. So it adds very little judgment of its own while removing errors caused by formatting. In response to reviewer's comment, we also measured agreement between the judge and human scoring among 50 random samples and found complete agreement.
  • GPT-5mini as sub-model choice. The pairing of GPT-5mini as recursive model for GPT-5 as root was not our choice and was borrowed from the RLM original evaluation protocol for fair comparison.

The uncertainty interpretation is not sufficiently validated, and the combined score confounds confidence with trajectory length. The verbalized-confidence score sums log confidence across steps, so it already penalizes trajectories with more steps. Multiplying it by total token length introduces another length dependence. The resulting preference for short, high-confidence trajectories is not sufficient evidence that the score measures epistemic uncertainty or semantic understanding. The paper does not establish calibration or within-question candidate-ranking quality, and pooled accuracy plots can be confounded by task difficulty. Length-normalized confidence, confidence-only, length-only, and simple voting controls on identical candidate pools are needed.

We are not fully sure we have understood the concern of reviewer, so please let us know if further clarification would help.

First to clarify, the two terms measure different aspects of the reasoning process. Summing log-confidence over steps reflects how many uncertain steps the model needed, while token length reflects how much deliberation each step took. A trajectory may involve only a few steps with lengthy, hedging generations, or many short steps. Our scoring function does not simply favor shorter trajectories and as it can be observed in Fig. 5 top and Fig. 12, the length-only variant show very different behavior than other baselines.

Also, we would like to highlight that most of the uncertainty quantification metrics in LLM literature are in fact heuristic and our metric is also built motivated by these prior works. The contribution of this paper is not that the scoring function has a strong theoretical grounding, but that these three signals are complementary and that their combination provides a better self-reflection signal than any individual signal alone in the scope of long context interaction.

AuthorsOpenReview ↗

Response to reviewer rosf (2)

The stated selection algorithm makes confidence and trace length irrelevant to the final answer. Section 2.2.1 first selects the plurality answer (\hat a) and restricts candidates to [ S={p:\operatorname{out}(p)=\hat a}. ] Section 2.2.2 then selects (p^\in S) using confidence and trace length and returns (\operatorname{out}(p^)). Consequently, the final prediction must remain (\hat a), regardless of the confidence–length score. Under the described procedure, the last two signals cannot improve answer accuracy beyond self-consistency on the same candidate pool. This conflicts with the component ablations. The manuscript does not specify an intermediate selection-and-continuation mechanism that would resolve this issue. There is also a directional inconsistency: the text states that lower scores are better, while the equation uses an argmax.

Thank you for raising thoughtful questions. We would like to clarify that in SRLM, the three signals work at different levels. Verbalized confidence and reasoning length are applied per step: they guide which intermediate steps are kept as each context-interaction trajectory is built. Self-consistency is applied over the full sequence of steps, based on the final answers of the completed trajectories. They are not a re-ranking inside a fixed answer group, so the reviewer's statement that “the last two signals cannot improve answer accuracy beyond self-consistency” is not correct as with these signals, the candidate pool itself can be different. This also explains our component ablation results in Fig. 5. We agree that our current writing could be clearer and thank reviewer for bringing this to our attention. We have now revised Section 2.2 to state where each signal acts, and we added a short algorithm description to make the procedure clear for reader.

On the direction of the score, it's important to note that since VC(p) ≤ 0 (log of probabilities) and Len(p) > 0 , s(p) ≤ 0 , so the best candidates are those with scores closest to zero. That is why argmax is the right operator. To clarify this for reader, we have changed writing to say “values closer to zero indicate better candidates”.

The claimed inference-budget fairness is insufficiently established. SRLM samples eight candidate trajectories, whereas the experimental setup does not clearly establish an equivalent sampling and resource allocation for RLM and other baselines. A shared 600-second limit per trajectory step does not establish an equal end-to-end wall-clock budget, particularly if candidates run in parallel. The paper needs explicit concurrency, total model-call counts, token usage, and monetary or compute costs. A critical missing control is eight-sample RLM with ordinary self-consistency under the same budget. Without it, improvements may reflect additional sampling rather than uncertainty-guided selection.

Thank you for raising this point for discussion. We would like to clarify that the key control baseline reviewer asks for ("8-sample RLM with ordinary self-consistency") is already reported in Figure 5 (purple bar). Fig. 12(a) in the appendix also breaks this out for runs with recursive sub-calls. Also, it's important to note that the RLM numbers reported in paper are not single-sample results: each RLM score is the average over 8 samples, so RLM and SRLM draw on the same number of trajectories. We will make sure to state this clearer in the paper.

In response to reviewer's comment on the costs beyond latency, we have also computed cost estimates for the Qwen3-Coder-480B which are shown below. Using per-step tokens derived from the original RLM paper, and scaling by K for SRLM without sub-calls, we obtain the following worst-case cost per query:

DatasetSRLM (no sub-call, K=8)RLM (depth 1)RLM (depth 3)
LongBench-v2 CodeQA$1.44 (0.18×8)$0.92$1.65
BrowseComp+ (1K)$6.56 (0.82×8)$0.86$1.10
OOLONG$2.56 (0.32×8)$0.60$0.80

These numbers show that SRLM without sub-calls is slightly more expensive than RLM in token terms, particularly on BrowseComp+ where the gap is largest. However, it's important to note that the 8x linear cost intuition represents a worst-case upper bound rather than the practical overhead. In reality, SRLM without sub-calls samples candidate programs per step; each candidate is a shorter generation that is filtered before proceeding to the next step, so costs do not multiply fully across the entire interaction. Meanwhile, RLM with recursion also issues multiple sequential sub-calls that each consume additional tokens on top of the base trajectory.


We hope that our rebuttal address the reviewer's concerns, and if so, they would consider updating their score. We'd be more than happy to engage in further discussions.

AuthorsOpenReview ↗

Message from Authors

Dear Reviewer rosf,

If there were any leftover concerns, we would sincerely appreciate the opportunity to clarify them before the discussion period for the authors ends. We believe our responses have addressed in detail the full set of questions/concerns you raised. Thank you for your time and thoughtful feedback!

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.