acceptodds
Under review as a conference paper at ICLR 2027

-RLM: Statically Restricted Control for Recursive Long-Context Reasoning

Abstract

Long context is not synonymous with reliable reasoning: relevant evidence is easily lost, while standard Recursive Language Models (RLMs) address the problem by asking the model to generate and execute its own control code. This open-ended strategy extends effective context, but introduces malformed programs, unpredictable cost, and uncontrolled recursion. We introduce -RLM, a structured alternative that expresses recursive reasoning as a closed -calculus program over a compact library of compositional operators. The language model is invoked only on bounded leaf subproblems; decomposition, filtering, traversal, and aggregation follow a fixed plan that can be inspected before execution. This separation guarantees termination, bounds the number of model calls (leaves, plus one per internal node under neural composition) and hence their cost, and supports task-appropriate accuracy analyses for both conjunctive and retrieval settings. Across five long-context benchmarks and nine open-weight models, five-seed comparisons, -RLM improves accuracy most strongly for weak and medium models while reducing latency by on average and up to . These results show that explicit functional control can make recursive long-context reasoning faster, more reliable, and easier to analyze without increasing model scale.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Lambda Calculus, Context Rot

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.25 over 4 reviews, above 96% of the others.
Reviewer_STfLOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes λ-RLM, a fixed recursive workflow for long-context tasks. It replaces model-generated control code with predefined operators for splitting inputs, processing parts, and combining results. Across five benchmarks and nine models, the paper reports accuracy gains, especially for smaller models, and a 4× average speedup. It also analyzes termination, model-call counts, and accuracy under stated assumptions.

Critical strengths
  1. The paper addresses a useful and interesting question: when does restricting a model's control improve reliability and efficiency?
  2. The experiments are comprehensive and cover nine different models with diverse tiers and behaviors. The paper reports accuracy gains, especially for smaller models, and a 4× average speedup. Table 7 supports the value of restricting control within the tested system.
  3. Fixed workflows make execution easier to inspect, and the paper acknowledges weaker gains on stronger models and open-ended tasks.
  4. The method works with existing model weights, so its gains do not require additional model training.
  5. The accuracy analysis distinguishes tasks that need every part correct from retrieval tasks that need one relevant part.
Critical weaknesses
  1. Some of the largest gains do not match how the method is described, so it is unclear what produced them. According to Algorithm 2, if the input fits in the model's context window, λ-RLM does not split it. Apart from a short task-type call, it sends the whole input to the model in one call, which is what the Direct baseline also does. So on inputs that fit, λ-RLM and Direct should get about the same score. The results show large gaps instead. On OOLONG-Pairs, for models with a 128K window, almost all inputs fit, yet Direct scores near zero while λ-RLM scores around 30–65 (Table 3). On S-NIAH, Qwen3-8B with Direct averages 3.2 over up to five input lengths, so it can score at most about 16 at any length. Yet Table 5 reports a leaf accuracy of 0.70 for the same model on single 32K pieces. The two numbers are not the same metric, but the gap is too large to be explained by that alone. Together, these results suggest that the λ-RLM calls and the Direct calls differ in prompt, answer parsing, or scoring. Two reporting problems add to my concern. First, some numbers are reported both as an average over all input lengths and as the result for one input length, which is a bit confusing to me. For example, Qwen3-8B's 48.3 on OOLONG is the Table 3 average over all lengths, but Tables 6, 7, and 12 label it as the 131K result. Second, the paper uses paired two-sided permutation tests over five seeds. If the five seed results are the paired units, the smallest possible p-value of an exact test is 2/32 ≈ 0.06, so no result should be significant at 0.05.
  2. It is unclear whether the gains come from fixed control or from the hand-written plan for each task. The authors write a plan by hand for each task, and λ-RLM mostly runs it as a single split-then-combine step. The gains are largest where the plan already does much of the work. On OOLONG-Pairs, the model only labels records, and fixed code builds the pairs. On CodeQA, where the plan is generic, λ-RLM scores lower than RLM for all three strong models. The paper does not separate these two factors. Its ablation and PlanGen baseline each use only one model and one task, and it does not cite or compare with similar split-then-combine methods such as LLM×MapReduce and Chain-of-Agents. Testing on tasks without a ready-made plan, such as LongHealth or Harvey's Legal Agent Benchmark (LAB), would also show whether the method generalizes.
  3. The paper's motivation is only weakly supported by the reported evidence. The paper motivates the method with two claims: (1) Free-form RLM fails because of code and control errors and (2) Shorter chunks avoid context rot. Neither is well-supported. RLM's failures are never broken down by cause (for example, malformed code, runaway recursion, or wrong answers), so we cannot tell whether simpler fixes, such as retrying on error, would close the gap. For context rot, shorter chunks actually hurt. In Table 6, cutting leaves from 26.2K to 8.2K tokens drops OOLONG accuracy from 48.3 to 1.4.
  4. The 4× speedup is not shown under comparable resources. Although Section 6 says call counts are reported, the paper has no call counts for RLM and no token counts for any method. Only a few λ-RLM leaf counts appear (e.g., Tables 5 and 6). There is also no matched compute budget, and it is unclear whether the models ran on local vLLM or through free APIs, where latency depends on queueing and rate limits, which affects every task. In addition, the BrowseComp+ and S-NIAH plans filter inputs with cheap previews before the model reads them, but no ablation removes this filter, so part of the speedup on these two tasks may come from the filter.
  5. The conceptual novelty is also limited: the authors themselves state that the λ-calculus is only a specification language, that an ordinary verified function could give the same guarantees, and that the gains come from restricting control rather than from the notation.
