ArXiv: 2510.08189

🎯 Pitch

Even top reasoning models like DeepSeek-R1 suffer catastrophic accuracy collapse (e.g., from 87% to 25%) when forced to chain just 5 math problems together, revealing a shockingly short "effective reasoning length" where errors cluster within the first few thousand tokens. Training on these composed multi-horizon tasks not only rescues performance on long chains but unexpectedly boosts standard single-problem benchmarks by up to 7.5 points — but only if the individual problems are already within the model's ability range.

1. Executive Summary

This paper introduces R-HORIZON, a method for stimulating long-horizon reasoning behaviors in Large Reasoning Models (LRMs) through query composition—linking multiple single-horizon problems into sequentially dependent chains (e.g., using a prior problem's answer as a variable in the next). Evaluating 25 LRMs on the R-HORIZON Benchmark (MATH500, AIME24, AIME25, AMC23, LiveCodeBench, WebShaper), the authors demonstrate that even the most advanced models suffer severe performance degradation as reasoning horizons expand—DeepSeek-R1 drops from 87.3% to 24.6% on AIME25 when horizon increases from 1 to 5 problems—establishing that current LRMs possess a sharply limited effective reasoning length (error positions stabilize within ~4–6k tokens for 7B models, ~8–10k for 32B models) and fail to allocate thinking budget across multiple problems appropriately. Training with R-HORIZON composed data via reinforcement learning with verified rewards (RLVR) not only substantially improves multi-horizon performance (+17.4 on AIME24 n=2) but also boosts single-problem accuracy (+7.5 on AIME2024), establishing that long-horizon training data serves as an efficient mechanism for improving both breadth and depth of reasoning, though gains fundamentally depend on problems remaining within the model's capability range—the hardest difficulty bins show near-zero improvement regardless of training intervention.

2. Context and Motivation

The Core Problem: Single-Horizon Evaluation Misses the Real World

The central question this paper wrestles with is deceptively straightforward: How far can today's best reasoning models really go when asked to sustain coherent reasoning across multiple, interdependent problems? The answer, it turns out, is "not nearly as far as their single-problem benchmark scores suggest."

The field of Large Reasoning Models (LRMs) has been riding a wave of excitement driven by test-time scaling—the discovery that allowing models to "think longer" via extended Chain-of-Thought (CoT) reasoning produces remarkable accuracy gains on challenging benchmarks like AIME and MATH. Models such as OpenAI o1 and DeepSeek-R1 now achieve near-saturation performance on single-problem mathematical reasoning tasks that would have seemed out of reach just two years ago. The implicit narrative has been: if we can get a model to think for 10,000 tokens on one hard problem, we've built something that can reason deeply.

But this narrative harbors a critical blind spot. As the authors point out in Section 1, real-world reasoning rarely involves isolated, self-contained problems. An AI agent helping with scientific research, software development, or long-term planning must reason, plan, and act over extended sequences of interdependent steps—sometimes thousands or millions of them—where the answer to one subproblem becomes a necessary input to the next. A single-horizon evaluation paradigm cannot assess whether a model can sustain coherent reasoning across such chains. The model might ace five individual AIME problems when presented separately, yet completely collapse when those same five problems are linked together in a dependency chain. That collapse is precisely what this paper documents.

This gap between benchmark performance and real-world reasoning capability represents a fundamental evaluation failure. Current benchmarks (MATH, GSM8K, AIME, LiveCodeBench) treat each question as an independent event. They measure depth of reasoning on a single problem but say nothing about breadth—the ability to maintain reasoning quality across an extended horizon of problems. The paper's core contribution is not just identifying this gap but providing a systematic method for measuring and addressing it.

Why This Matters: The Hidden Failure Mode of Test-Time Scaling

The practical significance of this problem is amplified by the very mechanism that has made LRMs successful: test-time scaling. Models achieve high accuracy on hard problems by generating very long reasoning trajectories—sometimes tens of thousands of tokens per problem. But this strategy has an unspoken assumption baked in: that the reasoning budget is being spent on a single problem. What happens when the model faces multiple problems and must allocate its finite thinking budget across all of them?

The paper's findings reveal a troubling answer. As Section 5.1 documents, current LRMs exhibit what we might call budget allocation myopia: they lavish tokens on early problems while starving later ones. Even DeepSeek-R1, one of the most capable reasoning models available, cannot effectively distribute its thinking budget across a chain of just five problems (Figure 8). The first problem gets the lion's share of computation; subsequent problems receive progressively less attention. This is not a minor inefficiency—it is a structural failure in how these models approach multi-problem reasoning.

This myopia connects directly to the effective reasoning length phenomenon the paper identifies. Section 2.2 frames this in relation to prior findings that CoT reasoning chains have an optimal length beyond which performance degrades. But the R-HORIZON analysis reveals something more specific: the degradation is not just about length in the abstract—it is about where in the sequence the model's attention collapses. The error position analysis (Figure 6) shows that models reliably fail at characteristic token counts (4-6k for 7B models, 8-10k for 32B models), regardless of how many problems are in the chain. This suggests a hard attentional or representational bottleneck, not merely an optimization issue.

The real-world stakes are substantial. Consider an AI system tasked with debugging a multi-file codebase: it must trace program state across multiple functions, each requiring reasoning about the output of the previous step. Or an agent conducting multi-round web research: each search result informs the next query, requiring sustained reasoning across a chain of information-gathering steps. If current LRMs struggle with just five composed math problems, they are almost certainly failing in more complex, open-ended sequential reasoning scenarios. The R-HORIZON benchmark provides the first systematic evidence that this failure is universal across model sizes, architectures, and task types.

Prior Approaches and Where They Fall Short

The paper positions itself against several strands of existing work, each of which captures part of the problem but fails to provide a complete picture.

Test-time scaling research focuses on single problems. The literature on inference-time compute scaling (cited extensively in Section 2.1) has produced sophisticated techniques for allocating computation within a single reasoning trajectory—deciding when to search, when to verify, when to reflect. But these techniques operate on the assumption of a single, self-contained problem. They optimize depth within a reasoning horizon, not breadth across multiple horizons. When the model finishes Problem 1 and must pivot to Problem 2 (which depends on Problem 1's answer), none of the existing test-time scaling strategies offer guidance on how to allocate the remaining thinking budget. The model is essentially on its own, and as Figure 8 shows, it defaults to a crude "first problem gets most" allocation.

Length-control mechanisms are designed for single-problem efficiency, not multi-problem allocation. Several recent works address the overthinking problem—the observation that LRMs generate verbose reasoning trajectories with marginal accuracy gains (Chen et al., 2025; Aggarwal & Welleck, 2025). These approaches train models to think more efficiently by controlling response length or penalizing excessive token usage. But they share the same single-problem framing. A model trained to think efficiently on isolated AIME problems has learned to answer AIME problems with fewer tokens, not how to distribute those tokens across a chain of problems. The R-HORIZON RL experiments (Section 4.3) demonstrate this directly: training with R-HORIZON composed data produces a fundamentally different allocation pattern than training with the same problems presented individually, even when both achieve similar single-problem accuracy.

Multi-context stress testing exists but lacks genuine dependencies. The paper explicitly contrasts with REST (Pan et al., 2025), which concatenates multiple independent problems and tests whether models can maintain performance under "multi-context stress." REST reveals that models degrade when asked to handle multiple problems simultaneously, but the problems in REST are independent—they share context but have no logical dependencies. The R-HORIZON design goes further by constructing explicit dependency chains: Problem 2 literally cannot be solved without Problem 1's answer, because Problem 1's answer is substituted into Problem 2 as a key variable. This is a qualitatively harder task. It forces the model not just to maintain parallel context for multiple problems, but to sequentially solve them and correctly propagate results across the dependency chain. The paper's ablation study (Appendix D.1, Figure 12) confirms this distinction: models perform significantly worse on dependent problems than on independent problems concatenated together, even though the underlying math is the same.

Existing RL training data for reasoning is single-horizon. The paper makes an important observation about the training pipeline behind modern LRMs (Section 3.3, Appendix B). Reinforcement learning with verifiable rewards (RLVR) is the dominant paradigm for training reasoning capabilities—the DeepSeek-R1 recipe that many models follow. But the training data for RLVR consists almost entirely of individual problems from math competitions and similar sources. The reward signal is binary: did you get the answer right? The model learns to optimize for solving one problem at a time because that's all it has ever seen. As Appendix B documents, when researchers apply standard RL training to improve reasoning, the model's ability to handle composed problems improves slowly and shows "no clear correlation with the increase in response length"—the model is learning single-problem depth, not multi-problem breadth. This training-data blind spot means that even the most advanced LRMs have literally never practiced the skill of solving multiple dependent problems in sequence.

Reflection and self-correction are studied locally, not across problems. The paper's analysis of reflection behavior (Section 5.1, Figure 7) reveals a subtle limitation that prior work has not captured. Models do engage in reflection—they check their work, revisit assumptions, verify intermediate steps. But as the horizon expands, the reflection becomes increasingly localized to the current problem. The "Long Reflection Rate" metric shows that as the number of composed problems increases, the proportion of problems involving long-range reflection (checking across problem boundaries) rises, but more than half of all problems still lack any long-range reflection. The model reflects within Problem 3 but rarely asks "Did I actually get the right answer for Problem 2, and is that answer correctly propagated into Problem 3's dependency variable?" This is a critical mode of failure in sequential reasoning that single-problem evaluation masks entirely.

How This Paper Positions Itself

The paper frames R-HORIZON as a dual-purpose infrastructure: an evaluation methodology that exposes previously hidden failure modes, and a training methodology that addresses those failures. This dual framing is important because it acknowledges that the problem is both diagnostic (we don't know how bad the gap is) and prescriptive (we need a way to close it).

As evaluation, R-HORIZON answers the "how far" question. The paper's title asks "How Far Can Your Large Reasoning Model Really Go in Breadth and Depth?" The answer, established through evaluation of 25 models across 6 task types (Section 4.2, Figure 3), is that breadth and depth are in tension. Models can go deep on one problem, but that depth consumes the thinking budget that breadth across multiple problems requires. The paper's choice of the term "horizon" is deliberate—borrowing from reinforcement learning, where the horizon determines how many steps into the future an agent considers when making decisions. LRMs, the paper argues, have a short effective reasoning horizon not in the sense that they can't look ahead (in fact, their single-problem CoT often does exactly that), but in the sense that they cannot maintain the quality of their reasoning across multiple decision points.

As training methodology, R-HORIZON offers a minimal, scalable intervention. The paper does not propose a new architecture, a new reward function, or a new RL algorithm. The intervention is almost embarrassingly simple: take the same math problems you were already using for RL training, link them together with dependency functions, and train on those composed problems instead. The finding that this simple change produces substantial improvements on both composed and single-problem performance (+7.5 on AIME2024, +17.4 on AIME24 n=2; Section 4.3, Figure 4) suggests that the training data composition is doing something fundamentally different from just presenting more math problems. It is teaching the model to manage a reasoning budget across multiple sub-tasks—a meta-skill that transfers back to single-problem reasoning because efficient allocation is useful even within a single problem's subtask structure.

The paper positions itself at the intersection of three concerns that have been studied mostly in isolation: the overthinking phenomenon (models waste tokens on simple problems), the effective reasoning length (performance degrades beyond some CoT length), and the multi-step problem structure (dependencies create chains that test propagation of reasoning). R-HORIZON unifies these concerns by showing that they are manifestations of the same underlying limitation: LRMs lack mechanisms for adaptively allocating computation across reasoning horizons. The paper's finding that composed training data teaches better allocation (Section 5.2, Figure 9) implies that this limitation is not architectural but rather a consequence of the training distribution—the models have never needed to allocate across horizons, so they never learned to.

A crucial nuance the paper is careful about: R-HORIZON does not claim to expand the fundamental capability frontier. The hardest problems (difficulty bin 5) remain largely unsolvable regardless of training intervention, and models trained on composed data still cannot handle problem chains where any individual problem is beyond their capability. The paper is explicit that R-HORIZON improves reasoning efficiency and horizon management, not raw problem-solving ability. This distinguishes it from approaches that try to make models smarter in an absolute sense—R-HORIZON makes them better at being smart across more problems, not smarter per problem. The +7.5 on AIME2024 is not because the model learned new math; it is because the model learned to spend its thinking budget more effectively on the math it already knew.

3. Technical Approach

3.1 Reader Orientation

R-HORIZON is fundamentally a data composition pipeline — it takes existing single-problem reasoning datasets and automatically stitches them into multi-problem chains where each subsequent problem depends on the answer from the previous one. The paper is primarily an evaluation and training framework paper: it uses this composition pipeline to build a benchmark that exposes hidden failure modes in current Large Reasoning Models, and then uses the same pipeline to generate training data that teaches models to reason across extended horizons. The core idea is that the gap between single-problem and multi-problem performance is not an architectural limitation of LRMs but a consequence of training data distribution — models have never seen dependent multi-problem chains during training, so they never learned to manage a reasoning budget across horizons.

3.2 Big-Picture Architecture (Diagram in Words)

The R-HORIZON system has four major components:

  1. Problem Filtering Module — Takes an existing dataset of single-problem question-answer pairs and filters for problems suitable for composition (those containing integer key variables that can be extracted and manipulated). Output: a set of "seed problems" with annotated key variables.

  2. Dependency Chain Construction Module — Takes seed problems and links them into sequential chains using Algorithm 1. Creates placeholder variables and dependency functions that force each problem to require the previous problem's answer. Output: composed problem sequences $(q_1, q'_2, ..., q'_n)$ where each $q'_i$ contains an explicit dependency on $a_{i-1}$.

  3. Evaluation Harness — Applies the composed problems as test prompts to LRMs, extracts answers using GPT-4.1-based parsing, and computes all-or-nothing accuracy (all sub-problems must be correct for the entire composed sequence to count as correct). Also computes theoretical accuracy (product of individual pass rates) as a ceiling for comparison.

  4. RLVR Training Pipeline — Uses composed problems as training data for GRPO-based reinforcement learning, with two reward schemes (last-only $R_{last}$ and all-correct $R_{all}$). The trained models are then evaluated on both composed and single-problem benchmarks.

Information flows through these components in two parallel tracks: downstream evaluation (components 1→2→3) and training enhancement (components 1→2→4).

3.3 Roadmap for the Deep Dive

  • First, the problem filtering criteria (Equations 1-2), which determine which problems can participate in composition and identify the key variables that will become dependency anchors — this is the foundation that the rest of the pipeline depends on.
  • Second, the dependency chain construction algorithm (Algorithm 1), which is the core technical mechanism for creating sequential dependencies — this is where the paper's novelty resides in terms of data construction.
  • Third, the composed data construction variants for code and agentic tasks (Appendix A), which show how the core composition idea adapts to domains beyond pure mathematics.
  • Fourth, the evaluation metrics (Equations 3-4), because understanding what is being measured shapes how we interpret all subsequent experimental results.
  • Fifth, the RLVR training setup with R-HORIZON data (Equation 5, reward schemes in Equation 6), which closes the loop from evaluation to improvement.

3.4 Detailed, Sentence-Based Technical Breakdown

This is an evaluation-and-training framework paper whose core technical contribution is a method for automatically constructing multi-horizon reasoning tasks from existing single-horizon datasets. The method operates by identifying "composable" problems, establishing variable-level dependencies between them, and generating composed prompts that enforce sequential solving. The same construction pipeline serves dual purpose: feeding an evaluation benchmark that measures how well models sustain reasoning across extended horizons, and generating training data for reinforcement learning that teaches models to manage thinking budgets across multiple sub-problems.

Problem Filtering: Identifying Composable Problems and Their Key Variables

The composition pipeline cannot use arbitrary problems — it requires problems where the answer is a numeric value that can be substituted into another problem as a variable. The filtering module applies two criteria to cull the original dataset into a usable seed set and then annotates each seed problem with its "key variables."

Dataset filtering criterion. Given an initial dataset $\mathcal{D} = \{(q_i, a_i)\}_{i=1}^N$ consisting of question-answer pairs, the seed set $\mathcal{D}_{seed}$ is defined as:

Dseed={(q,a)∈D∣∣I(q)∣>0∧a∈Z}\mathcal{D}_{seed} = \{(q, a) \in \mathcal{D} \mid |I(q)| > 0 \land a \in \mathbb{Z}\}

where $I(\cdot) = \text{extract\_int}(\cdot)$ denotes extracting all integers appearing in the input text, and $\mathbb{Z}$ is the set of integers.

What it computes: for each problem in the original dataset, the system checks two conditions: (1) the problem text must contain at least one integer (so there is something that could potentially serve as a dependency variable in a downstream problem), and (2) the problem's answer must be an integer (so it can be cleanly substituted as a numeric value into a dependency function). Only problems satisfying both conditions enter the seed set.

Why these criteria: the integer-text requirement ensures there are potential "slots" in the problem statement where a dependency variable could be substituted — if a problem contains no integers at all, there is nothing to replace with a variable that depends on a previous answer. The integer-answer requirement ensures clean dependency propagation — if the answer were a fraction, a radical expression, or a string, constructing a simple dependency function would require parsing complex expressions rather than straightforward arithmetic. The paper focuses on integer answers because the majority of mathematical reasoning benchmarks produce integer answers, making this criterion minimally restrictive for the target domains.

Key variable identification. For each seed problem, not all extracted integers are equally important. Some integers are essential to the problem (removing them would make the problem unsolvable), while others are incidental. The system uses a model $M$ to classify each extracted integer:

K(q)={m∈I(q)∣M(q,m)=1}K(q) = \{m \in I(q) \mid M(q, m) = 1\}

where $M(q, m) = 1$ indicates that removing $m$ from $q$ renders the problem unsolvable. Each filtered seed problem is then represented as a triple $(q, a, K(q))$.

What it computes: for each integer $m$ appearing in the problem text of seed problem $q$, the verification model $M$ answers a binary question: "If we remove this specific integer from the problem statement, can the problem still be solved?" If the answer is no, $m$ is a key variable and gets added to $K(q)$ — the set of integers whose values are essential to solving $q$. The final representation of each seed problem carries the question text, the correct integer answer, and the annotated set of key variables.

Why this form: the key variable identification is what enables the dependency construction in the next step to be semantically meaningful. If the system simply substituted any random integer in the problem text, it might replace a value that is incidental to the solution (a year, a count that appears in an example, an arbitrary constant in a distractor phrase). The model $M$ acts as a semantic filter that ensures only integers whose values actually constrain the solution space become dependency slots. The paper does not specify which model $M$ is used for this verification step, but given the pipeline's reliance on LLMs elsewhere, it is presumably a capable instruction-following model prompted with a task description that explains what "renders the problem unsolvable" means.

A subtle design choice: the filtering module does not require that every key variable in $K(q)$ be used in the composition — some problems may have multiple key variables, and the dependency chain construction algorithm (Algorithm 1) selects one key variable per downstream problem to serve as the dependency anchor. This flexibility means the seed set can be rich (capturing all relevant integers) while the composition step makes specific choices about which variables to actually link.

Scale of filtering. The paper reports in Appendix F.2, Table 4, that applying this filtering to the Skywork-OR1-RL training dataset reduces 48,371 original problems to 18,015 seed problems — a retention rate of approximately 37%. This substantial reduction reflects the strictness of the criteria: many problems in RL training datasets either lack integer answers (e.g., proof problems, problems with rational or radical answers) or lack integer-valued key variables in their text. The filtered pool is then further restricted by difficulty constraints during composition (only problems whose product of individual pass rates exceeds 0.25 are composed together), yielding 18,000 final composed training instances.

Dependency Chain Construction: Algorithm 1 in Detail

This is the algorithmic core of R-HORIZON. Given a sequence of seed problems (each with annotated key variables), Algorithm 1 constructs a composed problem sequence where each problem after the first contains an explicit dependency on the previous problem's answer.

Algorithm input and output. The algorithm takes as input a sequence of seed problems $\{(q_1, a_1, K_1), ..., (q_n, a_n, K_n)\}$ — each a triple of question text, answer integer, and key variable set. It outputs a composed problem sequence $Q = (q_1, q'_2, ..., q'_n)$ where the first problem $q_1$ is unchanged and each subsequent $q'_i$ is a modified version of $q_i$ with a dependency injected.

The iterative construction process. Algorithm 1 proceeds step-by-step through the sequence. For each step $i$ from 1 to $n-1$ (linking problem $i$ to problem $i+1$), it executes four operations:

  1. Select key variable as dependency anchor: From the set $K_{i+1}$ (the key variables of problem $i+1$), select one integer $m_{i+1}$ to serve as the dependency anchor. This is the specific value in problem $i+1$'s text that will be replaced by a variable whose value depends on problem $i$'s answer.

  2. Create a placeholder variable and dependency function. A new variable symbol $v_{i+1}$ is introduced. A dependency function $f_i(x) = x + (m_{i+1} - a_i)$ is defined, where $x$ will be bound to the answer $a_i$ of the previous problem. This function has the crucial property: $f_i(a_i) = a_i + (m_{i+1} - a_i) = m_{i+1}$. That is, when the correct answer $a_i$ is plugged in, the function evaluates to exactly the original value $m_{i+1}$ that was in problem $i+1$'s text.

  3. Modify the downstream problem. In the problem text $q_{i+1}$, the integer $m_{i+1}$ is replaced by the placeholder variable $v_{i+1}$. This creates $q'_{i+1}$, a version of problem $i+1$ that is literally unsolvable as written — it contains a free variable whose value is unknown.

  4. Augment with dependency constraint. The modified problem $q'_{i+1}$ is prepended with a dependency specification of the form: "Using the result [answer_i] from the previous calculation, [variable_{i+1}] = [dependency_function]." This makes explicit that the placeholder variable $v_{i+1}$ is defined by applying $f_i$ to the previous problem's answer.

The crucial property of the dependency function. The choice $f_i(x) = x + (m_{i+1} - a_i)$ is deliberate and elegant. In plain language: the dependency function takes the previous answer, adds the difference between the original key variable value and that answer, and produces a value. When the model solves the previous problem correctly and gets $a_i$, the function evaluates to exactly $m_{i+1}$, restoring the original problem. But if the model gets the previous problem wrong, the dependency function produces a wrong value $v_{i+1}$ (because the constant offset $m_{i+1} - a_i$ assumes the correct $a_i$ was used), and problem $i+1$ becomes a different problem — one the model likely cannot solve correctly. This creates a brittle dependency: errors in earlier problems propagate forward and corrupt later problems, making the all-or-nothing evaluation metric (Equation 3) a genuine test of sustained reasoning accuracy.

Why this form and not something simpler? A simpler approach would be to directly substitute: "Problem 2: The answer to Problem 1 is X. Now compute ..." But this creates a dependency that is too easy to satisfy — the model just reads X from the context and plugs it in, no computation needed. The dependency function forces the model to compute the dependency variable from the previous answer, which is closer to real sequential reasoning where intermediate quantities must be transformed before use in subsequent steps. The specific form of the function (adding a constant offset) is the simplest possible transformation that still requires computation — it ensures the dependency variable differs from the raw answer, preventing the model from simply copying the previous answer forward.

A subtle aspect of the construction: the algorithm replaces $m_{i+1}$ with $v_{i+1}$ in the problem text, but the original value $m_{i+1}$ is still encoded in the dependency specification (as part of the constant $m_{i+1} - a_i$). This means the problem is reversible: a sufficiently capable model could, in principle, reverse-engineer $m_{i+1}$ from the dependency specification even without solving the previous problem. The paper's evaluation (Appendix D.2, Figure 13) in fact documents this phenomenon — some models correctly solve later problems even when earlier answers are wrong, presumably by such reverse-engineering. But the key finding is that this happens only occasionally, and the overall all-or-nothing accuracy still degrades dramatically.

The augmentation format. The paper provides concrete prompt examples in Figures 15, 16, and 17. For mathematical tasks (Figure 15), the composed prompt explicitly lists all problems with their dependency specifications inline:

Problem 1: {Question 1} Using the result {[answer 1]} from the previous calculation, {[variable 2]} = {dependency_function}. Problem 2: {Question 2} ... Problem n: {Question n}

Note: In this problem set:

  • [variable k] represents the calculated variable needed to solve problem k.
  • [answer k] represents the answer to problem k.

Solve all problems step by step and provide the answers for all problems in the following format:

Final Answers

Problem 1: \boxed{[answer 1]} Problem 2: \boxed{[answer 2]} ... Problem n: \boxed{[answer n]}

The structured output format requirement is important for evaluation: it allows the answer extraction module (Appendix E.2) to parse responses reliably, especially when models produce long-winded CoT reasoning.

Composition Variants for Code and Agentic Tasks

The core dependency chain construction from Algorithm 1 is designed for mathematical reasoning where answers are integers and dependency functions are simple arithmetic. For code and agentic tasks, the paper adapts the composition approach because these domains lack clean integer answers that can be substituted via arithmetic functions.

Code tasks: direct concatenation without dependencies (Appendix A). For code generation tasks (LiveCodeBench), the paper does not construct dependencies between problems. Instead, it concatenates multiple independent code problems into a single prompt using a "directly composed concatenation format" without adding dependency relationships. The prompt format (Figure 16) presents all problems together:

Question: {Questions}

Solve all problems step by step and provide the code for all problems. For each problem, read the inputs from stdin, solve the problem, and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within delimiters in the following format:

# YOUR CODE HERE

Why no dependencies for code? The paper's rationale is practical: "code tasks require sandbox execution to obtain answers, making it challenging to construct direct dependency relationships between problems and answers as in mathematical tasks." In mathematical tasks, the answer to Problem 1 is an integer that can be directly substituted into Problem 2's text and evaluated by the model during reasoning. In code tasks, the "answer" to Problem 1 is a program that must be executed to produce output — there is no clean numeric value that can be substituted into Problem 2's prompt. One could imagine constructing dependencies where Problem 2's input is the output of Problem 1's program, but this would require chaining sandbox executions during inference, which the evaluation infrastructure does not support. The direct concatenation design means that LiveCodeBench composed tasks test the model's ability to handle multiple independent coding problems within a single context window — a test of breadth (context management across sub-tasks) but not of dependency propagation (correctness propagation across sub-tasks).

Agentic tasks: graph-based decomposition with topological sorting (Appendix A). For web search tasks from WebShaper, the construction is substantially more complex. WebShaper questions are structured around target variables and intermediate variables — essentially, a question like "What is the population of the city where Company X is headquartered?" requires identifying intermediate values (Company X's headquarters location, that city's population) from web searches, then combining them. The paper's construction pipeline for these tasks:

  1. Filter for viable questions. From the original WebShaper dataset, questions are selected based on complexity levels, ultimately yielding 50 questions with accessible URLs.

  2. Extract variable values from web pages. For each question, Claude-Sonnet-4 browses the associated URLs and extracts values for each intermediate variable $V$. Variables that cannot be extracted are excluded.

  3. Assemble a Directed Acyclic Graph (DAG). The original questions and extracted variables are assembled into a DAG structure where nodes represent variables and edges represent dependency relationships (variable B depends on variable A).

  4. Topological sort and prune to create sub-questions. The DAG is topologically sorted (ordering nodes so that dependencies precede dependents), then pruned to derive sub-questions and seed questions. This yields sub-questions of increasing complexity: a question with 1 variable requires one piece of web-extracted information; a question with 5 variables requires collecting and combining five pieces.

  5. Filter erroneous decompositions. Questions with incorrect or duplicate decompositions are removed.

Output. The final WebShaper composed dataset contains 50 questions, each categorized into 5 levels based on the number of variables (ranging from 1 to 5), yielding 250 total seed problems. The dependency structure is implicit in the variable decomposition rather than explicit in a dependency function — a question with 5 variables naturally requires solving for all intermediate variables before combining them into the final answer.

**The evaluation prompt format (Figure 17) provides tool-calling instructions in the standard function-calling style, with the model expected to reason, call search tools as needed, and provide final answers in <answer></answer> tags. The multi-horizon aspect here is the number of variables that must be resolved — each variable may require a separate web search and reasoning step.

Evaluation Metrics: All-or-Nothing Accuracy and Theoretical Ceiling

The R-HORIZON benchmark evaluates models using two complementary metrics that together reveal both absolute performance and the gap between actual and potential performance.

All-or-nothing accuracy (Equation 3). Given a composed problem sequence $Q = (q_1, q'_2, ..., q'_n) \in \mathcal{D}_{composed}$ and the model's response $R$, the system extracts an answer sequence $\hat{A} = (\hat{a}_1, \hat{a}_2, ..., \hat{a}_n)$. The accuracy metric is:

Acc(Q)={1if a^i=ai for all i∈{1,...,n},0otherwise.\text{Acc}(Q) = \begin{cases} 1 & \text{if } \hat{a}_i = a_i \text{ for all } i \in \{1, ..., n\}, \\ 0 & \text{otherwise.} \end{cases}

where $\hat{a}_i$ is the model's extracted answer for problem $i$, $a_i$ is the ground-truth answer for problem $i$, and $n$ is the number of composed problems.

What it computes: for a single composed prompt, the metric returns 1 only if the model correctly solves every sub-problem in the chain — a single mistake anywhere in the sequence makes the entire composed instance count as a failure. This is a deliberately harsh metric designed to capture the brittleness of sequential reasoning: in real-world sequential tasks, a single error early in a chain can invalidate all downstream work, so success requires sustained accuracy across the full horizon.

Why this form: an alternative metric would be to score each sub-problem independently and report per-position accuracy (e.g., "Problem 1 accuracy: 80%, Problem 2 accuracy: 60%, ..."). But such a metric would obscure the dependency structure — Problem 2 accuracy cannot be interpreted independently of Problem 1 accuracy because Problem 2 depends on Problem 1's answer. The all-or-nothing metric directly measures the probability that the model can complete a multi-step task without a single mistake, which is the quantity that matters for applications where correctness must be guaranteed end-to-end (e.g., a mathematical proof where a single algebraic error invalidates the conclusion; a code pipeline where one function's bug corrupts downstream outputs). The paper's ablation in Appendix D.2 shows that alternative metrics like $\text{Acc}_{last}$ (only requiring the final problem to be correct) yield substantially higher numbers but are misleading because models sometimes coincidentally get the final answer right despite upstream errors.

Theoretical accuracy (Equation 4). To establish an upper bound on what composed-problem performance "should" be if the model's reasoning quality does not degrade across the horizon, the paper defines:

Accexpected(Q)=∏i=1npi\text{Acc}_{expected}(Q) = \prod_{i=1}^{n} p_i

where $p_i$ is the pass rate of atomic problem $q_i$ — the probability that the model solves problem $q_i$ correctly when presented in isolation (single-horizon).

What it computes: the product of individual single-problem pass rates across all composed problems. If the model achieves 90% accuracy on Problem 1, 80% on Problem 2, and 70% on Problem 3 when each is presented separately, the theoretical accuracy for a 3-problem composed chain is $0.9 \times 0.8 \times 0.7 = 0.504$ — roughly 50%. This is the accuracy we would expect if solving composed problems were no harder than solving individual problems and errors across problems were independent.

Why this form: the product-of-probabilities assumption models the situation where the model's reasoning on each sub-problem is unaffected by the presence of other sub-problems in the context. It assumes no interference, no context-window degradation, no attention dilution, and no error propagation from dependency computation. In other words, it represents a best-case ceiling for what composed-problem accuracy could be if the only factor were the inherent difficulty of each sub-problem. The gap between $\text{Acc}(Q)$ (actual composed accuracy) and $\text{Acc}_{expected}(Q)$ (theoretical ceiling) is the paper's primary diagnostic signal — it quantifies how much the multi-horizon structure degrades performance beyond what individual problem difficulty would predict. Figure 1 and Figure 3 show this gap growing dramatically as the number of composed problems increases: at $n = 16$ on MATH500, many 7B models have actual accuracy near 0% while their theoretical accuracy (based on >90% single-problem pass rates) would predict accuracy around 20-30%.

Answer extraction details (Appendix E.2). The paper uses GPT-4.1 for answer extraction from model responses, motivated by the finding that rule-based extraction (looking for \boxed{} patterns) becomes unreliable as the number of composed problems increases. Table 3 shows that for R1-Qwen-7B on MATH500, the consistency rate between model-based and rule-based extraction drops from 96.8% at $n=2$ to 91.0% at $n=16$ — models increasingly fail to follow the prescribed output format when handling many problems. The extraction prompt for mathematical tasks (Figure 18) is: "Extract the question numbers and corresponding answers from the given results, and return them in JSON format, where the key is the question number and the value is the answer." For WebShaper tasks (Figure 19), the extraction prompt asks GPT-4.1 to judge equivalence between predicted and labeled answers, responding "Correct" or "Incorrect." For code tasks, code blocks are extracted via pattern matching and correctness is assessed through sandbox execution (the only domain where evaluation is fully automated without an LLM judge).

Dataset sizes and sampling details. Table 2 reports the scale of each composed dataset. MATH500: 257 seed questions yield 500 composed instances (multiple compositions from overlapping seed pools). AIME24 and AIME25: 28 seed questions each yield 30 composed instances (harder problems, fewer viable compositions). For AIME datasets, results are reported as $\text{Avg@}k$ — average accuracy over $k$ independent generations (32 for AIME, 8 for AMC23) — to account for the high variance on small problem sets. LiveCodeBench: 279 seed questions yield 279 composed instances, evaluated at $\text{Pass@}1$ (single generation). WebShaper: 117 filtered variables from 500 original questions yield 50 composed instances, evaluated at $\text{Avg@}3$. The inference budget per question is substantial: models generate up to 64k tokens per response, with temperature 1.0, top-k 10, and top-p 0.95.

RLVR Training with R-HORIZON Composed Data

The training component of R-HORIZON uses the same composed problem sequences as training prompts for reinforcement learning with verifiable rewards (RLVR). The core question is: if standard RL training on single problems produces models that struggle on composed problems (Appendix B), does training on composed problems teach something different?

Training data construction for RL. The training data pool starts from the Skywork-OR1-RL dataset, filtered through R-HORIZON's Problem Filtering (Section 3.1) to obtain 18,015 seed problems. These are composed into sequences of varying lengths: $n=2$, $n=4$, and a mixed setting where problems have varying composed counts (1, 2, 3, 4). To control difficulty, compositions are constrained such that $\text{Acc}_{expected} > 0.25$ — the product of individual pass rates must exceed 25%, ensuring that the composed problems are not impossibly hard even for the untrained model. This yields 18,000 final training instances (Table 4).

Base model and optimization algorithm. All RL experiments use R1-Qwen-7B as the base model (the 7B-parameter DeepSeek-R1-distilled Qwen model). The optimization algorithm is GRPO (Group Relative Policy Optimization), which eliminates the value function requirement of PPO by computing advantages in a group-relative manner. For each training question $q$, the behavior policy $\pi_{\theta_{old}}$ samples $G$ response candidates $\{o_1, ..., o_G\}$. GRPO optimizes the policy $\pi_\theta$ by maximizing:

JGRPO(θ)=Eq,{oi}i=1G[1∑i=1G∣oi∣∑i=1G∑t=1∣oi∣min⁡(ri,tA^i,t,clip(ri,t,1−ϵ,1+ϵ)A^i,t)−βDKL[πθ∣∣πref]]J^{GRPO}(\theta) = \mathbb{E}_{q, \{o_i\}_{i=1}^G} \left[ \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \min\left(r_{i,t} \hat{A}_{i,t}, \text{clip}(r_{i,t}, 1 - \epsilon, 1 + \epsilon) \hat{A}_{i,t}\right) - \beta D_{KL}[\pi_\theta || \pi_{ref}] \right]

where $r_{i,t} = \frac{\pi_\theta(o_{i,t} | q, o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t} | q, o_{i,<t})}$ is the token-level importance weight (ratio of new-policy probability to old-policy probability for token $t$ of output $i$), $\epsilon$ is the clipping hyperparameter (set to 0.265), $\beta$ is the KL penalty coefficient (set to 0 — no KL regularization is applied in the main experiments), and $\hat{A}_{i,t}$ is the group-relative advantage of output $i$ at token $t$.

What it computes: for each training question, the model generates $G=16$ candidate responses. Each response receives a scalar reward (defined by the reward schemes below). Within the group of 16, advantages are computed relative to the group mean — responses with above-average reward get positive advantages, below-average get negative advantages. The PPO-style clipped objective then encourages the policy to increase probability of tokens in high-advantage responses while not deviating too far from the old policy (enforced by the clipping). The optional KL term (set to zero here) would additionally penalize divergence from a frozen reference policy.

Why this form: GRPO is chosen because it eliminates the need for a separately trained value function (critic), reducing memory and training complexity. The group-relative advantage computation is simpler than generalized advantage estimation (GAE) and works well when the reward signal is sparse and binary (correct/incorrect), as is the case for verifiable math problems. The high clip ratio (0.265, compared to the standard 0.2 in PPO) and absence of KL regularization represent design choices that prioritize aggressive policy updates — the paper's training setup follows the Skywork-OR1 recipe, which found these settings effective for mathematical reasoning RL.

Training hyperparameters (Appendix F.1). The paper provides detailed training configuration: maximum response length of 40k tokens (to prevent truncation on multi-problem prompts), constant learning rate of $1 \times 10^{-6}$, batch size of 256, mini-batch size of 128, group size of 16 (16 sampled responses per question), clip ratio of 0.265, target entropy of 0.2, sampling temperature of 1.0, and rejection sampling enabled. Training is conducted exclusively on the mathematical components of the Skywork-RL dataset. The paper explicitly notes that no KL loss is applied, consistent with recent findings that KL regularization may be unnecessary or even harmful for reasoning RL when the reward signal is clean and verifiable.

Two reward schemes for composed problems (Equation 6). The reward design is where R-HORIZON training diverges from standard RLVR. For a composed problem sequence of length $n$, two reward functions are studied:

Rlast={1if a^n=an,0otherwise.andRall={1if a^i=ai for all i∈{1,...,n},0otherwise.R_{last} = \begin{cases} 1 & \text{if } \hat{a}_n = a_n, \\ 0 & \text{otherwise.} \end{cases} \quad \text{and} \quad R_{all} = \begin{cases} 1 & \text{if } \hat{a}_i = a_i \text{ for all } i \in \{1, ..., n\}, \\ 0 & \text{otherwise.} \end{cases}

where $\hat{a}_n$ is the model's final answer in the chain, $a_n$ is the ground-truth final answer, and $\hat{a}_i, a_i$ are the predicted and ground-truth answers for intermediate sub-problem $i$.

What they compute: $R_{last}$ (the default reward used in the main experiments) provides a reward of 1 if and only if the last problem in the chain is answered correctly, regardless of errors in intermediate problems. $R_{all}$ provides a reward of 1 if and only if every problem in the chain is answered correctly.

Why these two forms: the distinction allows studying how reward granularity affects learning of long-horizon reasoning. $R_{last}$ is permissive — it rewards the model for getting the final answer right even if it made mistakes along the way (perhaps because it reverse-engineered the dependency variables, as documented in Appendix D.2). This could encourage the model to learn shortcuts and neglect intermediate correctness. $R_{all}$ is strict — it demands end-to-end correctness, which should incentivize careful reasoning at every step and proper error propagation. Table 1's comparison shows that $R_{all}$ with $n=2$ composed training outperforms $R_{last}$ when evaluated on multi-problem scenarios (39.5 vs. 36.5 average on multi-horizon benchmarks), but interestingly $R_{last}$ shows stronger gains on single-problem performance (76.1 vs. 75.9 average on original benchmarks). This suggests a trade-off: $R_{all}$ produces models that are better at maintaining correctness across a chain (because that's what they're rewarded for), while $R_{last}$ produces models that are better at solving individual problems efficiently (perhaps because they learn to skip unnecessary verification when the final answer can be reached by alternative paths).

Training progression with composed data (Section 4.3, Figure 4). The training curves compare models trained on single-problem data ($n=1$) versus 2-problem composed data ($n=2$), both evaluated on AIME24 single-problem ($n=1$) and AIME24 2-problem composed ($n=2$). Key observations: (1) on single-problem AIME24, composed-data training achieves roughly 0.675 accuracy at 600 steps vs. 0.600 for single-data training — a +7.5 percentage point gain that emerges gradually over training; (2) on composed-problem AIME24, composed-data training reaches roughly 0.35 accuracy vs. 0.175 for single-data training — a +17.4 point gain that appears early and widens; (3) the reward curve for composed training data starts lower but eventually surpasses single-data training reward (roughly 0.67 vs. 0.65 at 600 steps). The fact that composed training improves single-problem performance is a key finding: practicing multi-problem chains teaches better thinking budget management that transfers to single-problem efficiency.

Why composed training improves single-problem performance. The paper's hypothesis (developed in Section 5.2 and Figure 9) is that composed training teaches thinking budget allocation — the model learns to not over-invest tokens in early reasoning steps because it knows more problems are coming, and this efficiency carries over to single-problem settings where the model similarly avoids overthinking. Section 5.2 documents that models trained on composed data generate shorter responses per problem (Figure 9b) and allocate tokens more evenly across sub-problems (Figure 9d), compared to single-data-trained models that lavish tokens on the first problem and starve later ones. The finding that $R_{last}$ achieves better single-problem performance than $R_{all}$ supports this interpretation: $R_{last}$ rewards efficient path-finding to the final answer, which transfers to single problems as efficient problem-solving, while $R_{all}$ rewards meticulous verification at every step, which is less beneficial when only one problem needs solving.

Appendix B: Standard RL training progression. As context for why composed training is necessary, Appendix B documents what happens when standard RL (single-problem training data only) is applied to improve reasoning. The three-stage training (8k → 16k → 32k response lengths) improves single-problem AIME24 from roughly 0.30 to 0.66 across 1680 steps, but 2-problem composed AIME24 only improves from roughly 0.12 to 0.21 — a much smaller gain. Critically, when the context length increases from 16k to 32k (stage 3), response length jumps from ~7k to ~11k tokens, but performance on both single and composed problems barely improves. This shows that simply giving models more thinking budget (longer context) does not teach them to use it effectively across multiple problems — they need composed training data to learn multi-horizon allocation.

4. Key Insights and Innovations

Innovation 1: Dependency Chain Composition as a Diagnostic for Reasoning Horizon Collapse

The paper's most fundamental conceptual move is not the method itself — stitching problems together — but what that method reveals: that current Large Reasoning Models suffer from a sharp, measurable collapse in reasoning quality that sets in at a characteristic token distance regardless of problem count. Prior work had documented that CoT reasoning has an optimal length beyond which performance degrades (Wu et al., 2025b; Ghosal et al., 2025; Chen et al., 2024) and that LRMs "overthink" on simple problems (Chen et al., 2025). But all of this prior work examined reasoning degradation within a single problem — the model's attention wanders, it starts repeating itself, it loses the thread. R-HORIZON demonstrates something more subtle and arguably more concerning: the degradation is not just about length in the abstract; it is about position in a multi-problem chain. The error position analysis (Figure 6) shows that R1-Qwen-7B's errors reliably cluster around 4-6k tokens into the response, and R1-Qwen-32B's errors cluster around 8-10k tokens, regardless of whether those tokens represent the third sub-problem in a 16-problem chain or the first sub-problem in a 2-problem chain. This is evidence for a fixed-length effective reasoning window — a hard attentional or representational boundary that the model cannot reason past, independent of how many subtasks it has completed or how many remain.

This reframes the overthinking problem. The dominant narrative in the field has been that LRMs are computationally wasteful — they spend tokens on unnecessary verification and verbose reasoning that doesn't improve accuracy. Length-control methods (Aggarwal & Welleck, 2025; Yang et al., 2025b) treat this as an efficiency problem to be optimized. R-HORIZON reveals that it is also a horizon management problem: the tokens the model squanders on early problems are tokens it cannot spend on later problems. The 7B model's error position stabilizes at ~5k tokens not because it has reached some optimal reasoning depth for a single problem, but because it has exhausted the portion of its context window where it can maintain coherent reasoning. Everything after that point operates at degraded quality. This is a fundamentally different diagnosis: the problem is not that the model wastes tokens, but that the model cannot sustain reasoning quality beyond a model-specific token horizon. The implication is that test-time scaling strategies that allocate more total tokens (longer generation) will not help multi-step reasoning unless they also address where in the sequence those tokens are being spent. This is a diagnostic contribution, not a method contribution — but it is arguably more valuable than a method contribution because it tells the field what needs to be fixed rather than offering yet another optimization trick.

The dependency chain design is what makes this diagnosis possible. REST (Pan et al., 2025) had shown that concatenating independent problems degrades performance, but independent concatenation confounds two effects: context-window dilution (the model has more information to track) and sequential reasoning degradation (the model must sustain reasoning quality across steps). By constructing problems where each downstream problem literally cannot be solved without the previous answer (via the dependency function), R-HORIZON isolates the sequential reasoning component. The gap between dependent and independent concatenation (Appendix D.1, Figure 12) — dependent problems perform significantly worse — is clean evidence that sequential dependency imposes an additional burden beyond mere context-window crowding. This is a careful experimental design choice that yields cleaner causal attribution than prior work.

Innovation 2: Multi-Horizon Training Data as a Mechanism for Teaching Thinking Budget Allocation

The paper's second major conceptual contribution is the finding that composing training problems teaches models something that single-problem training does not: how to allocate a finite thinking budget across multiple sub-tasks. This is not an architectural change, a new loss function, or a novel RL algorithm. It is a purely data-side intervention — present the same math problems, but linked into chains — and it produces measurable improvements on both composed tasks (+17.4 on AIME24 n=2) and single-problem tasks (+7.5 on AIME2024). The dual improvement is what makes this finding intellectually significant: it suggests that thinking budget allocation is a transferable meta-skill that the model can learn and apply even when only one problem is present.

The field's implicit assumption, encoded in the standard RLVR training pipeline, has been that reasoning is problem-specific — you train on hard problems to get better at hard problems, and the thinking budget is something the model figures out implicitly through the reward signal. The R-HORIZON training results challenge this assumption. When a model trained only on single problems faces AIME24 (single-problem evaluation), it has learned to solve AIME-style problems, but it has also learned — through the implicit structure of the training distribution — that it can spend whatever tokens it wants because there is only one problem to solve. When that same model faces a composed prompt, its single-problem-trained allocation strategy catastrophically fails: it dumps excessive tokens into Problem 1 and starves Problems 2 through n (Figure 8). The composed-data-trained model, by contrast, has learned through experience that tokens spent on early problems are tokens unavailable for later problems, and it allocates accordingly — not just on composed prompts, but also on single-problem prompts where this efficiency yields accuracy gains by preventing overthinking.

This is a conceptual contribution to the understanding of what RLVR actually teaches. The standard view is that RLVR on math problems teaches mathematical reasoning — the model learns to chain logical steps, verify intermediate results, and avoid common errors. R-HORIZON suggests that RLVR also teaches — unintentionally, through the structure of the training distribution — a problem-solving posture: how aggressively to think, how much verification to perform, when to move on. Single-problem training teaches a posture of unbounded depth (think as long as needed; there are no downstream costs). Composed-problem training teaches a posture of depth-with-breadth (think enough to solve this, but preserve budget for what comes next). The fact that these postures transfer across problem counts means that the posture is not just a context-specific adaptation but a learned behavior that the model internalizes.

This insight connects to the broader discourse on "overthinking" (Chen et al., 2025; Su et al., 2025) but provides a different causal explanation. Prior work attributes overthinking to the model's failure to recognize problem difficulty — it applies the same intensive reasoning to simple problems as to hard ones. R-HORIZON reveals an additional mechanism: the model's thinking budget allocation is shaped by the implicit horizon of its training distribution. A model trained exclusively on single problems has never experienced the consequence of over-investing in one sub-problem at the expense of another, so it has no gradient signal pushing it toward efficient allocation. Composed training provides exactly that signal, and the model learns the allocation skill even though it was never explicitly rewarded for efficiency — the skill emerges as a byproduct of the multi-problem reward structure.

Innovation 3: Reflection Localization as the Hidden Failure Mode in Sequential Reasoning

The paper's analysis of reflection behavior across problem chains (Section 5.1, Figure 7) surfaces a previously undocumented limitation: as reasoning horizons expand, models' reflection becomes increasingly localized to the current sub-problem, failing to cross problem boundaries even when correctness depends on correctly propagating earlier answers. The "Long Reflection Rate" metric — the proportion of problems where the model's reflection spans beyond the current problem — increases with chain length (because there are more opportunities to look back) but plateaus far below what effective sequential reasoning would require. More than half of all sub-problems in longer chains exhibit no long-range reflection whatsoever.

This finding matters because it reveals a specific structural failure, not just a general degradation. The field knows that reflection and self-correction are important reasoning behaviors — many test-time scaling strategies are built around them. But the dominant analysis of reflection has been within-problem: does the model catch its own arithmetic mistake? Does it verify an intermediate step? R-HORIZON shows that even when models do reflect (and Figure 7 shows reflection frequency does increase with chain length, converging to a maximum value), the reflection is overwhelmingly locally scoped — the model checks its work on Problem 4 but never asks whether the dependency variable from Problem 3 was correctly computed. This is a distinct failure mode from the overthinking that prior work identifies. It is not that the model thinks too much; it is that it thinks in the wrong places, applying within-problem verification while neglecting cross-problem dependency verification.

The connection to training is instructive. The reflection localization pattern likely emerges because standard RLVR training data consists of single problems — the model learns to reflect within a problem because that is the only reflection scope that has ever been rewarded. There has never been a training signal telling the model that it should check whether the answer it is using from a previous problem is actually correct. The composed-data training partially addresses this: Figure 9(c) shows that models trained on composed data exhibit higher long-reflection rates and more reasonable reflection frequency scaling with chain length. But even composed-data-trained models do not achieve universal cross-problem reflection. This suggests that reflection scope is a distinct skill that requires explicit training signal to develop — it does not automatically emerge from multi-problem exposure alone.

This is a diagnostic contribution with direct implications for future training methodology. If we want models that can sustain reasoning across long horizons, we need to explicitly reward cross-problem reflection during training, not just end-to-end answer correctness. The R_all vs. R_last comparison (Table 1) is a step in this direction — R_all requires all intermediate answers to be correct, which implicitly incentivizes checking earlier work — but the reflection analysis suggests that more targeted interventions (e.g., auxiliary rewards for explicitly verifying dependency propagation steps) may be necessary.

Innovation 4: The Theoretical Accuracy Ceiling as a Clean Metric for Isolating Multi-Horizon Degradation

The paper's use of theoretical accuracy — the product of individual single-problem pass rates (Equation 4) — provides a conceptually clean decomposition of the performance gap that no prior multi-problem benchmark offers. When a model's actual composed accuracy falls below its theoretical accuracy, the gap cannot be attributed to the inherent difficulty of the sub-problems; it must be attributed to the multi-horizon structure itself. This decomposition separates three confounded effects that prior benchmarks (including REST) cannot disentangle: (1) the base difficulty of the individual problems, (2) the cost of maintaining multiple problem contexts simultaneously, and (3) the cost of sequentially solving and propagating dependencies.

The theoretical accuracy metric serves as a counterfactual upper bound that answers the question: "How well would this model perform if multi-horizon reasoning imposed no additional burden beyond the independent difficulty of each sub-problem?" The gap between actual and theoretical accuracy is a direct measure of the multi-horizon penalty. As Figure 1 and Figure 3 show, this gap grows dramatically with chain length — for R1-Qwen-7B on MATH500, the gap at n=8 is roughly 80 percentage points (theoretical accuracy ≈80%, actual ≈0-10%). This quantifies the severity of the problem in interpretable units: the model is losing almost all of its reasoning capability not because the problems are too hard, but because the sequential structure is too demanding.

This is methodologically significant because it provides a universal yardstick for comparing different models' multi-horizon capabilities independent of their absolute performance levels. A model with 50% single-problem accuracy on a dataset and a model with 90% single-problem accuracy will have different theoretical ceilings — 25% vs. 81% for a 2-problem chain. Comparing their raw composed accuracies would confound base capability with multi-horizon resilience. Comparing the gap between actual and theoretical accuracy — expressed as a ratio or difference — isolates the multi-horizon effect. The paper does not compute this gap explicitly as a normalized metric, but the framework enables it, and the per-difficulty-bin performance curves (Figure 3, Figure 6) implicitly use this logic by showing both actual and theoretical accuracy on the same axes. This is a small but important methodological contribution that future multi-horizon benchmarks would do well to adopt.

The theoretical accuracy metric also serves as a diagnostic for where degradation occurs. When the actual-theoretical gap is small on short chains but large on long chains (as is consistently observed), it indicates that the degradation mechanism is cumulative — each additional problem imposes an incremental cost that compounds, rather than a one-time context-switching cost. This rules out simple explanations like "the prompt is too long" (which would produce a flat penalty regardless of chain length after the first few problems) and supports explanations involving gradual attentional decay or progressive budget depletion. The fact that this cumulative degradation is observed even in models with context windows far exceeding the prompt length (64k generation budget vs. prompts that rarely exceed a few thousand tokens) further rules out raw capacity limits — the degradation is a reasoning quality phenomenon, not a memory limitation.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The R-HORIZON benchmark comprises six reconstructed datasets spanning mathematical reasoning, code generation, and agentic tasks. For math: MATH500 (500 composed instances from 257 seed questions), AIME24 (30 composed instances from 28 seed questions, evaluated at Avg@32), AIME25 (30 composed instances from 28 seed questions, Avg@32), and AMC23 (40 composed instances from 37 seed questions, Avg@8). For code: LiveCodeBench v5 (279 composed instances from 279 seed questions, Pass@1). For agentic tasks: WebShaper (50 composed instances from 117 filtered variables across 500 original questions, evaluated at Avg@3). Composed instances for math tasks use sequentially dependent concatenation with dependency functions linking answers across problems; code tasks use direct concatenation without dependencies; agentic tasks use graph-based variable decomposition from directed acyclic graphs (Table 2, Appendix A). Each composed instance spans horizon lengths n ranging from 1 (single problem) to a maximum of 16 for MATH500 and 5 for the other datasets.

  • Base model(s). The paper evaluates 25 open-source Large Reasoning Models (LRMs) spanning a wide parameter range from 1.5B to 235B parameters: the DeepSeek-R1-distilled series (R1-Qwen-1.5B, R1-Qwen-7B, R1-Qwen-32B, R1-Llama-8B, R1-Llama-70B), Qwen3 series (Qwen3-8B, Qwen3-32B, Qwen3-235B-A22B-Instruct, Qwen3-235B-A22B-Thinking, QwQ-32B), Nemotron series (Nemotron-Research-Reasoning-Qwen-1.5B, Llama-3.1-Nemotron-Nano-8B), the Polaris series (1.7B and 4B), Skywork-OR1 (7B and 32B), as well as DeepScaleR-1.5B, OpenThinker3-7B, Efficient-R1-7B, Laser-DE-L4096-7B, and DAPO-Qwen-32B. Three proprietary frontier models are also included: DeepSeek-R1, o4-mini, and Claude-Sonnet-4. This diverse coverage is chosen to establish the universality of multi-horizon degradation across model scales, architectures, and training recipes. The RL training experiments use R1-Qwen-7B as the base model, chosen as a representative mid-scale reasoning model with strong single-problem performance but clear multi-horizon limitations.

  • Metrics. The primary metric for mathematical and agentic tasks is all-or-nothing accuracy (Equation 3): a composed prompt Q of n problems scores 1 only if all n extracted answers â_i match the ground-truth a_i, and 0 otherwise. For AIME and AMC datasets, results are reported as Avg@k — the average over k independent generations (32 for AIME, 8 for AMC23) to account for variance on small problem sets. For LiveCodeBench, results are reported as Pass@1 (single generation, evaluated via sandbox execution). A complementary metric is theoretical accuracy (Equation 4): the product of individual single-problem pass rates p_i for the constituent sub-problems, representing the expected composed accuracy if multi-horizon structure imposed no additional burden. The gap between actual and theoretical accuracy quantifies the multi-horizon penalty. Answers for math tasks are extracted using GPT-4.1 (model-based extraction chosen because rule-based \boxed{} parsing becomes unreliable at longer horizons — Table 3 shows consistency between model-based and rule-based extraction dropping from 96.8% at n=2 to 91.0% at n=16 on MATH500 for R1-Qwen-7B). For WebShaper tasks, GPT-4.1 judges answer equivalence. For code tasks, code blocks are extracted via pattern matching and executed in sandbox environments.

  • Baselines. The primary baseline for comparison is single-horizon performance (n=1) on each dataset, representing the model's capability without multi-horizon degradation. For the RL training experiments (Section 4.3), the baseline is standard RLVR training on single-problem data (the original Skywork-OR1-RL dataset without composition). The paper also compares against the theoretical accuracy ceiling as an upper bound. No prior methods for multi-horizon reasoning improvement are implemented as baselines because the paper positions itself as the first systematic framework for evaluating and training multi-horizon capabilities — there is no established prior method to compare against.

  • Generation budget / compute accounting. For evaluation, the generation budget is capped at a maximum of 64,000 new tokens per response for models supporting that length (40,000 for Qwen3-8B and Qwen3-32B; 32,000 for OpenThinker3-7B). This generous budget is chosen to avoid output truncation confounding the results — the research question concerns reasoning quality degradation, not premature termination. Inference hyperparameters: temperature 1.0, top-k 10, top-p 0.95. For RL training, the maximum response length is 40,000 tokens, with batch size 256, mini-batch size 128, and group size 16 (16 candidate responses sampled per training question). The paper does not report or account for the computational cost of difficulty estimation or data composition itself, focusing instead on per-query evaluation cost. Training computational cost is not explicitly compared across methods (e.g., FLOPs or GPU-hours for single-horizon vs. multi-horizon training), which is a limitation noted in the critical assessment.

  • Cross-validation / statistical protocol. For evaluation, no train/validation/test splits are used — all models are evaluated directly on the composed test sets without any model-specific fine-tuning or strategy selection on held-out data. The RL training experiments (Section 4.3, Appendix B) evaluate on separate benchmark datasets (AIME24, AIME25, MATH500, AMC23) that are independent of the Skywork-OR1-RL training data, and results are reported at specific training step counts with single-run training curves (no multiple random seeds or error bars are reported). Difficulty binning for the difficulty-ordering ablation (Appendix D.3) uses the pass rate of R1-Qwen-7B as a reference, with "easy" defined as pass rate > 0.5 and "hard" otherwise, but this is for analysis only and does not involve model-specific policy selection that would require cross-validation to prevent overfitting.

Main Quantitative Results

Universal Performance Degradation with Increasing Reasoning Horizon

The central empirical finding is documented in Figure 3: all 25 evaluated models exhibit severe performance degradation as the number of composed problems increases, and this degradation is consistent across tasks of varying types and difficulty levels. On MATH500, R1-Qwen-7B drops from 93.6% at n=1 to 0.0% at n=16 — a collapse from near-perfect to zero. R1-Qwen-32B drops from 98.4% at n=1 to 25.6% at n=16. Even DeepSeek-R1, the strongest open model, drops from 97.8% at n=1 to 45.6% at n=16. The degradation is monotonic with horizon length for all models, with the steepest drops occurring in the transition from n=4 to n=8 and n=8 to n=16 for MATH500. For AIME25 — the hardest mathematical dataset — the degradation is more severe: DeepSeek-R1 drops from 87.3% at n=1 to 24.6% at n=5; Qwen3-235B-Thinking drops from 92.3% to 29.2%; R1-Qwen-7B drops from 33.3% to 3.5%. The paper notes a clear model-size effect: larger models exhibit less degradation. R1-Qwen-7B's drop of 93.6 percentage points on MATH500 (from 93.6% to 0.0% at n=16) represents 34.1% more degradation than the 32B model's drop of 72.8 points (from 98.4% to 25.6%).

For code tasks (LiveCodeBench, Figure 3), the degradation is more severe than for mathematical tasks at comparable horizon lengths. Smaller models (7B) struggle to complete multiple code problems — R1-Qwen-7B drops from 39.1% at n=1 to 0.0% at n=5, and multiple 7B-class models reach near-zero performance by n=3-4. Even Qwen3-235B-Thinking drops from 64.5% at n=1 to 2.9% at n=5. For web search tasks (WebShaper, Figure 3), an additional problem emerges: many trained reasoning models have lost the ability to call tools, resulting in poor performance even at n=1. Claude-Sonnet-4 achieves the best web search performance at 83.7% at n=1 but drops to 81.4% at n=5 — a relatively modest degradation compared to math tasks, likely because the tool-based evaluation is fundamentally different from pure reasoning chains. However, reasoning-focused models like DeepSeek-R1 underperform on this agentic task (53.3% at n=1).

The gap between actual and theoretical accuracy (Figure 1, Figure 6) widens substantially as horizon increases. For R1-Qwen-7B on MATH500 at n=16, the theoretical accuracy (product of individual pass rates) would predict a substantial non-zero accuracy, but actual accuracy hits zero — the entire multi-horizon penalty is not from problem difficulty but from the sequential structure itself. For R1-Qwen-32B on AIME24 at n=5, actual accuracy is roughly 20-25% while theoretical accuracy is substantially higher (the expected product curve in Figure 6 shows a much gentler decline). This demonstrates that model capability on individual sub-problems is not the limiting factor — the multi-horizon structure itself is.

Effective Reasoning Length Bounds Model Performance

The error position analysis (Figure 6) reveals that models fail at characteristic token counts regardless of how many problems are in the chain. For R1-Qwen-7B on MATH500, the error position stabilizes around 4,000-6,000 tokens — as n increases from 1 to 20, the output length grows linearly, but the error position plateaus. The model's errors consistently occur at roughly the same token distance into the response, meaning that for long chains, errors cluster in early problems (because later problems are beyond the effective reasoning horizon). For R1-Qwen-32B, the error position stabilizes around 8,000-10,000 tokens — roughly double the 7B model's effective length, indicating scale-dependent improvement in sustained reasoning. On AIME24, the same pattern holds: the 7B model's error position plateaus around 5,000-7,000 tokens, while the 32B model's plateaus around 12,000-15,000 tokens (the harder problems push the effective length outward because individual problems require more tokens to solve). The key implication is that effective reasoning length is model-specific and size-dependent, and exceeding this length — whether by adding more problems or by generating verbose solutions — leads to sharply increased error rates regardless of problem difficulty.

Thinking Budget Allocation Is Myopic

Figure 8 documents the allocation of thinking budget (tokens per problem) across composed query positions for AIME24. For R1-Qwen-7B with a 5-problem composed query, Problem 1 receives approximately 15,000-20,000 tokens, Problem 2 receives roughly 10,000-15,000, and Problems 3-5 receive sharply diminishing budgets (Problem 5 receives fewer than 5,000 tokens). R1-Qwen-32B shows a similar but slightly more balanced pattern: Problem 1 receives ~15,000-20,000, Problem 2 ~10,000-15,000, Problems 3-4 ~5,000-10,000, Problem 5 ~2,000-5,000. DeepSeek-R1 — the most capable model — still exhibits the same front-loaded allocation: Problem 1 receives the largest token budget, and Problems 3-5 receive substantially less. The paper explicitly states that "even DeepSeek-R1 cannot effectively distribute the thinking budget reasonably to subsequent problems, indicating that current mainstream LRMs have not yet developed the capability to allocate thinking budgets according to reasoning horizon." This myopic allocation is consistent with the effective reasoning length finding: models invest heavily in early reasoning because that is where their reasoning quality is highest, and the allocation to later problems diminishes as the model approaches its effective reasoning boundary.

Reflection Is Frequent but Remains Locally Scoped

Figure 7 analyzes reflection behavior on MATH500 across three models (R1-Qwen-7B, R1-Qwen-32B, DeepSeek-R1). Reflection frequency (average number of reflections per question) increases with composed query number and converges to a maximum value — roughly 40-50 reflections per question for the 7B model, 30-40 for the 32B model, and 20-30 for DeepSeek-R1 at longer horizons. However, the long reflection rate — the proportion of problems whose reflection range exceeds the current problem (i.e., reflections that cross problem boundaries) — increases with chain length but plateaus well below what effective dependency tracking would require. For R1-Qwen-7B at n=16, the long reflection rate is approximately 30-40%, meaning that 60-70% of sub-problems receive no cross-problem reflection at all. The model reflects within Problem 4 but does not check whether Problem 3's answer — which Problem 4 depends on — was correct. Even DeepSeek-R1's long reflection rate at n=16 on MATH500 is below 40%. The paper's interpretation: "LRMs' reflections are highly localized" to the current problem, failing to verify dependency propagation across problem boundaries.

Error Types Reveal That Early Stopping and Problem Reasoning Errors Dominate

Figure 5 breaks down error types by composed query number for R1-Qwen-7B and R1-Qwen-32B on MATH500 and AIME24. Five error categories are tracked: (1) Problem Reasoning Error — the model makes a reasoning mistake within a specific sub-problem; (2) Dependency Reasoning Error — the model solves previous problems correctly but makes an error when computing the dependency function (calculating the variable that links one problem to the next); (3) Early Stop — the model terminates its response after solving some but not all sub-problems; (4) Output Truncation — generation exceeds the token limit; and (5) Correct — all problems solved correctly. As the number of composed problems increases, Problem Reasoning Errors increase rapidly and come to dominate the error distribution. Dependency Reasoning Errors also increase gradually but remain a relatively small fraction of total errors (roughly 5-15% across horizons). Early Stop errors become substantial at longer horizons (visible as the third-largest slice in the stacked bars at n=16 for MATH500, constituting roughly 10-20% of cases), indicating that models simply give up on later problems without making an attempt. Output Truncation, by contrast, is negligible — the 64k token budget is rarely exhausted. The key diagnostic implication: the primary failure mode is not that models fail to compute dependencies correctly, but that their core problem-solving reasoning degrades as the horizon lengthens, and they increasingly abandon later problems entirely.

RLVR with Composed Training Data Improves Both Multi-Horizon and Single-Horizon Performance

The training results in Section 4.3 and Figure 4 compare models trained on single-problem data (n=1) versus 2-problem composed data (n=2). After 600 training steps on R1-Qwen-7B:

  • Multi-horizon performance (AIME24 n=2): Composed-data training achieves approximately 0.35 accuracy vs. approximately 0.175 for single-data training — a +17.4 percentage point gain that emerges early in training and widens throughout. The single-data-trained model shows only marginal improvement on the composed task despite significant gains on single-problem performance.

  • Single-horizon performance (AIME24 n=1): Composed-data training achieves approximately 0.675 accuracy vs. approximately 0.600 for single-data training — a +7.5 percentage point gain that accumulates gradually over the training run. This is the non-obvious finding: training on harder, multi-problem chains improves single-problem performance more than training on single problems directly.

  • Training reward: The average reward for composed-data training starts lower (roughly 0.50 vs. 0.55) but eventually surpasses single-data training reward (roughly 0.67 vs. 0.65 at 600 steps), indicating that the model learns to solve the harder composed tasks at a reward level that exceeds the easier single-problem reward — a pattern that would not occur if composed problems were simply harder versions of the same task.

Table 1 reports the impact of varying the number of composed training queries and the reward function. Comparing the naive baseline (single-problem training, n=1) against various composed-data configurations:

Training ConfigurationMATH500 n=8AIME24 n=2AIME25 n=2AMC23 n=2Avg (Multi)Avg (Origin)
Naive (n=1)8.416.75.155.021.374.3
Composed n=2 (R_last)21.434.110.080.636.576.1
Composed n=4 (R_last)50.634.88.179.143.273.7
Composed mixed (R_last)47.832.810.081.643.172.8
Composed n=2 (R_all)26.838.811.983.440.275.9

The composed-data-trained models all substantially outperform the naive baseline on multi-horizon tasks. Increasing the number of composed queries from n=2 to n=4 significantly improves performance on MATH500 n=8 (21.4 → 50.6), suggesting that training with longer chains builds the capability to handle even longer evaluation chains — a form of horizon generalization. The R_all reward (n=2) produces the best multi-horizon average (40.2 vs. 36.5 for R_last n=2) and the strongest individual results on AIME24 n=2 (38.8 vs. 34.1) and AIME25 n=2 (11.9 vs. 10.0), at a small cost to single-problem performance (75.9 vs. 76.1 average on original benchmarks). The mixed configuration (varying composed query counts in training) achieves multi-horizon performance comparable to fixed n=4 training (43.1 vs. 43.2 average) with slightly lower single-problem performance (72.8 vs. 73.7), suggesting no clear advantage to mixing horizon lengths over training on a fixed longer horizon.

Improvement from Standard RL Is Limited for Multi-Horizon Tasks

Appendix B (Figure 10) documents the progression of single-problem vs. composed-problem performance during standard three-stage RL training (single-problem data only, following the Skywork-OR1 recipe). Over 1680 training steps: AIME24 single-problem (n=1) improves from approximately 0.30 to 0.66 (+36.6 percentage points), while AIME24 composed (n=2) improves only from approximately 0.12 to 0.21 (+9.1 points). AIME25 single-problem improves from ~0.12 to ~0.42 (+30 points), while AIME25 composed improves minimally from ~0.02 to ~0.05 (+3 points). The paper notes that "the improvement on composed problems shows no clear correlation with the increase in response length" — when context length increases from 16k to 32k (stage 3), response length jumps from ~7k to ~11k tokens, but both single and composed accuracy plateau. Standard RL training teaches depth (better at harder single problems) but not breadth (better at sustaining reasoning across problems), and simply giving the model more thinking budget does not teach it to allocate that budget across multiple sub-tasks.

Ablation Studies and Robustness Checks

Dependencies vs. independent problems (Appendix D.1, Figure 12): Using R1-Qwen-7B on MATH500, removing all dependency construction (directly concatenating independent problems without dependency functions) yields higher accuracy than dependent composition at all horizon lengths. For example, at n=10, independent composition achieves roughly 30-40% accuracy vs. approximately 5-10% for dependent composition. Both fall below theoretical accuracy, but the dependent version's additional degradation — roughly 20-30 percentage points at n=10 — isolates the cost of maintaining and propagating sequential dependencies beyond the cost of managing multiple independent problems in a shared context. This confirms that dependency propagation is a distinct failure mode, not merely an artifact of context-window crowding.

Evaluation metric comparison: all-or-nothing vs. last-only (Appendix D.2, Figure 13): Comparing Acc_all (all problems must be correct, Equation 3) against Acc_last (only the final problem must be correct) reveals increasing divergence as horizon grows. On MATH500 with R1-Qwen-7B, Acc_last at n=16 is approximately 20-30% while Acc_all is near 0%. This gap implies that models sometimes correctly answer the final problem despite errors in preceding problems — a behavior that should be impossible for strictly dependent chains (if Problem 2 depends on Problem 1's answer, and Problem 1 is wrong, Problem 2 should be unsolvable). The paper documents this as an "anomalous phenomenon" and provides statistics on anomaly counts (Figure 13, right): at n=16, there are roughly 150-200 anomaly samples for the 7B model where the final answer is correct despite upstream errors. The paper hypothesizes data contamination as a possible explanation (models may have memorized answers to individual problems and can recognize them even when the dependency variable is wrong) but does not investigate further. This is a significant validity concern for the last-only metric and justifies the paper's choice of all-or-nothing scoring.

Query difficulty ordering (Appendix D.3, Figure 14): Using R1-Qwen-7B's pass rates as the difficulty reference (easy: pass rate > 0.5; hard: pass rate ≤ 0.5), the paper compares easy-to-hard ordering vs. hard-to-easy ordering for 2-problem composed chains. For R1-Qwen-7B, the ordering makes no significant difference — accuracy is similar for both orderings. For R1-Qwen-32B and DeepSeek-R1, hard-to-easy ordering produces higher accuracy than easy-to-hard ordering. The thinking budget analysis (Figure 14b, 14c) shows that all models still allocate more tokens to the first problem regardless of difficulty — even when the first problem is easy and the second is hard, Problem 1 receives a larger token budget. The larger models' benefit from hard-to-easy ordering is hypothesized to come from the difficult first problem naturally "forcing" the model to allocate more tokens where they are most needed, which smaller models cannot capitalize on because they lack the capacity to solve the hard problem regardless. Critically, no model demonstrates adaptive budget allocation based on problem difficulty — the allocation pattern is positional, not responsive to problem demands.

Consistency of answer extraction methods (Appendix E.2, Table 3): Comparing model-based extraction (GPT-4.1) against rule-based extraction (regex for \boxed{} patterns) on R1-Qwen-7B's MATH500 responses shows a consistency rate that degrades with horizon length: 96.83% at n=2, 96.41% at n=4, 93.77% at n=8, and 91.04% at n=16. The 9% inconsistency at n=16 represents cases where rule-based extraction fails to locate properly formatted answers. This validates the decision to use model-based extraction for the primary results, as rule-based extraction would introduce spurious errors at long horizons that could be misinterpreted as reasoning failures.

Training dynamics with composed data (Appendix C, Figure 11): The response length of models trained on composed data (n=2, n=4) initially decreases and then increases during training, eventually reaching levels comparable to single-data-trained models, with similar training time per step. However, the entropy loss decreases more rapidly for composed-data-trained models — by step 600, the entropy loss for n=4 training is approximately 0.25 vs. 0.35 for n=1 training, indicating that the policy distribution narrows faster when training on harder composed problems. The paper notes this "may limit the model's capacity for effective exploration" — the composed-data-trained model converges to a lower-entropy policy that may be less robust to novel problem distributions, though this hypothesis is not tested with out-of-distribution evaluation.

Critical Assessment

Does the evaluation establish that LRMs suffer a fundamental, universal limitation in multi-horizon reasoning?

The evidence is strong but with important scope limitations. The degradation curves (Figure 3) are remarkably consistent across 25 models and 6 datasets — no model escapes multi-horizon collapse, and the pattern holds across math, code, and agentic tasks. This universality is the paper's strongest empirical contribution. However, the claim is conditioned on the specific type of "multi-horizon" that R-HORIZON constructs: sequentially dependent problems where each downstream problem explicitly requires the previous answer, communicated in a structured prompt format. This is a reasonable operationalization of multi-horizon reasoning, but it is one specific type. Real-world long-horizon reasoning often involves implicit dependencies (where the connection between steps is not spelled out in the prompt), interleaved reasoning (where sub-problems are not cleanly separable), or open-ended chains (where subsequent steps depend on intermediate decisions, not just final numeric answers). The paper's findings may not generalize cleanly to these variants. The R-HORIZON construction deliberately makes dependencies explicit and sequential, which tests the model's ability to follow a prescribed dependency structure but does not test the model's ability to construct its own dependency structure in an unstructured long-horizon scenario.

Additionally, the all-or-nothing metric, while appropriate for the diagnostic purpose, makes the degradation appear maximally severe — a model that gets 9 out of 10 problems correct and fails on the 10th scores identically to a model that fails on the first problem and gives up. This is a valid measure of end-to-end reliability but obscures whether degradation is gradual (models get most but not all problems right at longer horizons) or catastrophic (models fail completely after a certain point). The error type analysis in Figure 5 partially addresses this by showing that Problem Reasoning Errors dominate rather than Early Stop or Dependency Errors, suggesting gradual degradation of individual problem-solving quality rather than catastrophic abandonment. But the all-or-nothing metric's binary nature could be complemented with metrics like "average number of consecutive correct problems before first error" or "per-position accuracy" to provide a more nuanced picture of where in the chain degradation occurs.

Does the effective reasoning length finding demonstrate a genuine attentional/representational bottleneck, or could it be an artifact of the evaluation setup?

The error position analysis (Figure 6) is one of the paper's most striking findings, but it has interpretive ambiguities. The fact that error position stabilizes at a characteristic token count regardless of problem count is consistent with a hard reasoning horizon, but alternative explanations are possible: (1) Positional bias in training data: if the base model was trained predominantly on documents where important information appears in the first 4-8k tokens, the model may learn to discount later-positioned information regardless of its actual content. This would produce the observed pattern without implying a genuine representational limitation. (2) Attention dilution with sequence length: as the context grows, each token's attention weight to any specific earlier token decreases, which would degrade reasoning on all problems proportionally to their position in the sequence. This is a known limitation of transformer architectures that the paper does not disentangle from a reasoning-specific horizon. (3) Structured output format degradation: models may simply get worse at outputting structured answer formats as responses get longer, leading to extraction failures being misclassified as reasoning errors. The 91% consistency rate between model-based and rule-based extraction at n=16 (Table 3) suggests this is a real but modest effect — the other 9% represents cases where extraction ambiguity could inflate error rates, but the gap between actual (near 0%) and theoretical (20-30%) accuracy at n=16 is far larger than extraction noise alone could explain.

The claim would be strengthened by control experiments that vary the position of dependency specifications within the prompt (e.g., putting Problem 1 at the end rather than the beginning) to test whether degradation is truly about reasoning horizon or about attention to later-positioned information. The difficulty ordering ablation (Appendix D.3) is a partial control — it varies which problem comes first but finds that allocation patterns are positional rather than difficulty-driven — but it does not directly test whether the horizon effect is about reasoning quality vs. attention decay.

Does the training with R-HORIZON composed data genuinely improve multi-horizon reasoning capabilities, or does it simply teach the model to handle the specific prompt format and dependency structure?

The +17.4 improvement on AIME24 n=2 (Figure 4, Table 1) is substantial and establishes that composed-data training produces better performance on composed evaluation prompts. But the critical question for generalization is: does this represent a genuine improvement in multi-horizon reasoning, or adaptation to the specific R-HORIZON prompt format? Several pieces of evidence support the "genuine improvement" interpretation: (1) the improvement transfers to single-problem benchmarks (+7.5 on AIME2024), which cannot be explained by format adaptation because single-problem prompts do not use the composed format; (2) training with longer composed chains (n=4) improves performance on even longer evaluation chains (MATH500 n=8: 50.6 for n=4 training vs. 21.4 for n=2 training), suggesting the model is learning a generalizable horizon-management skill rather than memorizing specific chain lengths; (3) the response length and budget allocation analyses (Figure 9) show that composed-data-trained models generate shorter, more evenly distributed responses — behavioral changes that are consistent with learning efficient allocation rather than format-specific heuristics.

However, important gaps remain. The paper does not evaluate whether composed-data-trained models maintain their improvements on out-of-distribution multi-horizon tasks — all evaluation uses the same R-HORIZON construction methodology as training. A convincing demonstration of genuine multi-horizon capability improvement would require evaluation on a different multi-step reasoning benchmark (e.g., multi-hop QA, long-horizon planning tasks, or real-world sequential decision-making scenarios) where the dependency structure differs from the training format. Without such evaluation, the possibility that the model has simply learned to better handle R-HORIZON's specific dependency specification syntax cannot be ruled out. The single-problem improvement provides some cross-task transfer evidence but does not address whether the multi-horizon skill itself transfers.

Does the thinking budget allocation analysis explain the performance degradation, or is it merely a correlate?

The paper presents budget allocation myopia (Figure 8) alongside the performance degradation but does not establish the causal direction. Three causal models are consistent with the data: (1) allocation → degradation: models over-invest in early problems, starving later problems of tokens, causing them to fail; (2) degradation → allocation: models recognize (implicitly) that their reasoning quality degrades later in the sequence, so they rationally invest tokens where they are most effective (early problems); (3) common cause: both phenomena arise from a shared underlying factor (e.g., positional attention decay) that simultaneously degrades reasoning quality at later positions and biases token allocation toward earlier positions. The paper's language sometimes implies model (1) — "LRMs have not yet developed the capability to allocate thinking budgets" — but the data do not distinguish between these models. If model (2) is correct, then forcing more balanced allocation (e.g., by truncating early-problem responses or introducing per-problem token budgets) would not improve overall accuracy because the later-problem tokens would be spent on degraded reasoning anyway. The paper does not conduct such intervention experiments, making the causal interpretation ambiguous.

The single-problem performance improvement from composed training is an important and non-obvious result, but its robustness is under-explored.

The +7.5 on AIME2024 (Figure 4) is reported from a single training run at step 600 — no error bars, no multiple seeds, no statistical testing. Given the known high variance in RL training (different random seeds can produce substantially different final performance), a single-run result should be interpreted as suggestive rather than definitive. The paper also does not investigate whether the +7.5 gain holds across different base models (only R1-Qwen-7B is used for RL experiments) or different training datasets (only the Skywork-OR1-RL math subset is used). If the finding generalizes across models and datasets, it would represent a significant training methodology insight — that multi-problem training is strictly better than single-problem training, even for single-problem evaluation. If it does not generalize, the finding would be a specific interaction between R1-Qwen-7B's training dynamics and the Skywork-OR1-RL data distribution. The paper's conceptual framing (multi-horizon training teaches budget allocation that transfers to single problems) is plausible but not rigorously tested — an experiment that explicitly measures thinking budget allocation on single-problem prompts and correlates it with accuracy improvement would strengthen the causal claim.

Missing experiments and baselines that would strengthen the paper.

  • Comparison of RL on composed data vs. RL on single data + length penalty: The paper argues that composed-problem training improves allocation and reduces overthinking. A simpler intervention would be to add a length penalty to single-problem RL training (as done by Aggarwal & Welleck, 2025, which the paper cites). If length-penalized single-problem training achieves similar single-problem improvements to composed-problem training, the "budget allocation" interpretation would be challenged — the benefit might come from efficiency alone rather than multi-horizon skill. This comparison is not made.

  • Direct evaluation of dependency error propagation: The error type analysis (Figure 5) tracks Dependency Reasoning Errors as a distinct category, but the paper does not perform the most diagnostic analysis: for each incorrect final answer in a composed chain, trace backward to identify whether the root cause was an error in Problem 1 (which then propagated) or an independent error in a later problem. This would directly quantify how much of the degradation is due to error propagation vs. independent failure at each step, which has different implications for what interventions (better verification vs. better allocation) would help.

  • Scaling the number of composed training problems beyond n=4: The RL experiments use up to n=4 composed training. Does training with even longer chains (n=8, n=16) continue to yield improvements, plateau, or cause training instability? The entropy analysis in Appendix C suggests faster entropy collapse with longer composed chains, which could limit the maximum effective training horizon. This practical ceiling is not explored.

  • Evaluation on a non-composed multi-step reasoning benchmark: The paper would be more convincing if it showed that composed-problem training improves performance on existing multi-step reasoning benchmarks (e.g., multi-hop QA like HotpotQA, long-horizon planning in ALFWorld, or multi-turn tool-use benchmarks) that were not constructed via R-HORIZON's composition methodology. This would establish that the trained skill is genuinely multi-horizon reasoning rather than R-HORIZON-specific format handling.

The anomalous "correct final answer despite upstream errors" phenomenon is flagged but not adequately investigated.

Appendix D.2 (Figure 13) documents a surprising and potentially important finding: models sometimes answer the final problem correctly even when earlier answers are wrong in sequentially dependent chains. At n=16, there are ~150-200 such anomaly samples for the 7B model. The paper hypothesizes data contamination — the model recognizes the final problem independent of the dependency variables — but this hypothesis is not tested (e.g., by checking whether anomaly rates correlate with problem frequency in training data, or by ablating the dependency specification to see if models still answer correctly). If correct, this would be a significant finding about contamination effects in LRM evaluation that extends beyond R-HORIZON. If incorrect, it suggests that the dependency chains are not as strictly enforced as intended, which would partially undermine the all-or-nothing metric's interpretation. This deserves more thorough investigation than the paper provides.

6. Limitations and Trade-offs

Limitation 1: The Dependency Chain Construction Creates an Unrealistically Brittle Reasoning Structure

R-HORIZON composes math problems by injecting dependency functions of the form $f_i(x) = x + (m_{i+1} - a_i)$, where the placeholder variable $v_{i+1} = f_i(a_i)$ must be computed from the previous problem's answer before the next problem becomes solvable (Algorithm 1, Section 3.1). The all-or-nothing evaluation metric (Equation 3) then demands perfect correctness across the entire chain. This construction deliberately creates a maximally brittle dependency structure: a single arithmetic error in the dependency computation, or a single upstream wrong answer, propagates forward and renders all downstream problems unsolvable as written — the dependency variable takes an incorrect value, so even a model maintaining perfect reasoning quality on later sub-problems will produce wrong answers because it is solving a different problem than the evaluator expects.

The consequence is that R-HORIZON's evaluation confounds two distinct failure modes that have different practical implications. The first is reasoning quality degradation across the horizon — the model's problem-solving ability genuinely declines as more problems accumulate. The second is arithmetic error propagation — the model solves later problems correctly given its (wrong) intermediate values, but gets marked incorrect because the evaluator compares against answers computed with different inputs. A model that solves Problems 2-5 perfectly given the (wrong) answer it obtained for Problem 1 fails the all-or-nothing metric entirely, but this failure mode is fundamentally different from a model whose reasoning collapses after Problem 1. The error type analysis (Figure 5) attempts to separate these by tracking Dependency Reasoning Errors (errors in computing the dependency function itself) as a distinct category, but this only captures cases where the dependency computation fails given correct upstream answers. It does not capture the far more common case where the model correctly computes the dependency from its own (wrong) previous answer, solves the downstream problem correctly under that assumption, and is marked wrong because the ground-truth answer assumes the correct upstream value. The paper's own anomaly analysis (Appendix D.2) provides indirect evidence of this confound: at $n=16$ on MATH500, there are ~150-200 cases where the final answer is correct despite upstream errors (Figure 13, right), suggesting that some "wrong" answers in the all-or-nothing score actually represent correct downstream reasoning from wrong upstream inputs.

The dependency function design choice — making the downstream problem literally unsolvable without the upstream answer — is justified by the paper as creating "dependencies that enforce sequential solving" (Section 3.1). But this enforcement comes at a cost: it makes the evaluation measure something closer to "probability of zero arithmetic errors across an extended chain" rather than "ability to sustain reasoning quality across an extended chain." In real-world sequential reasoning, intermediate results are often approximate, revisable, or verifiable through consistency checks — the brittleness of mathematical dependency chains does not reflect the error-tolerance of most practical long-horizon scenarios. The paper does not acknowledge this as a limitation. No mitigation is proposed (e.g., partial-credit scoring, evaluation of downstream reasoning quality conditional on the model's own upstream answers, or comparison against a "correct downstream reasoning from any input" metric). The paper's recommendation to use R-HORIZON for training and evaluation implicitly assumes that learning to avoid any arithmetic error in a brittle chain transfers to real long-horizon reasoning, but this assumption is untested.

Limitation 2: The Effective Reasoning Length Finding Cannot Distinguish Positional Attention Decay from Genuine Reasoning Capacity Limits

The error position analysis (Figure 6) is presented as evidence that LRMs have a model-specific effective reasoning length — 4-6k tokens for 7B models, 8-10k for 32B models — beyond which reasoning quality collapses regardless of problem count. The paper interprets this as a reasoning capacity limitation: the model cannot sustain coherent multi-step thinking past a characteristic token horizon. However, an alternative explanation that the paper does not rule out is that the degradation reflects positional attention decay in the transformer architecture — as the sequence grows, each token's attention weight to earlier tokens becomes increasingly diluted, making it harder to reference and manipulate information from earlier in the response regardless of the reasoning demands. Under this explanation, the same model might maintain reasoning quality far beyond 10k tokens if the information it needs to reason about were positioned differently (e.g., distributed across the sequence rather than concentrated at the beginning), or if the architecture were modified to improve long-range attention.

The consequence of this ambiguity is that the paper's central diagnostic — "LRMs have a sharp effective reasoning horizon" — may point toward the wrong intervention. If the bottleneck is attentional, the solution is architectural (better positional encodings, memory mechanisms, retrieval-augmented context management). If the bottleneck is genuinely about reasoning capability, the solution is training (composed-problem data, reflection incentives, horizon management skills). The paper's training results (Sections 4.3, 5.2) provide some evidence that training interventions help, which would be less expected if the limitation were purely attentional and architectural. But the paper does not conduct the cleanest control experiment: testing whether error position depends on the position of critical information in the prompt (e.g., putting the dependency specification for earlier problems at the end of the prompt rather than at the beginning). If degradation were purely attentional, moving critical information to later positions should shift the error position later; if it is about reasoning endurance, the error position should remain stable regardless of information placement. The difficulty ordering ablation (Appendix D.3, Figure 14) provides a partial test — it varies whether hard or easy problems come first — but it examines token allocation rather than error position, and finds that allocation is positional (first problem gets most tokens regardless of difficulty) rather than difficulty-responsive. This is consistent with both the attentional and reasoning-endurance interpretations.

The paper does not acknowledge this interpretive ambiguity. The discussion of effective reasoning length (Section 5.1) treats the error position finding as direct evidence of a reasoning horizon, without considering alternative explanations rooted in known transformer limitations. No mitigation is proposed, and no future work is suggested to disentangle these mechanisms. This is a consequential gap because the field's response to the finding — whether to invest in better architectures or better training data — depends on which interpretation is correct.

Limitation 3: The Difficulty Estimation Bottleneck Is Amplified for Multi-Horizon Tasks But Is Neither Measured Nor Mitigated

R-HORIZON training (Section 3.3, 4.3) constructs composed training instances by pairing problems such that $\text{Acc}_{expected} > 0.25$ — the product of individual pass rates exceeds 25%. This requires knowing the pass rate of each seed problem, which in turn requires evaluating the base model on every candidate problem individually before composition. While the paper does not report the computational cost of this pass-rate estimation step, the scale is substantial: the Skywork-OR1-RL dataset contains 48,371 original problems, and computing pass rates with any reasonable statistical precision (e.g., the benchmark evaluation uses $Avg@32$ or $Avg@8$ for individual datasets) would require generating hundreds of thousands of model responses purely for data preparation — before any training begins.

The consequence is that the reported training efficiency and accuracy improvements (the +17.4 on AIME24 n=2, +7.5 on AIME2024; Figure 4, Table 1) exclude the compute cost of determining which problems to compose and at what difficulty level. In a practical deployment, the total cost of adopting R-HORIZON training includes: (1) generating responses to estimate per-problem pass rates across the training set, (2) running the filtering and key-variable identification pipeline (Equations 1-2), (3) executing Algorithm 1 to construct composed instances, and (4) the actual RL training on composed data. The paper reports only the training cost (step 4), leaving the data preparation cost unquantified. For a static training dataset used once, this overhead might be acceptable if amortized over many training runs. But the paper's vision (Section 6) positions R-HORIZON as a "scalable, controllable, and low-cost paradigm" — and for this claim to hold for iterative training pipelines (where models are repeatedly fine-tuned on updated data), the pass-rate estimation would need to be rerun each time the model changes, because a model with different capabilities would have different per-problem pass rates, requiring different composition decisions. This costs scales linearly with dataset size and quadratically with the number of training iterations, potentially dominating the RL training cost itself.

The difficulty-ordering ablation (Appendix D.3) used the pass rate of R1-Qwen-7B as the difficulty reference, requiring evaluation of a specific model on the entire dataset. For the main RL experiments, the paper uses Skywork-OR1-RL data filtered through R-HORIZON, requiring the same estimation on the base model R1-Qwen-7B. The paper does not report how many inference calls this required, what precision was used for pass-rate estimation, or whether the cost was included in any budget calculation. The paper does not acknowledge this as a significant practical limitation. No mitigation is proposed (e.g., using the PRM or ORM from the base model to estimate pass rates without full generation, or developing lightweight difficulty estimators as suggested in the related effective-reasoning-length literature the paper cites in Section 2.2). The "low-cost" claim in the abstract is therefore unvalidated — the method may be low-cost in terms of additional training FLOPs per composed instance, but the data preparation overhead is unmeasured and potentially substantial.

Limitation 4: All Evaluation Uses the R-HORIZON Construction Methodology; Generalization to Other Forms of Long-Horizon Reasoning Is Untested

The paper evaluates multi-horizon reasoning exclusively on R-HORIZON-constructed benchmarks (Section 4.2) and trains exclusively on R-HORIZON-constructed data (Section 4.3). The composed prompts follow a specific format: sequentially ordered problems with inline dependency specifications, explicit notation for placeholder variables and dependency functions, and a structured output format requirement (Figure 15). This format is highly distinctive — models never encounter this exact prompt structure in standard pretraining or fine-tuning data. This creates a fundamental ambiguity in interpreting both the evaluation and training results: are the documented failures symptoms of general multi-horizon reasoning limitations, or symptoms of the specific R-HORIZON prompt format?

The consequence is that the paper cannot distinguish between several competing explanations for the observed degradation: (1) models cannot sustain reasoning across multiple problems regardless of how those problems are presented; (2) models are confused by the unusual R-HORIZON format and would perform better on multi-problem tasks presented in a more natural format; (3) models have not been trained to follow the specific output conventions R-HORIZON requires and lose points due to format violations rather than reasoning errors. The paper's answer extraction analysis (Table 3) shows that format compliance degrades with horizon length (91% consistency between model-based and rule-based extraction at $n=16$), providing some evidence for explanation (3). The REST comparison (Appendix D.1) shows that dependent concatenation is harder than independent concatenation, providing evidence that dependency imposes a real burden beyond format, but both conditions use the R-HORIZON format — there is no comparison against a "natural" multi-problem format (e.g., a narrative scenario where sub-problems are embedded in a story, or a dialogue where problems arise sequentially from user turns). The code task results (Figure 3, LiveCodeBench) use a different format (direct concatenation without dependencies; Appendix A), and the degradation there is also severe — but this format is still constructed by R-HORIZON's concatenation approach, not drawn from a naturally multi-file or multi-function code task.

For the training results, the same ambiguity applies in the opposite direction: composed-problem training may teach the model to handle the R-HORIZON format specifically, rather than teaching generalizable multi-horizon reasoning skills. The single-problem improvement (+7.5 on AIME2024) provides some evidence against pure format-fitting — single-problem AIME prompts do not use the R-HORIZON format — but this improvement could arise from efficiency gains (less overthinking) that are orthogonal to multi-horizon capability. For the multi-horizon improvements to be convincing as evidence of generalized reasoning horizon management, the paper would need to evaluate composed-problem-trained models on a multi-step reasoning benchmark that was not constructed via R-HORIZON — for example, multi-hop question answering (HotpotQA), long-horizon planning tasks, or multi-turn dialogue with state tracking. The paper acknowledges the scope limitation implicitly by noting that evaluation covers "mathematical reasoning, code generation, and agentic tasks" but does not position the R-HORIZON format as a limitation or propose validation on naturally multi-step benchmarks. This is a significant gap because the paper's central recommendation — use R-HORIZON to train and evaluate long-horizon reasoning — would be substantially weakened if R-HORIZON's format is a significant contributor to the observed effects.

Limitation 5: The RL Training Results Come from a Single Training Run on a Single Base Model with No Statistical Replication

All RL training experiments (Section 4.3, Table 1, Figure 4, Figure 9, Appendix B, Appendix C) use R1-Qwen-7B as the base model, trained on the math subset of Skywork-OR1-RL data, with results reported from single training runs at specific step counts. Reinforcement learning for language models is known to exhibit substantial variance across random seeds — different initializations, different data orderings, and different sampling during on-policy data collection can produce meaningfully different final performance. The paper's headline finding — that composed-problem training improves single-problem AIME accuracy by +7.5 percentage points (Figure 4) — is based on comparing two single training curves (single-problem data vs. composed-problem data), each run once. Without error bars, multiple seeds, or statistical testing, it is impossible to determine whether the +7.5 difference is a reliable effect or within the range of seed-dependent variance that RL training typically exhibits.

The consequence is that the paper's most actionable recommendation — "replace some fraction of single-problem training data with composed-problem data to improve both multi-horizon and single-horizon performance" — rests on evidence that would not meet the replication standards of most empirical ML venues. A practitioner who attempts to replicate this finding with a different base model, different training data, or different hyperparameters cannot know whether a failure to reproduce the +7.5 gain reflects a genuine interaction effect or is within the expected variance of the method. The paper's additional experiments varying composed query counts and reward schemes (Table 1) provide multiple data points, but each configuration is a single training run, so the variance within any configuration is unknown. The comparison across configurations (e.g., $n=2$ vs. $n=4$ vs. mixed) is therefore confounded with seed variance — we cannot tell whether $n=4$ genuinely outperforms $n=2$ on MATH500 n=8 (50.6 vs. 21.4) or whether a different random seed for the $n=2$ run would close the gap.

The paper does not acknowledge the single-run limitation. The training dynamics analysis (Appendix C, Figure 11) reports response length, time per step, and entropy loss for different training configurations, all from single runs. The standard practice in empirical RL research — reporting mean and standard deviation across 3-5 independent seeds — is not followed. No mitigation is proposed or discussed. The paper's contribution would be substantially strengthened by even a minimal replication (e.g., 3 seeds for the key comparison between single-data and composed-data training) to establish that the observed effects exceed training variance.

Limitation 6: The Anomalous "Correct Despite Upstream Errors" Phenomenon Signals a Potential Validity Issue in the Dependency Construction That Is Not Adequately Investigated

Appendix D.2 (Figure 13) documents a finding that should be deeply concerning for the paper's core methodology: in sequentially dependent chains where Problem 2 literally cannot be solved without Problem 1's correct answer (because Problem 1's answer determines a key variable in Problem 2's statement), models sometimes answer Problem 2 correctly despite getting Problem 1 wrong. At $n=16$ on MATH500, the R1-Qwen-7B model produces roughly 150-200 such anomalous cases out of 500 evaluation instances. This should be mathematically impossible under the dependency construction — if $v_2 = f_1(a_1) = a_1 + (m_2 - a_1) = m_2$ only when $a_1$ is correct, then getting $a_1$ wrong means the model is solving a different problem for Problem 2 (one with an incorrect value of $v_2$), and should not coincidentally arrive at the original $a_2$.

The consequence is that the dependency chains may not be as strictly enforced as intended or that models find alternative solution paths that bypass the dependency. Several mechanisms could explain this: (1) Data contamination: the model has memorized Problem 2's answer from training data and can recognize the problem independent of the dependency variable — it ignores the incorrect $v_2$ value and solves the problem as originally memorized. If this explanation is correct, it means the R-HORIZON evaluation is partially measuring contamination resistance rather than multi-horizon reasoning, and models with higher contamination would show spuriously better composed-problem performance. (2) Dependency function reversibility: the dependency specification $v_2 = f_1(a_1)$ is included in the prompt in a form that allows the model to reverse-engineer the original problem — for instance, if the prompt says "Using the result 5 from the previous calculation, $v_3 = 5 - 200$," and the model incorrectly got 5 for Problem 2 but solves Problem 3 by noticing that the dependency computes to -195 and then recognizing Problem 3 as a known problem independent of the dependency path. (3) Numerical coincidence: for some problem pairs and some error values, the wrong answer to Problem 1 produces a dependency variable that, by chance, yields a problem that the model solves to the same final answer as Problem 2's ground truth — this would be rare but not impossible.

If explanation (1) is correct, the R-HORIZON evaluation is partially compromised as a pure measure of multi-horizon reasoning — contamination effects inflate the apparent multi-horizon performance of models that have seen the constituent problems during training, and the gap between actual and theoretical accuracy underestimates the true multi-horizon penalty for contamination-free models. If explanation (2) is correct, the dependency chains are weaker than intended — the model can skip solving Problem 1 by reverse-engineering the dependency to recover Problem 2's original form, making the "sequential dependency" partially optional. The paper hypothesizes data contamination (Section D.2: "We hypothesize that this phenomenon is related to data contamination in models") but conducts no tests to verify this hypothesis — it does not check whether anomaly rates correlate with problem frequency in training corpora, whether models with known contamination patterns (e.g., models trained on MATH-derived data) show higher anomaly rates than models trained on disjoint data, or whether removing the dependency specification from the prompt eliminates the anomaly. The paper also does not investigate whether the anomaly rate explains any of the variation in multi-horizon performance across models — do models with higher anomaly rates show higher (spuriously inflated) composed accuracies?

The paper does not acknowledge this as a fundamental validity concern for the R-HORIZON methodology. It is treated as an interesting anomaly rather than a potential confound that could systematically bias the evaluation. The $R_{last}$ vs. $R_{all}$ comparison (Table 1) is partly designed to study whether permissive rewards (rewarding only final answer correctness) produce different behaviors than strict rewards, but the anomaly finding suggests that even the $R_{all}$ evaluation metric (requiring all answers correct) may be counting some cases as "correct" where the model did not actually solve the composed chain as intended. This limitation is acknowledged only in passing and no mitigation is proposed — the paper does not, for example, filter out anomalous cases from evaluation, design dependency functions that prevent reverse-engineering, or conduct decontamination analysis of the training data.

7. Implications and Future Directions

How This Work Changes the Landscape

R-HORIZON does not propose a new architecture, a new training algorithm, or even a new dataset in the conventional sense. What it proposes — and what makes it a genuine conceptual contribution rather than an incremental benchmark paper — is a reframing of what "reasoning capability" means for Large Reasoning Models. The field has spent the past two years optimizing for depth: how many tokens should a model spend on a single AIME problem? What search strategy maximizes single-question accuracy? The implicit assumption, baked into every test-time scaling paper and every RLVR training run, has been that reasoning is a problem-local property — if a model achieves 90% on AIME, it "reasons well." R-HORIZON demonstrates that this assumption is catastrophically wrong. The same model that achieves near-saturation on individual problems collapses to near-zero when those same problems are linked into a chain, because reasoning is not just depth — it is also breadth: the ability to sustain coherent, error-free inference across an extended horizon of interdependent sub-tasks.

This reframing matters because it changes what the field optimizes for. If R-HORIZON's diagnosis is correct — that the effective reasoning length of LRMs is sharply bounded, that thinking budget allocation is myopic, and that reflection remains stubbornly local to individual sub-problems — then the current trajectory of "scale up test-time compute, train on harder single problems, and expect general reasoning to emerge" is fundamentally incomplete. A model that can think for 20,000 tokens on one hard problem has demonstrated depth. A model that can think for 20,000 tokens across ten interdependent problems — allocating attention, verifying dependency propagation, and maintaining accuracy throughout — has demonstrated something qualitatively different. The paper's core contribution is to establish that these are distinguishable capabilities and that models trained only on single-horizon tasks do not acquire the second one by default. This is not a claim that depth and breadth are in trade-off — the finding that composed-problem training improves single-problem performance (+7.5 on AIME2024, Figure 4) suggests they can be complementary. Rather, it is a claim that breadth requires explicit training signal — the training distribution must include multi-horizon tasks for the model to learn multi-horizon skills. This is a direct challenge to the prevailing "more data, harder problems" approach to reasoning model development.

The diagnostic contribution is arguably more important than the training contribution. The effective reasoning length analysis (Figure 6) — showing that error positions stabilize at characteristic token counts (4-6k for 7B models, 8-10k for 32B) regardless of how many problems are in the chain — provides the first clear evidence that LRM reasoning quality is not a smooth function of context position. There appears to be a hard attentional or representational horizon beyond which the model's reasoning degrades to chance-level accuracy, and this horizon scales with model size. This finding, if it replicates across architectures and training recipes, has implications that extend far beyond mathematical reasoning benchmarks. It suggests that any application requiring sustained reasoning across long contexts — multi-turn dialogue with state tracking, long-document summarization with cross-referencing, multi-file software engineering, multi-step scientific inference — is operating in a regime where current LRMs are fundamentally unreliable, regardless of their single-problem benchmark scores. The R-HORIZON methodology provides a clean experimental paradigm for measuring this horizon, and the paper demonstrates that the measurement is consistent across 25 models and 6 task types. This is a contribution to the science of reasoning evaluation that can be adopted and extended by subsequent work without necessarily adopting the R-HORIZON training methodology.

The paper also reconciles several apparently contradictory threads in the recent literature. The overthinking phenomenon (Chen et al., 2025) showed that LRMs waste tokens on simple problems with minimal accuracy gain. Length-control methods (Aggarwal & Welleck, 2025) showed that training models to think efficiently preserves or improves accuracy. The effective-reasoning-length literature (Wu et al., 2025b; Ghosal et al., 2025) showed that CoT performance degrades beyond an optimal length. R-HORIZON unifies these observations under a single mechanism: thinking budget myopia. The model's token allocation is driven by positional habits formed during single-problem training — lavish attention on early content, expend whatever tokens seem necessary, and assume no downstream cost. On a single problem, this produces overthinking (wasted tokens after the problem is essentially solved). On a composed chain, it produces catastrophic under-allocation to later problems. The same underlying behavior produces both the efficiency problem and the horizon problem. Composed-problem training partially addresses both: it reduces overthinking on single problems (Figure 9b shows shorter responses) and improves allocation on multi-problem chains (Figure 9d shows more balanced per-problem budgets). This unification is intellectually satisfying because it explains multiple phenomena with a single mechanism rather than treating them as independent problems requiring independent solutions.

For research prioritization, R-HORIZON's findings redirect attention in two ways. First, they make training data structure a first-class design consideration alongside training data difficulty and quantity. The dominant narrative in reasoning model development has been that what matters is how hard the problems are — AIME-hard is better than MATH-hard, and IMO-hard is better than AIME-hard. R-HORIZON suggests that this misses a dimension: how problems are arranged matters independently of how hard they are individually. A training set of 10,000 single AIME problems teaches something different from a training set of 2,500 chains of 4 AIME problems, even though the underlying math content is identical. Second, they make reflection scope — whether the model checks its work across problem boundaries or only within them — a measurable and trainable skill rather than an emergent property of scale. The finding that more than half of sub-problems in long chains lack any cross-problem reflection (Figure 7), and that composed-problem training increases long-range reflection (Figure 9c), suggests that reflection scope is not simply a function of model capability — it is a behavior that must be incentivized through the training distribution.

Follow-Up Research This Work Enables

Disentangling positional attention decay from genuine reasoning horizon collapse. The paper's most striking finding — that error positions stabilize at characteristic token counts (Figure 6) — admits two interpretations with different implications. If the degradation is caused by attention dilution in the transformer architecture (later tokens attend less precisely to earlier information, independent of reasoning demands), the solution is architectural: better positional encodings, retrieval-augmented generation for long contexts, or segment-level recurrence. If the degradation is caused by a genuine reasoning endurance limit (the model cannot sustain coherent multi-step inference beyond a certain number of reasoning operations regardless of how information is positioned), the solution is training: composed-problem data, horizon-management incentives, and reflection training. A clean experiment to distinguish these would place the same critical dependency information at different positions in the prompt — for instance, put Problem 1 (and its dependency specification for Problem 2) at the very end of a long preamble of filler text, so that the model must reason about Problem 1 at token position 15,000 rather than token position 200. If error position shifts with information position, the bottleneck is attentional. If error position remains at 4-6k tokens regardless of where the key information is, the bottleneck is reasoning endurance. This experiment would directly determine whether the field should be investing in better architectures or better training data to address multi-horizon degradation.

Evaluation of R-HORIZON-trained models on naturally multi-step reasoning benchmarks. The paper's training results demonstrate that composed-problem RL improves R-HORIZON-format evaluation performance, but the critical open question is whether this improvement transfers to multi-step reasoning tasks that were not constructed via R-HORIZON's composition methodology. A strong follow-up would train models using R-HORIZON's composed data pipeline (replicating the n=4 R_last condition from Table 1) and evaluate on: (1) multi-hop question answering benchmarks (HotpotQA, 2WikiMultihopQA) where questions require chaining multiple facts across documents, (2) long-horizon planning tasks (ALFWorld, WebArena) where actions depend on previous observations, and (3) multi-turn code generation tasks where each turn builds on the previous solution. If composed-training improvements are specific to R-HORIZON's integer-dependency-chain format, no transfer would be observed, and the findings would be substantially narrower in practical import. If transfer occurs, it would establish that composed-problem training teaches a generalizable horizon-management skill that applies across task modalities and dependency structures.

Measuring and training for cross-problem reflection as a distinct skill. The reflection analysis (Figure 7) reveals that models' self-verification is overwhelmingly localized to the current sub-problem — they check arithmetic within Problem 3 but rarely verify whether the dependency variable from Problem 2 was correctly computed. The paper's R_all reward (rewarding only if all sub-problems are correct; Table 1) is a blunt instrument for incentivizing cross-problem reflection — it rewards the outcome of correct dependency propagation but does not directly reward the behavior of checking propagation steps. A more targeted intervention would introduce an auxiliary reflection reward: during RL training, identify spans in the model's CoT where it explicitly re-examines a previous problem's answer or recomputes a dependency variable, and provide a small bonus reward for these reflection behaviors regardless of final answer correctness. This would allow studying whether reflection scope is trainable independently of general reasoning capability, whether incentivizing cross-problem reflection improves multi-horizon accuracy beyond what end-to-end answer rewards alone achieve, and at what rate cross-problem reflection generalizes to unseen chain lengths. The analysis could use the paper's existing Long Reflection Rate metric (Figure 7) as the primary diagnostic.

Scaling composed-problem training to longer horizons and larger models. The paper's RL experiments use a maximum of n=4 composed training problems on a 7B model. Several scaling dimensions remain unexplored: (1) Training horizon saturation: does training with n=8 or n=16 composed problems continue to yield improvements on long-horizon evaluation, or does the training signal become too sparse (the probability of getting all 16 problems correct by chance, even with high single-problem pass rates, becomes vanishingly small)? Appendix C (Figure 11) shows that entropy loss decreases faster with n=4 training than n=2, suggesting that longer composed chains may cause premature policy convergence — a systematic sweep of training horizons with entropy and exploration metrics would establish the practical ceiling. (2) Model scale interaction: the evaluation results show that larger models exhibit less degradation (32B drops less than 7B) and have longer effective reasoning horizons. Does composed-problem training on a 32B or 70B model produce proportionally larger improvements than on a 7B model, or do the benefits saturate? (3) Mixed-horizon training with adaptive difficulty: the paper's mixed configuration (Table 1) includes varying composed query counts but keeps difficulty filtering static (Accexpected > 0.25). A more sophisticated approach would dynamically adjust the number of composed problems and the difficulty of constituent sub-problems based on the model's current multi-horizon performance — analogous to curriculum learning but for horizon length rather than problem difficulty. This would determine whether horizon management is best taught through a fixed training distribution or through an adaptive curriculum that stretches the model's effective reasoning length progressively.

Investigating and mitigating the anomalous correct-final-answer phenomenon. The finding that models sometimes answer the final problem correctly despite upstream errors (Appendix D.2, Figure 13) raises a validity concern that extends beyond R-HORIZON to any evaluation of sequential reasoning. A focused investigation would: (1) categorize anomalous cases by hypothesized mechanism — data contamination (model recognizes the final problem from training data and solves it independent of the dependency variable), dependency function reversibility (model reverse-engineers the original problem from the dependency specification), or numerical coincidence (wrong dependency value happens to produce a problem with the same answer); (2) for the contamination hypothesis, cross-reference anomalous problems against known training corpora (Pile, CommonCrawl snapshots, math-specific training sets) to check whether models with higher exposure to specific problems show higher anomaly rates; (3) design dependency functions that are not trivially reversible — for instance, using modular arithmetic, hashing, or multi-step transformations rather than simple additive offsets — and test whether anomaly rates decrease. If contamination is the primary driver, this finding has implications for all multi-step evaluation benchmarks and suggests that dependency chains must be constructed with decontamination as a design constraint. If reversibility is the driver, it suggests that the current dependency construction does not enforce sequential solving as strictly as intended, and stronger dependency functions are needed.

R-HORIZON as infrastructure for studying the scaling laws of reasoning horizon. The paper's effective reasoning length analysis (Figure 6) provides a static measurement: for a given model at a given size, error positions stabilize at a characteristic token count. But this is a single snapshot. A scaling law study would systematically vary model size (1.5B, 7B, 32B, 70B, 235B) within a single model family (e.g., the Qwen series, which spans this range) and measure effective reasoning length on R-HORIZON benchmarks at each size, fitting a power law relating parameter count to sustainable reasoning horizon. Additionally, one could measure how training compute (FLOPs) spent on composed-problem data vs. single-problem data affects the effective horizon at each model size, establishing whether horizon is primarily a function of model scale (architecture-determined) or training data (learnable). This would provide the first systematic characterization of the scaling properties of multi-step reasoning, analogous to how the Chinchilla scaling laws characterized the relationship between model size, data quantity, and single-problem loss. Such a study would directly inform practical decisions about how to allocate a fixed compute budget between larger models (with longer base horizons) and composed-problem training (extending the horizon of smaller models).

Practical Applications and Downstream Use Cases

Training data augmentation for reasoning model RL pipelines. The most immediate practical application of R-HORIZON is as a drop-in data preprocessing step in existing RLVR training pipelines. The paper demonstrates (Table 1, Figure 4) that replacing a fraction of single-problem training instances with composed-problem instances — constructed automatically from the same underlying dataset using Algorithm 1 — yields improvements on both composed-problem evaluation (+17.4 on AIME24 n=2) and single-problem evaluation (+7.5 on AIME2024). The data construction is automated (requiring only integer-extraction, key-variable identification via LLM verification, and dependency function computation), and the training pipeline is unchanged (same GRPO algorithm, same hyperparameters, same reward structure). For any team currently training reasoning models via RLVR on math datasets, adopting R-HORIZON composition for a subset of training data requires no infrastructure changes beyond the preprocessing step. The paper's finding that n=4 composed training improves MATH500 n=8 performance from 8.4 to 50.6 (Table 1) suggests that the composition approach is particularly effective when the training horizon exceeds the evaluation horizon, providing a practical recipe: compose training instances at a length slightly beyond the target evaluation horizon. The main practical barrier is the pass-rate estimation cost discussed in Limitation 3 of Section 6 — teams adopting this approach would need to budget inference compute for per-problem pass-rate estimation before training begins.

Multi-step evaluation as a quality gate for LRM deployment. Organizations deploying LRMs for applications involving sequential reasoning — customer support triage requiring multi-step information gathering, automated code review spanning multiple files, research assistance requiring chained fact-checking — can use R-HORIZON-constructed benchmarks as deployment-readiness tests. The paper's finding that even top models like DeepSeek-R1 drop from 87.3% to 24.6% on AIME25 when moving from n=1 to n=5 (Figure 3) means that a model with impressive single-problem benchmark scores may be dangerously unreliable for multi-step tasks. A deployment pipeline could construct a R-HORIZON benchmark from in-domain task data using the composition methodology: identify sequential dependencies between real user queries or operational steps, construct composed evaluation prompts using the dependency function approach, and set a minimum all-or-nothing accuracy threshold below which the model is not deployed for multi-step tasks. The evaluation methodology is model-agnostic and task-agnostic (the paper demonstrates it on math, code, and web search tasks), so it can be adapted to any domain where tasks have identifiable sequential dependencies and verifiable intermediate answers. The key practical consideration is that the composition pipeline requires tasks with clean, extractable intermediate answers — domains with ambiguous or subjective intermediate steps would require adaptation.

Curriculum design for reasoning model training. R-HORIZON provides a principled mechanism for constructing progressive training curricula based on reasoning horizon rather than problem difficulty alone. A training curriculum could start with single-problem instances (n=1), move to 2-problem composed chains once single-problem performance exceeds a threshold, then to 4-problem chains, and so on — with the horizon increasing as the model's effective reasoning length (measurable via the error position analysis in Figure 6) extends. This is distinct from standard difficulty-based curricula (where harder individual problems are introduced over time) because it targets a different capability: horizon management rather than problem-solving depth. The paper's Appendix B (Figure 10) shows that naively increasing context length during standard RL training (from 8k to 16k to 32k) does not substantially improve composed-problem performance, because the model learns to use the extra budget on individual problems rather than distributing it across the chain. A horizon-based curriculum would address this by explicitly introducing multi-problem structure when the model has the capacity to benefit from it. The training dynamics analysis (Appendix C, Figure 11) provides practical guidance: composed-problem training initially reduces response length (the model learns efficiency), and entropy decreases faster — suggesting that curriculum transitions should be triggered when single-problem accuracy plateaus rather than when response length stabilizes, to avoid premature convergence.

When to Prefer This Method

The paper does not position R-HORIZON against a named alternative multi-horizon reasoning method — there is no established baseline for "how to train or evaluate multi-horizon reasoning" that it directly competes with. The closest comparison is standard RLVR training on single-problem data (the naive baseline in Table 1), which R-HORIZON outperforms on both multi-horizon and single-horizon metrics. The paper also does not articulate a specific tradeoff where R-HORIZON should be preferred over an alternative approach under well-defined conditions, because the space of multi-horizon training methods is essentially empty — R-HORIZON is, by the paper's account, the first systematic framework for both evaluating and training long-horizon reasoning in LRMs. In the absence of an explicit tradeoff articulated by the authors, a forced "prefer A when / prefer B when" matrix would be generic speculation rather than a reflection of the paper's claims. The practical decision facing a practitioner is not "should I use R-HORIZON or Alternative X for multi-horizon training?" — it is "should I augment my existing RLVR pipeline with R-HORIZON composed data, and at what horizon length?" The paper's evidence (Table 1) suggests that augmenting single-problem data with n=2 to n=4 composed data improves both multi-horizon and single-horizon performance regardless of the specific single-problem baseline, with the main practical cost being the pass-rate estimation step during data preparation.