Questions for authors
  1. Table 7(d) gives free-form code access to the combinators on Qwen3-8B × OOLONG. How does RLM perform when given the same combinators and a plan description on the other models and tasks? Does PlanGen use the λ-RLM executor to run its plan?
  2. On OOL-Pairs, how many pairs does each method produce, and how many does the task require? Does the gain remain when all methods have room to return all required pairs? Pair F1 penalizes both wrong pairs and missing pairs. Can you split the near-zero OOL-Pairs scores into early stopping, input limits, formatting errors, and wrong classification? Without this, the gap does not show how much better the method reasons.
  3. What limits on parallel requests, steps, and generated text apply to each method? How many calls and tokens does each use? Were the models served on local vLLM or through free APIs? What recursion depth is reached on each task, especially CodeQA?
  4. Does the model combine two child results per call, or all child results in one call? What happens when a leaf or composition prompt exceeds the context limit?
  5. What share of RLM failures are code errors, timeouts, or runaway recursion, and what share are wrong answers?
7 comments
AuthorsOpenReview ↗

Response to Reviewer STfL

Thanks for the insightful comments. We have addressed and comments. Please find our response to weakness (W) and questions (Q) below.

W1. Short-circuit behavior and experimental reporting. The short-circuit was active in the Table 3 runs. λ-RLM uses a 32K prompt-length threshold, so 64K and 128K inputs trigger decomposition even when they fit within the backbone’s native context window. For prompts at or below the threshold, λ-RLM makes one task-selection call and one solver call using the selected task template. Direct sends the raw benchmark prompt in one call. Both methods use the same final-answer parser and scorer. Algorithms 2 and 3 now show the templated call explicitly. Table 17 reports single-seed per-bucket scores for Llama-3.1-8B, while Table 3 reports five-seed aggregates. Routing in the nominal 32K bucket depends on the actual prompt length.

For Qwen3-8B on S-NIAH, 3.2 for Direct and 24.6 for λ-RLM are end-to-end F1 scores averaged across input lengths. The 0.70 in Table 5 is λ-RLM’s solver accuracy on the relevant 32K leaf containing the evidence. End-to-end evaluation also requires locating that evidence in the full input. A matched comparison of raw and templated prompts on the same leaves would quantify the template’s contribution.

The 131K label identifies the example used to illustrate the planner settings. The repeated 48.3 is the bucket-averaged Table 3 score. We clarified the captions and revised the win–tie–loss wording to report 36 higher five-seed means for λ-RLM and nine for RLM. With five paired seeds, the smallest attainable exact two-sided permutation p-value is 0.0625. Appendix D.10 provides standard deviations and p-values in Table 22 and individual seed scores in Tables 23–27.

W2. Fixed control and hand-designed plans. On Qwen3-8B × OOLONG, Table 7 holds the combinator library fixed. Fixing the plan before execution yields 48.3, compared with 40.2 when the model can reselect the plan at each turn. This 8.1-point difference measures the effect of plan fixity in that setting. The OOLONG-Pairs gains also include the benefit of symbolic pair construction, discussed in Q2.

On LongHealth, a benchmark outside the six predefined task types, the same executor achieved 76.0% with a generic split–map–reduce plan and 76.7% with a validated model-generated plan on Mistral-7B. RLM achieved 63.2%, and Chain-of-Agents, the strongest split-and-combine baseline, achieved 68.0% (Appendix D.8, Table 19). Both λ-RLM variants ran without a hand-written LongHealth plan. Table 21 also shows that λ-RLM outperforms fixed chunk–map–reduce, LLM×MapReduce, and Chain-of-Agents on OOLONG and OOLONG-Pairs at 32K with both Llama-3.1-8B and Mistral-7B. On CodeQA, λ-RLM with the generic summarise plan has the higher mean on five of nine models, while RLM leads on all three strong models.

W3. Execution failures and leaf size. Code or control errors were the primary cause in 17 of 20 free-form RLM runs in the Llama-3.1-8B OOLONG-Pairs diagnostic. Restarting ten runs that showed an error signal left their mean F1 at 0.0% (Appendix D.11). Q5 gives the breakdown.

In the OOLONG ablation, reducing leaf size from 26.2K to 8.2K lowered measured leaf accuracy from 0.85 to 0.76. Shorter chunks can split records across boundaries. For the representative 131K input, the same fan-out change increased the leaf count from five to sixteen, so the aggregate depended on more leaf outputs being correct. The observed score across buckets fell from 48.3 to 1.4 (Tables 6 and 12). This motivates choosing a leaf size that preserves the evidence needed for the task.

W4. Scope of the speedup. The 4.0× figure is the ratio of mean end-to-end wall-clock latencies across the 45 Table 3 cells under the same hosted setup. Timing includes intermediate calls, network time, and API queueing.

On 32 S-NIAH questions in the 32K bucket with Llama-3.1-8B, λ-RLM without preview filtering was 2.46× as fast as RLM. Enabling filtering provided a further 1.67× speedup within λ-RLM (Appendix D.13, Table 30). Uncapped RLM used nearly twice as many tokens per question as unfiltered λ-RLM (60,719 versus 32,089) and scored lower (8.5% versus 16.7% F1). Capping RLM near λ-RLM’s mean token use reduced RLM’s F1 further to 5.1%, with realized usage of 26,706 tokens per question. This comparison is specific to the S-NIAH diagnostic. Benchmark-wide RLM call and token totals were unavailable for Table 3, and the filter’s separate effect on BrowseComp+ remains unmeasured.

Response to W5 and Questions continued in next comments.

AuthorsOpenReview ↗

Response to Reviewer STfL (continued 1)

Q1. How does free-form RLM perform with the same combinators and a plan description? Does PlanGen use the λ-RLM executor?

We gave free-form RLM both the λ-RLM combinators and a plan description on the same 20 Llama-3.1-8B OOLONG-Pairs questions at 32K. Both variants scored near zero. Plain RLM’s 2.3% mean pair F1 came almost entirely from partial recovery on one question. The assisted variant scored 0.0% at a mean latency of 893 s. Nine assisted runs produced no runnable code, and ten more ended with a code exception and empty answer, an iteration cap, or a time limit. The model still had to translate the plan into executable control code (Appendix D.12, Table 29). In the separate Qwen3-8B × OOLONG ablation, adding combinator access raised free-form RLM’s score from 24.1 to 31.7, while full λ-RLM scored 48.3 (Table 7).

The original PlanGen baseline runs its generated plan as written, outside the λ-RLM executor. The LongHealth generated-plan variant validates and freezes its plan before running it through the λ-RLM executor.

Q2. How many pairs are required and returned, and does the gain persist when all methods have enough output capacity?

For the sampled dense queries, the median gold answer contains 193, 850, 4,698, 15,679, and 63,915 pairs at 8K, 16K, 32K, 64K, and 128K, respectively. Every sampled query at 32K and above requires more than 4,096 output tokens to enumerate all gold pairs. At 128K, the median sampled gold list requires approximately 511K output tokens (Appendix D.7, Table 18). In that bucket, λ-RLM achieves 46.6 F1 versus 0.1 for Direct on Llama-3.1-8B (Appendix D.6, Table 17). On split inputs, λ-RLM predicts record labels and constructs the pairs symbolically, allowing the final list to exceed the per-call generation cap.

In the 20-question RLM diagnostic at 32K, one run recovered 2,487 of 5,356 gold pairs. Another reached the iteration cap and returned 50 pairs, two of which were correct. The remaining 18 recovered zero correct pairs (Appendix D.11, Table 28). The traces show no confirmed failure due to the output-token limit. The single API timeout may have been related to output length, and its cause remains uncertain. Code and control failures accounted for 17 of 20 runs, including two input-context overflows. These traces suggest that λ-RLM’s advantage over free-form RLM would likely persist in this diagnostic if both could return the complete pair list, since increasing output capacity alone would leave the predominant failure modes in place.

For Direct, we expect the gap to narrow if the model can process the full input and generate the complete pair list. The current cap limits attainable recall on dense queries. The size of the reduction remains unmeasured, as do returned-pair counts and failure breakdowns across all methods and buckets.

Q3. What were the serving setup, execution limits, and actual resource use?

All Table 3 runs used the free tier of a hosted inference API, with the same endpoint, backbone, and decoding settings within each model–task cell. Each model call could generate up to 4,096 output tokens. Direct used one call for inputs that fit. RLM had a depth cap of 2, 10 iterations per call, and up to 16 concurrent calls. λ-RLM calls ran sequentially (Appendix D.1).

Tables 30–31 report resource use for the targeted diagnostics. On the Llama-3.1-8B S-NIAH subset, plain RLM averaged 15 calls and 60,719 tokens per question. λ-RLM averaged 32,089 tokens without filtering and 20,293 with filtering. On CodeQA, RLM averaged 13 calls and 40,255 tokens at the 10-iteration limit. Raising the limit to 30 increased these means to 27 calls and 169,308 tokens, and accuracy on the 23 questions rose from 21.7% to 30.4%. Counting the root as depth 0, the deepest observed RLM call in these S-NIAH and CodeQA diagnostics was at depth 1.

Q4. How are child outputs composed, and what happens on context overflow?

For neural composition, the executor concatenates all child outputs at a node and sends them to the model in one call. Symbolic composition, including count merging, search-result selection, and pair construction, uses no model call. The planner limits leaf size and caps neural fan-in using the composition budget. Theorem 1 assumes that the resulting prompts fit within the applicable limit. The runtime behavior for an oversized formatted leaf or composition prompt remains unspecified in the manuscript.

Q5 and W5 continued in next comment

AuthorsOpenReview ↗

Response to Reviewer STfL continued 2)

Q5. What caused the RLM failures?

On Llama-3.1-8B × OOLONG-Pairs at 32K, the primary causes across 20 RLM runs were code errors in 5/20 (25%), control failures in 12/20 (60%), an API timeout in 1/20 (5%), and wrong answers after error-free execution in 2/20 (10%). The control failures comprised six iteration-cap failures, four runaway execution loops stopped at the time limit, and two input-context overflows. The diagnostic used a recursion depth cap of one. Restarting ten runs with an error signal improved none of them, and their mean F1 remained 0.0% (Appendix D.11, Table 28).

W5. Conceptual contribution. λ-RLM makes recursive inference analyzable before execution begins. Once a plan is instantiated, the executor enforces its splitting, stopping, and composition rules. The model solves bounded subproblems and performs neural composition where specified. Its outputs can affect the answer, while the executor retains control over how the computation proceeds. Under the stated assumptions, one termination and model-call analysis applies across all admissible plans. The λ-calculus states the invariants explicitly, so any runtime that enforces them can inherit the same guarantees.

Reviewer_4QyAOpenReview ↗
Rating
2(+1)
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper revisits Recursive Language Models (RLM; Zhang et al., 2025), in which the model writes its own REPL code to break up long inputs, and replaces this free-form control with a fixed executor. An LLM first picks one of six task types. A lookup table then returns a hand-designed plan built from split, map, filter and reduce combinators, written in λ\lambda-calculus notation, and the model is only called on bounded pieces of the input. Because the control is fixed, the paper can prove termination, bounds on the number of calls and on cost, and accuracy bounds under stated assumptions.

The experiments cover five long-context benchmarks and nine open-weight models, compared with direct prompting and RLM. The paper reports 36 significant wins out of 45 over RLM from paired five-seed tests (p.6), about +13 accuracy points and roughly 4×4\times lower latency, and it lists the cells where RLM does better (Table 15).

References:

  • Zhang, A. L., Kraska, T., and Khattab, O. Recursive language models. arXiv:2512.24601, 2025.
Critical strengths
  1. A clear question, and a sensible answer to a known weakness of recursive reasoning systems: when the model writes its own control code, execution is hard to predict and analyze. Fixing the control in advance means that termination and the number of model calls are known before running (Thm 1), with an exact cost expression (Thm 2), however well or badly the model codes. This matters most for small models. The paper is also candid about its limits. It says the λ\lambda-notation is not essential and the plans are hand-designed (pp. 4, 11), calls the accuracy analysis "conditional rather than universal" (p.9), and reports the cells where RLM (Zhang et al., 2025) wins. The question is worth asking and the cost guarantees are real, if elementary, but in my view the evidence does not yet answer the empirical question.
Critical weaknesses
  1. The main claims of the paper are not supported by the reported results. The algorithm as written returns the direct call whenever the prompt fits in the context window ("direct call, no decomposition needed"; Alg. 2, l.5–6, p.3; Alg. 3, l.6–7). Five of the nine models have a 128K window (Table 8), and S-NIAH, OOLONG and OOL-Pairs are run at 8K–128K (Table 9), so on these models every input fits and λ\lambda-RLM should behave exactly like Direct. Yet Table 3 shows large differences, for example 0.1 vs 31.6 for Llama-8B on OOL-Pairs. In four such cells λ\lambda-RLM is even faster than Direct, although it makes the same call plus a menu call (Llama-405B on S-NIAH: 28.1 s vs 48.6 s).

    The protocol cannot be checked either. Each configuration is said to be run with five seeds and compared with paired tests (p.6, p.16), but no standard deviations, confidence intervals, p-values or per-seed results are reported. Results labelled as single-length runs ("Qwen3-8B ×\times OOLONG 131K") are identical to Table 3 cells that p.16 describes as macro-averages over length buckets. Serving is described both as "vLLM on 8×8\timesH100 nodes" (p.16) and as "free API services" (p.18), and leaf parallelism is not stated, which makes the latencies hard to interpret. Table 3, the 36/45 wins and the 4×4\times speedup are the paper's headline evidence, so either the evaluated system differs from the one described or the numbers need correcting.

  2. Even taken at face value, the gains cannot be separated from the hand-designed plans, and it is unclear how the approach would carry over to new tasks. Each task type maps to a plan written by the authors ("Plans are human-designed once", p.4), and the paper itself notes that "the strongest results occur when task structure is known" (p.9). No task outside the six types is evaluated. The only ablation (Table 7) covers one model on one task and has no arm with a generic, task-agnostic plan. On that same cell, multiplying k∗k^* by 1.5 costs 25.8 points (Table 13), so the decomposition settings carry much of the result. If the main contribution of the paper is in such manually-designed plans, their value is reduced by the possibility of other, more general-purpose, approaches for designing such plans. Generated plans (PlanGen) are tested on a single model–task pair (p.8), and general-purpose decomposition methods such as LLM$\times$MapReduce (Zhou et al., 2024) and Chain-of-Agents (Zhang et al., 2024) are neither cited nor compared. If most of the gain comes from the per-task plans, every new task needs new manual design, and the contribution reduces to plans that general-purpose decomposition might match.

References:

  • Zhang, Y., et al. Chain of agents: Large language models collaborating on long-context tasks. NeurIPS, 2024.
  • Zhou, Z., et al. LLM$\times$MapReduce: Simplified long-sequence processing using large language models. arXiv:2410.09342, 2024.
Questions for authors
  1. Clarification: given that Alg. 2 and Alg. 3 return the direct call whenever ∣P∣≤K|P| \le K, how can λ\lambda-RLM and Direct differ on S-NIAH, OOLONG and OOL-Pairs inputs that fit the window? Was the short-circuit active in the experiments? Per-bucket results for both methods would settle this, and the answer could change my assessment substantially.
  2. Clarification: could you provide per-seed results, standard deviations and the p-values of the paired tests behind the 36 wins, 8 ties and 1 loss (p.6, p.16)?
  3. Clarification: were the models served locally with vLLM (p.16) or through free API services (p.18)? Did leaves run in parallel, and how was latency controlled?
  4. Clarification: were the six task types and their plans fixed before the five benchmarks were examined? What does λ\lambda-RLM do when it meets a task that fits none of the six types?
  5. Requested experiment: the paper notes that "broader comparisons with planning and hierarchical-agent systems remain necessary" (p.8). On the same models, how does λ\lambda-RLM compare with a task-agnostic chunk-map-reduce baseline (one fixed plan, no task-type selection), LLM$\times$MapReduce (Zhou et al., 2024) and Chain-of-Agents (Zhang et al., 2024)?
5 comments
AuthorsOpenReview ↗

Response to Reviewer 4QyA

Thanks for the comments. We have carried out additional studies and reported results for the same to support the work. The changes are marked in blue in the updated PDF.

Response to the Weaknesses (W) and Questions (Q) are provided below:

W1. Consistency between the algorithm and the reported results. The short-circuit was active in the Table 3 runs. The λ-RLM controller used a 32K decomposition threshold, so 64K and 128K inputs were decomposed even when they fit within a backbone’s native context window. Within the threshold, λ-RLM uses a task-specific solver prompt, while Direct uses the raw benchmark prompt. We revised Algorithms 2 and 3 to make these distinctions explicit.

We also clarified three aspects of the reporting. The 131K label identifies the example used to illustrate the planner settings. The reference scores and latencies are averages across length buckets, which is why the 48.3 score for Qwen3-8B × OOLONG appears in both Table 3 and the ablations. We replaced the win–tie–loss wording with a descriptive count of 36 higher five-seed means for λ-RLM and nine for RLM. We also corrected the serving description to specify the free-tier hosted API used in Table 3.

W2. Dependence on hand-designed plans and decomposition settings. We added LongHealth, a benchmark outside the six predefined task types. On Mistral-7B, the same λ-RLM executor achieved 76.0% accuracy with a generic split–map–reduce plan and 76.7% with a validated model-generated plan, compared with 63.2% for RLM and 68.0% for Chain-of-Agents, the strongest split-and-combine baseline. Both variants ran without a hand-written LongHealth plan (Appendix D.8, Table 19).

The 25.8-point drop in Table 13 occurs when the fan-out is multiplied by 1.5 while the OOLONG plan is held fixed. The sweep in Table 12 shows that larger fan-out produces more, shorter leaves and that measured leaf accuracy falls. This sensitivity motivates choosing fan-out from the input length and controller budget. Separately, Table 7 holds the combinator library fixed on Qwen3-8B × OOLONG. Fixing the plan before execution yields 48.3, versus 40.2 when the model can reselect it at each turn. Table 21 adds the three requested split-and-combine baselines.

Q1. Was the short-circuit active, and why do λ-RLM and Direct differ?

Yes. With K = 32K tokens, λ-RLM decomposes prompts with |P| > K. For |P| ≤ K, it makes one task-selection call followed by one solver call with the selected task template. Direct makes one call with the raw benchmark prompt. Both methods use the same final-answer parser and scorer.

On split OOLONG-Pairs inputs, the model labels records and symbolic operators construct the final pairs. Direct must generate the pair list within a 4,096-token per-call output cap. Among the sampled dense queries, the median gold lists at 64K and 128K contain 15,679 and 63,915 pairs and require approximately 125K and 511K output tokens, respectively (Appendix D.7, Table 18). Symbolic composition lets λ-RLM return pair lists beyond that per-call cap.

For Llama-405B on S-NIAH, the 28.1 s for λ-RLM and 48.6 s for Direct are averages across length buckets. On split inputs, preview filtering reduces the context sent to the solver, which can offset the task-selection call. We tested this mechanism separately on Llama-3.1-8B at 32K. There, enabling the filter within λ-RLM gave a 1.67× speedup relative to the unfiltered variant (Table 30). The 405B comparison measures the end-to-end latency of the two systems, including API queueing and network time.

Appendix D.6, Table 17 reports single-seed per-bucket scores for Direct and λ-RLM on Llama-3.1-8B across S-NIAH, OOLONG, and OOLONG-Pairs. Table 3 reports the corresponding five-seed aggregate results. The controller applies its threshold to the actual prompt length, so routing within the nominal 32K bucket depends on whether the prompt exceeds K.

Q2. Can you provide the per-seed results, standard deviations, and paired-test p-values?

Yes. Appendix D.10 reports the five individual seed scores in Tables 23–27 and the standard deviations and exact two-sided paired permutation p-values in Table 22. With five paired seeds, the minimum attainable exact two-sided p-value is 2/2⁵ = 0.0625. The 36/45 figure counts cells in which λ-RLM has the higher five-seed mean. The revised manuscript makes no cell-level significance claims at the 0.05 level.

Response to other questions are continued in the next comment

AuthorsOpenReview ↗

Response to Reviewer 4QyA (continued)

Q3. How were the models served, and did leaves run in parallel?

All Table 3 runs used the free tier of a hosted inference API. We corrected the earlier reference to local vLLM/H100 serving. Within each model–task cell, the methods used the same endpoint, backbone, and decoding settings. λ-RLM leaf calls ran sequentially. End-to-end wall-clock latency includes intermediate calls, network time, and API queueing. The 4.0× figure is the ratio of mean RLM latency to mean λ-RLM latency across the 45 cells under this hosted setup.

Q4. When were the plans fixed, and what happens outside the six types?

We fixed the six task types and their plans before selecting the examples used in the five benchmark evaluations. The original router always assigns one of its six labels, including when none is a close fit. For LongHealth, we bypassed the router and supplied either one generic split–map–reduce plan or a validated model-generated plan. Both ran on the same executor and exceeded the baselines in Table 19.

Q5. How does λ-RLM compare with the requested baselines?

Table 21 compares λ-RLM with fixed chunk–map–reduce, LLM×MapReduce, and Chain-of-Agents on Llama-3.1-8B and Mistral-7B. At 32K, λ-RLM outperforms all three baselines on both OOLONG and OOLONG-Pairs for both backbones. The Llama-3.1-8B comparisons use one seed, and the Mistral-7B comparisons average five seeds. On LongHealth with Mistral-7B, λ-RLM’s generic plan scores 76.0%, compared with 68.0% for the strongest baseline.

Thank you for the detailed response and the additional experiments. They resolve the main reason for my original rating.

The short-circuit is now explained. With a 32K decomposition threshold, the 64K and 128K inputs are decomposed, so differences from Direct on these buckets are expected. The LongHealth result is the most informative addition for me: a generic split-map-reduce plan on the same executor reaches 76.0%, against 63.2% for RLM and 68.0% for Chain-of-Agents, without a hand-written plan. Together with Table 21, this partly answers my concern that the gains come from the per-task plans.

I am therefore raising my rating from 1 to 2. Several issues keep me below acceptance.

First, the response confirms that the submitted version misdescribed the short path (a task-specific prompt rather than a direct call), the serving setup and the statistics. With five paired seeds, the two-sided permutation test named on p.16 cannot give p<0.05p < 0.05, as you now note. The revised count of higher means carries no significance claim. Corrections of this extent mean that much of the evidence has to be read again in the revised version.

Second, below the threshold λ\lambda-RLM does not decompose. In the 8K, 16K and 32K buckets of S-NIAH, OOLONG and OOLONG-Pairs, its advantage over Direct and RLM therefore comes from the task-specific solver prompt rather than from restricted control, and the macro-averages in Table 3 mix these buckets with the decomposed ones. Reporting Table 3 separately for inputs above and below KK, for all models, would show how much of the gain the restricted control is responsible for.

Third, the new baseline comparison in Table 21 is run only at 32K, where many inputs take the single-call path, on two backbones and with a single seed for Llama-3.1-8B. The LongHealth result uses one model, with the router bypassed by hand. A comparison at 64K and 128K, where λ\lambda-RLM actually decomposes, would be much more convincing.

Finally, the 4×4\times latency figure comes from a free-tier hosted API with queueing, network time and sequential leaves, so I would present it as indicative only. Similarly, Direct cannot produce the OOLONG-Pairs answers at 64K and 128K under the 4,096-token output budget, so those cells are better marked as infeasible than counted as losses.

Reviewer_kxSeOpenReview ↗
Rating
4
Confidence
1
Informativeness
1
Presentation
1
Soundness
3
Read review
Paper summary

As written to ACs I am not qualified to make a review of this paper that is far out from my competence at the point that I cannot understand it at all. Because I am forced to write an evaluation I do it now. Any score is random. Please delete this review.

Critical strengths

As written to ACs I am not qualified to make a review of this paper that is far out from my competence at the point that I cannot understand it at all. Because I am forced to write an evaluation I do it now. Any score is random. Please delete this review.

Critical weaknesses

As written to ACs I am not qualified to make a review of this paper that is far out from my competence at the point that I cannot understand it at all. Because I am forced to write an evaluation I do it now. Any score is random. Please delete this review.

Questions for authors

As written to ACs I am not qualified to make a review of this paper that is far out from my competence at the point that I cannot understand it at all. Because I am forced to write an evaluation I do it now. Any score is random. Please delete this review.

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

The paper introduces λ-RLM, a statically restricted framework for recursive long-context reasoning that addresses limitations of conventional Recursive Language Models, particularly their dependence on model generated executable code, unpredictable execution costs, and lack of guaranteed termination. Rather than allowing the language model to determine its own recursive control flow, λ-RLM uses a fixed controller specified through a compact library of compositional operators, including SPLIT, MAP, FILTER, REDUCE, and CONCAT. The language model is restricted to solving bounded leaf-level subproblems, while decomposition, traversal, filtering, and aggregation are handled by predefined operations.

The framework uses a finite task selection mechanism to select among six human-designed execution plans, followed by deterministic fan-out and threshold planning. Its theoretical analysis establishes termination under explicit assumptions, derives bounds on model-call counts and execution costs, and provides separate accuracy bounds for conjunctive and retrieval-oriented tasks. The authors also formulate a fan-out optimization rule rather than assuming that binary decomposition is universally optimal.

The experimental evaluation covers five long-context benchmarks (S-NIAH, OOLONG, OOLONG-Pairs, BrowseComp+, and CodeQA) and nine models from the Qwen3, Llama, and Mistral families. Comparisons include direct inference, conventional RLM, and a one-shot planning baseline on S-NIAH. The experiments use five seeds and report accuracy/F1, wall-clock latency, and statistical comparisons. The reported results show improvements over RLM in 36 of 45 model–task comparisons, with eight ties and one statistically significant RLM win. The framework achieves an average reported latency reduction of 4.0×. Improvements are particularly pronounced for weaker and medium-sized models and tasks that benefit from symbolic processing, whereas conventional RLM retains advantages in some frontier-model code navigation and adaptive-search settings.

Critical strengths

Broad empirical evaluation with useful analysis of when the approach works and when it does not.

-> The evaluation across nine models and five benchmarks provides useful evidence that restricted control can improve both accuracy and efficiency, particularly for smaller models and structurally decomposable tasks. I also find the analysis of weaker performance on adaptive code-navigation and search tasks valuable. Rather than presenting the proposed framework as universally superior, the authors identify the trade-off between execution reliability and the flexibility of model-generated control. The fan-out sensitivity experiments and accuracy-assumption checks further strengthen the empirical analysis by examining factors that influence the observed performance rather than relying exclusively on aggregate benchmark results.

Critical weaknesses

The evaluation does not yet establish that λ-RLM generalizes beyond a relatively narrow set of predefined task plans.

->The method relies on selecting a task type and then executing a fixed, task-specific composition plan. The experiments cover five tasks, but the paper does not convincingly show how well this approach extends to unfamiliar tasks that do not fit the existing plan library. This is consequential because the main practical claim is about a general framework for long-context reasoning; the current evidence may instead support a more limited conclusion about carefully structured tasks for which suitable plans have already been designed.

Questions for authors

How much of the improvement comes from static control versus task-specific symbolic processing? The paper includes ablations, but could the authors clarify whether the gains remain substantial when comparing λ-RLM and RLM under equivalent decomposition and composition strategies? This distinction is important for understanding the actual contribution of the restricted-control framework.

2 comments
AuthorsOpenReview ↗

Response to Reviewer 7tGe

Thanks for your comments. Please find response to weakness and the question below. Changes in updated PDF are marked in blue

Response to Weakness

Generalization beyond the predefined plans. We added LongHealth, a benchmark outside the six predefined task types (Appendix D.8, Table 19). We bypassed task-type selection and used a single generic split–map–reduce plan for all inputs. On Mistral-7B, λ-RLM achieved 76.0% accuracy, compared with 63.2% for RLM and 68.0% for Chain-of-Agents, the strongest split-and-combine baseline. A second variant achieved 76.7% by validating and fixing a model-generated plan before execution. Both variants used the same executor without requiring a hand-written LongHealth plan.

Response to Question

Static control versus task-specific symbolic processing. Table 7 tests these effects on Qwen3-8B × OOLONG. Giving free-form RLM access to the combinators raised its score from 24.1 to 31.7 (arms e and d). Within λ-RLM, both variants had access to the same combinator library. Fixing the plan before execution scored 48.3, compared with 40.2 when the model could reselect the plan at each turn (arms a and b). The 8.1-point difference measures the effect of plan fixity in this setting.

We also gave free-form RLM both the λ-RLM combinators and a plan description on the same 20 Llama-3.1-8B OOLONG-Pairs questions at 32K (Appendix D.12, Table 29). Both variants scored near zero. Plain RLM’s 2.3% mean pair F1 came almost entirely from partial recovery on a single question, while the variant given the plan and combinators scored 0.0%. Nine of its runs produced no runnable code, and ten more ended with a code exception and empty answer, an iteration cap, or a time limit. The model still had to translate the plan into executable control code, and those failures persisted despite the added guidance.

AuthorsOpenReview ↗

Concluding comment by authors (Reviewer 7tGe)

As the discussion period ends, we thank you for reviewing our paper and providing insightful comment. We believe the paper was enhanced thanks to the insightful comments we received; be it adding the LongHealth benchmark that illustrates generalization beyond the predefined plans or static control versus task-specific symbolic processing.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.