2509.09677

# The Illusion of Diminishing Returns: Measuring Long Horizon Execution in LLMs **Authors**: - Steffen Staab Jonas Geiping (University of Cambridge  Institute for AI, University of Stuttgart) Abstract Does continued scaling of large language models (LLMs) yield diminishing returns? In this work, we show that short-task benchmarks may give an illusion of slowing progress, as even marginal gains in single-step accuracy can compound into exponential improvements in the length of tasks a model can successfully complete. Then, we argue that failures of LLMs when simple tasks are made longer arise from mistakes in execution, rather than an inability to reason. So, we propose isolating execution capability, by explicitly providing the knowledge and plan needed to solve a long-horizon task. First, we find that larger models can correctly execute significantly more turns even when small models have near-perfect single-turn accuracy. We then observe that the per-step accuracy of models degrades as the number of steps increases. This is not just due to long-context limitations—curiously, we observe a self-conditioning effect—models become more likely to make mistakes when the context contains their errors from prior turns. Self-conditioning does not reduce by just scaling the model size. But, we find that thinking mitigates self-conditioning, and also enables execution of much longer tasks in a single turn. We conclude by benchmarking frontier thinking models on the length of tasks they can execute in a single turn. Overall, by focusing on the ability to execute, we hope to reconcile debates on how LLMs can solve complex reasoning problems yet fail at simple tasks when made longer, and highlight the massive benefits of scaling model size and sequential test-time compute for long-horizon tasks. Code ? Dataset 1 Introduction Is continued scaling of compute for Large Language Models (LLMs) economically justified given diminishing marginal gains? This question lies at the heart of the ongoing debate on the viability of continued massive investments in LLMs. While scaling laws show diminishing returns on metrics like test loss, the true economic potential of LLMs might arise from automating long, multi-step tasks (METR, 2025). However, long-horizon tasks have been the Achilles’ heel of Deep Learning. We see recent vision models generating impressive images, yet consistency over long videos remains an unsolved challenge. As the industry races to build agents that tackle entire projects, not just isolated questions, a fundamental question arises: How can we measure the number of steps an LLM can reliably execute? <details> <summary>2509.09677v2/x1.png Details</summary>  ### Visual Description # Technical Document Extraction: Image Analysis ## Section 1: Diminishing Gains On A Single Step Can Lead To Exponential Gains Over Long Horizon ### Left Chart (Step Accuracy vs Model Release Date) - **Title**: Diminishing Gains On A Single Step Can Lead To Exponential Gains Over Long Horizon - **X-Axis**: Model Release Date (2020-01-01, 2020-03-01, 2020-06-01, 2020-09-01, 2020-12-01) - **Y-Axis**: Step Accuracy (0.92–1.00) - **Legend**: Red line (no explicit label) - **Data Points**: - (2020-01-01, 0.92) - (2020-03-01, 0.95) - (2020-06-01, 0.97) - (2020-09-01, 0.98) - (2020-12-01, 0.99) - **Trend**: Step accuracy plateaus after initial rapid improvement. ### Right Chart (Task Length vs Model Release Date) - **X-Axis**: Task Length (0, 10k, 20k, 50k, 100k, 150k, 200k) - **Y-Axis**: Step Accuracy (0.92–1.00) - **Legend**: Blue line (no explicit label) - **Data Points**: - (0, 0.92) - (10k, 0.95) - (20k, 0.97) - (50k, 0.98) - (100k, 0.99) - (150k, 0.995) - (200k, 1.00) - **Trend**: Task length increases exponentially while step accuracy plateaus. --- ## Section 2: Models Self-Condition On Their Errors, Taking Worse Steps ### Line Graph (Step Accuracy vs Task Length) - **Title**: Models Self-Condition On Their Errors, Taking Worse Steps - **X-Axis**: Task Length (0, 10k, 20k, 50k, 100k) - **Y-Axis**: Step Accuracy (0.0–1.0) - **Legend**: - Red line: Observed - Green dashed line: Expected - **Data Points**: - Observed: (0, 0.95), (10k, 0.94), (20k, 0.93), (50k, 0.92), (100k, 0.91) - Expected: (0, 0.95), (10k, 0.94), (20k, 0.93), (50k, 0.92), (100k, 0.91) - **Text Blocks**: - **Example 1**: ``` Expected: 56 + 92 = 148 Observed: 56 + 92 = -36 ``` - **Example 2**: ``` Expected: 56 + 92 = 148 Observed: 56 + 92 = -24 ``` --- ## Section 3: Scaling Model Size Enables Execution of Longer Tasks ### Line Graph (Task Length vs Model Size) - **Title**: Scaling Model Size Enables Execution of Longer Tasks - **X-Axis**: Model Size (Billion Parameters) (1, 3, 5, 10) - **Y-Axis**: Task Length (0–12) - **Legend**: - Blue line: Quen3 - Red line: Gemma3 - **Data Points**: - Quen3: (1, 3), (3, 5), (5, 7), (10, 9) - Gemma3: (1, 2), (3, 4), (5, 6), (10, 8) - **Trend**: Both models show linear scaling, with Quen3 consistently outperforming Gemma3. --- ## Section 4: Thinking Enables Execution of Long Tasks In A Single Turn ### Bar Chart (Task Length by Model) - **Title**: Thinking Enables Execution of Long Tasks In A Single Turn - **X-Axis**: Models (Kim3-K2, DeepSeek-V3, Gemini-2.5-Pro, DeepSeek-R1, Glaive-1, Claude-3-Sonnet, GPT-5) - **Y-Axis**: Task Length (Single Turn) (2^22–2^24) - **Legend**: Colors correspond to models (no explicit labels) - **Data Points**: - Kim3-K2: 2^22 - DeepSeek-V3: 2^23 - Gemini-2.5-Pro: 2^23 - DeepSeek-R1: 2^23 - Glaive-1: 2^23 - Claude-3-Sonnet: 2^24 - GPT-5: 2^23 - **Trend**: Claude-3-Sonnet achieves the highest task length (2^24), followed by multiple models at 2^23. --- ## Section 5: Larger Models Are More Prone To Self-Conditioning ### Line Graph (Turn 100 Accuracy vs Induced Error Rate) - **Title**: Larger Models Are More Prone To Self-Conditioning - **X-Axis**: Induced Error Rate (0.0–1.0) - **Y-Axis**: Turn 100 Accuracy (0.0–1.0) - **Legend**: - Blue lines: Quen3 variants (4b, 8b, 14b, 32b) - **Data Points**: - Quen3-4b: (0.1, 0.95), (0.2, 0.90), (0.3, 0.85) - Quen3-8b: (0.15, 0.92), (0.25, 0.88), (0.35, 0.83) - Quen3-14b: (0.2, 0.90), (0.3, 0.85), (0.4, 0.80) - Quen3-32b: (0.3, 0.75), (0.4, 0.70), (0.5, 0.65) - **Trend**: Accuracy decreases as error rate increases, with larger models showing steeper declines. --- ## Notes - **Language**: All text is in English. - **Critical Observations**: 1. Step accuracy plateaus after initial gains, while task length grows exponentially (Section 1). 2. Larger models (e.g., Quen3-32b) exhibit significant self-conditioning errors (Section 5). 3. Claude-3-Sonnet achieves the longest task length (2^24) in a single turn (Section 4). </details> Figure 1: A summary of our contributions. Our work measures long-horizon execution, finding large benefits from scaling model size and sequential test-time compute. We identify a failure mode where models self-condition on their own errors, degrading future performance. LLM failures on simple, but long tasks have been considered a fundamental inability to reason (Mirzadeh et al., 2024). Despite massive improvements on complex reasoning benchmarks, Shojaee et al. (2025) claim thinking models (Guo et al., 2025) only give an “illusion of thinking”, as they eventually fail when the task is made longer. These results have sparked much debate in the community, which we think can be resolved by decoupling the need for planning and execution in reasoning or agentic tasks. Planning involves deciding what information to retrieve or tools to use and in which order, while execution involves carrying out the plan. In Shojaee et al. (2025) setup, the LLMs know the correct plan, as they initially follow it correctly for many steps. We posit that the eventual failures are in execution—as the task gets longer, the model is more likely to make a mistake in executing the plan. Although much attention has been paid to LLM planning abilities (Kambhampati et al., 2024), execution remains an understudied challenge, despite being increasingly important as LLMs begin to be used for long reasoning and agentic tasks. In this work, we measure long-horizon execution capabilities of LLMs in a controlled setting. We isolate the execution capability of LLMs by explicitly providing them the knowledge and plan needed. By controlling the number of turns, and the number of steps per turn, which together contribute to task length, we reveal insights about long-horizon execution in LLMs: Does Scaling have Diminishing Returns? We observe that diminishing improvements in single-step accuracy can compound, leading to exponential growth in the length of task a model can complete. Traditionally, scaling model size is assumed to increase capacity to store parametric knowledge or search for plans. Yet, even when the required knowledge and plan are explicitly provided, we find that scaling model size leads to large improvements in the number of turns a model can execute successfully. The Self-Conditioning Effect. One might assume that failures on long tasks are simply due to the compounding of a small, constant per-step error rate and context length issues. However, we find that the per-step error rate itself rises as the task progresses. This is in contrast to humans, who typically improve at executing a task with practice. We hypothesize that, as a significant fraction of model training is to predict the most likely next token given its context, conditioning models on their own error-prone history increases the likelihood of future errors. We test this by controlling the error rate in the history provided to the model. As the error rate in the history is increased, we observe a sharp degradation in subsequent step accuracy, validating that models self-condition. We show how self-conditioning leads to degradation in model performance in long-horizon tasks beyond previously identified long-context issues, and unlike the latter, is not mitigated by scaling model size. The Impact of Thinking. We find that recent thinking models are not affected by prior mistakes, fixing the self-conditioning effect. Further, sequential test time compute also significantly improves the length of task a model can complete in a single turn. Where, without chain-of-thought prompting, even frontier LLMs like DeepSeek-V3 fail at performing even four steps of execution, and its thinking version R1 can execute over 100 steps, highlighting the importance of reasoning before acting (Yao et al., 2023). We benchmark frontier thinking models, and find GPT-5 thinking (codenamed “Horizon”) can execute over 2100 steps, far ahead of the next best competitor, Claude-4 Sonnet at 432. The “jagged frontier” (Dell’Acqua et al., 2023) of LLM capabilities remains fascinating yet confusing. Unlike traditional machines, LLMs are more susceptible to failure when used for executing repetitive tasks. Thus, we argue that execution failures in long tasks should not be misinterpreted as the inability to reason. We show that long-horizon execution improves dramatically by scaling model size and sequential test time compute. If the length of tasks a model can complete indicates its economic value, continued investment in scaling compute might be worth the cost, even if short-task benchmarks give the illusion of slowing progress. 2 Formulation First, we define key capabilities involved in an agentic or reasoning task. As a motivating example, consider an agent for the task of booking flights. Upon receiving a search result, the agent must reason to choose a flight that aligns with user preferences. One plan for this reasoning task could be: For each flight, verify the flight timings, baggage allowance, and airline reviews. Then apply any available discounts or reward programs, and finally select a flight based on cost and travel time. Each of these individual steps requires two operations: retrieving some information, and composing it with the existing information state, until the goal of choosing the final flight is reached. Both these operations require knowledge, potentially tacit, about how to perform them. Execution is carrying out this plan, a sequence of retrieve-then-compose steps, until a final booking is made. We formalize these terms for our work as follows: Key Terms Planning. Deciding what steps to take, and in what sequence. Execution. Carrying out the steps decided in the plan. Knowledge. Information about different types of steps, and how to compose them. A reasoning task. Requires planning the steps needed to solve it, and then executing them. An agentic task. Requires planning what actions to take, and then executing them. In this work, we focus on execution, as we argue that it is a critical component of long-horizon capabilities. Execution has traditionally received less attention (Stechly et al., 2024) than capabilities such as reasoning, planning, and world knowledge, which have been the primary focus of LLM capability discussions. In fact, failures in execution have been misattributed to limitations in reasoning or planning capabilities (Shojaee et al., 2025; Khan et al., 2025). This perception may stem from the view that execution is straightforward or mundane. For example, once we as humans learn how to do a task, we are quite reliable at executing it, even improving with practice. However, as LLMs do not come with correctness guarantees, we posit that just execution over a long horizon can surprisingly be a challenge. We hypothesize that: Even if planning and world knowledge are perfected, LLMs will still make mistakes in execution over a long-horizon. In an agentic or reasoning task, the model begins in an initial state (based on the first input) and has to perform a sequence of steps to reach the final goal. A long-horizon task requires a large number of steps, with the task length being the number of steps needed to complete it. We define the following metrics to evaluate performance: Evaluation Metrics Step Accuracy. Measures the fraction of samples where the state update from step $i-1$ to step $i$ is correct, regardless of the correctness of the model’s state at step $i-1$ . Turn Accuracy. A turn is a single interaction with the model, which may require executing multiple steps. Turn Accuracy measures the fraction of samples where the state update from turn $t-1$ to turn $t$ is correct, regardless of the correctness of the model’s state at turn $t-1$ . Turn Complexity ( $K$ ). Defined as the number of steps the model has to execute per turn. Task Accuracy. Measures the fraction of samples in which the model can complete a task of $i$ steps without making any mistakes in the process. Horizon Length ( $H_{s}$ ). Given a success rate threshold $0≤ s≤ 1$ , the horizon length is the first step $i$ where the model’s mean task accuracy across samples drops below $s$ . It can be interpreted as: the model can perform a task of length $H_{s}$ without making mistakes, with probability $s$ . We use $s=0.5$ unless otherwise specified, like Kwa et al. (2025). 2.1 Diminishing Returns in Step Accuracy Compound Over a Long Horizon We begin by analyzing the relationship between a model’s single-step accuracy and its horizon length. Note that this analysis applies not just to execution, but rather to any general long-horizon task. To obtain a mathematical relation, we make two simplifying assumptions similar to LeCun (2023). First, we assume a model’s step accuracy remains constant over the task. Second, we assume a model does not self-correct, meaning any single error leads to task failure. We assume this only for the analysis here, which is illustrative and provides useful intuition. Our subsequent empirical analysis goes beyond this, investigating how LLMs, in fact, do not exhibit constant step accuracy for long-horizon execution, and may also correct their mistakes. <details> <summary>2509.09677v2/figs/math_plot.png Details</summary>  ### Visual Description # Technical Document Extraction: Line Chart Analysis ## Chart Overview The image depicts a line chart illustrating the relationship between **Step Accuracy (p)** and **Horizon Length** across five distinct parameter values (H). The chart uses color-coded curves to represent different H values, with a legend in the top-left corner for reference. --- ### **Axis Labels and Scales** - **X-Axis (Horizontal):** - Title: **Step Accuracy (p)** - Range: **0.8** to **1** - Tick Marks: **0.8, 0.85, 0.9, 0.95, 1** - Scale: Linear - **Y-Axis (Vertical):** - Title: **Horizon Length** - Range: **0** to **100** - Tick Marks: **20, 40, 60, 80, 100** - Scale: Linear --- ### **Legend** - **Location:** Top-left corner (inside a gray box). - **Labels and Colors:** | H Value | Color | |---------|------------| | H₀.₁₀ | Yellow | | H₀.₂₅ | Orange | | H₀.₅₀ | Red | | H₀.₇₅ | Purple | | H₀.₉₀ | Dark Blue | --- ### **Data Series and Trends** 1. **H₀.₁₀ (Yellow Line):** - **Trend:** Starts at ~10 Horizon Length when p=0.8, curves steeply upward, reaching ~95 at p=1. - **Key Points:** - p=0.8 → ~10 - p=0.9 → ~30 - p=0.95 → ~70 - p=1 → ~95 2. **H₀.₂₅ (Orange Line):** - **Trend:** Starts at ~5 Horizon Length when p=0.8, curves upward, reaching ~85 at p=1. - **Key Points:** - p=0.8 → ~5 - p=0.9 → ~25 - p=0.95 → ~60 - p=1 → ~85 3. **H₀.₅₀ (Red Line):** - **Trend:** Starts at ~2 Horizon Length when p=0.8, curves upward, reaching ~90 at p=1. - **Key Points:** - p=0.8 → ~2 - p=0.9 → ~15 - p=0.95 → ~50 - p=1 → ~90 4. **H₀.₇₅ (Purple Line):** - **Trend:** Starts at ~1 Horizon Length when p=0.8, curves upward, reaching ~98 at p=1. - **Key Points:** - p=0.8 → ~1 - p=0.9 → ~10 - p=0.95 → ~75 - p=1 → ~98 5. **H₀.₉₀ (Dark Blue Line):** - **Trend:** Nearly flat line starting at ~0.5 Horizon Length when p=0.8, rising sharply near p=1 to ~99. - **Key Points:** - p=0.8 → ~0.5 - p=0.9 → ~2 - p=0.95 → ~50 - p=1 → ~99 --- ### **Key Observations** - **Inverse Relationship:** Higher H values (e.g., H₀.₉₀) exhibit steeper curves, indicating rapid increases in Horizon Length as Step Accuracy approaches 1. - **Convergence:** All lines converge near p=1, with Horizon Length approaching 100 for all H values. - **Divergence:** Lower H values (e.g., H₀.₁₀) show gradual increases, while higher H values (e.g., H₀.₉₀) exhibit near-vertical rises. --- ### **Spatial Grounding** - **Legend Placement:** Top-left corner (x=0.05, y=0.95 relative to chart boundaries). - **Line Placement:** - Yellow (H₀.₁₀): Topmost curve. - Orange (H₀.₂₅): Second-highest curve. - Red (H₀.₅₀): Third-highest curve. - Purple (H₀.₇₅): Fourth-highest curve. - Dark Blue (H₀.₉₀): Bottommost curve. --- ### **Conclusion** The chart demonstrates that **Higher H values correlate with steeper increases in Horizon Length as Step Accuracy improves**. This suggests a parameter-dependent sensitivity in the modeled system, where higher H values amplify the relationship between accuracy and horizon length. </details> Figure 2: Growth of Horizon Length. The length of task a model can perform grows hyperbolically in the high accuracy regime. **Proposition 1** *Assuming a constant step accuracy $p$ and no self-correction, the task-length $H$ at which a model achieves a success rate $s$ is given by: $$ \hskip-56.9055ptH_{s}(p)=\left\lceil\frac{\ln(s)}{\ln(p)}\right\rceil\ \approx\frac{\ln(s)}{\ln(p)} $$ (The derivation is provided in Appendix ˜ H.)* This shows that the horizon length grows hyperbolically with the step accuracy. We illustrate this growth in Figure ˜ 2 across different values for the success rate $s$ . Notice the sharp growth in horizon length beyond 80% single-step accuracy, performance that frontier models now achieve on many question-answering benchmarks (Vendrow et al., 2025), which can be considered short tasks. We note that human labor is often compensated for its time. If the economic value of an agent also arises from the length of tasks it can complete, single-turn or short task benchmarks may be misleading for evaluating the benefits of further investment in LLM compute. While these benchmarks reveal genuine diminishing returns at the step level, they understate the compounding benefits that emerge over long-horizons. Beyond a threshold, small improvements in step accuracy can translate into success at rapidly increasing task lengths, which may provide a more faithful indicator of economic value. For example, in METR’s horizon length plot on software engineering tasks (Kwa et al., 2025), it was empirically observed that the horizon length at $s=0.5$ of frontier models is growing exponentially, doubling every 7 months. Using our result above, in Figure ˜ 1 we show that such exponential growth in horizon length occurs even in a regime of diminishing returns on step accuracy. If we set $s=0.5$ , we obtain $H_{0.5}=-\frac{\ln(2)}{\ln(p)}$ . As such, the step-accuracy $p$ required to sustain exponential growth in $H_{0.5}$ over time ( $t$ ) is $2^{\frac{-1}{2^{t}}}$ , which is indeed a diminishing function. 2.2 Isolating execution by decoupling planning and knowledge We now describe how we measure long-horizon execution empirically. We isolate execution failures by explicitly providing the requisite knowledge and plan. We study the chaining of the retrieve-then-compose step motivated in the flight-selection agent example earlier. Each step involves retrieving relevant information or a tool specified by the plan and then composing its output to update the current state. The plan is deciding what to retrieve and how to compose it, whereas execution is actually performing those operations. This fits a natural abstraction—a key-value dictionary. The key serves as one step of a plan specifying what knowledge to retrieve, or tool to call, while the value represents the knowledge or tool output, which then has to be composed with the current state. In our study, we provide the plan as the keys in each query, eliminating the need for planning abilities from the LLM. We also provide the key-value dictionary in context, removing any dependency on the model’s parametric knowledge. With this design, we directly control two important axes that multiply to obtain the task length (number of retrieve-then-compose steps): the number of turns, and the turn complexity ( $K$ ). The turn complexity can be varied by changing the number of keys queried per turn. <details> <summary>2509.09677v2/x2.png Details</summary>  ### Visual Description # Technical Document Extraction: Process Diagram Analysis ## Diagram Overview The image presents a comparative analysis of two approaches to handling long-horizon tasks, visualized through two distinct diagram types: ### Left Diagram: "Long-Horizon Tasks Can Be Represented As" **Components and Flow:** 1. **The Plan** (Blue Box) - Sequential steps labeled Step 1 through Step N - Each step contains two sub-components: - `Retrieve` (Input) - `Compose` (Processing) - Outputs labeled Output 1 through Output N 2. **The Execution** (Green Box) - Central processing unit - Contains iterative `Retrieve` → `Compose` cycles - Arrows indicate sequential flow between steps 3. **The State** (Pink Box) - Contains output results - Shows cumulative state evolution 4. **User Provided** (Bottom Left) - External input source - Arrows indicate feedback loop into the system **Key Textual Elements:** - Header: "Long-Horizon Tasks Can Be Represented As" - Footer: "We isolate and study Long-Horizon Execution by LLMs" - Color-coded regions: - Blue: Planning phase - Green: Execution phase - Pink: State management ### Right Diagram: "Our Abstraction: Key-Value Dictionary Addition" **Components and Flow:** 1. **Dictionary Tracking System** (Blue Box) - Key-Value pairs: - Apple: -82 - Break: 32 - Grape: 56 - Track: -4 2. **User Interaction 1** (Add Apple + Grape) - Calculation: `-82 + 56 = -26` - Output: `<answer> -26 </answer>` 3. **User Interaction 2** (Add Break + Track) - Calculation: `-26 + 32 - 4 = 2` - Output: `<answer> 2 </answer>` **Key Textual Elements:** - Header: "Our Abstraction: Key-Value Dictionary Addition" - Color-coded elements: - Blue: Dictionary entries - Yellow: Calculation steps - Pink: Final answers - Green: Intermediate sums ## Cross-Diagram Analysis **Color Legend Correlation:** - Blue: System components/inputs - Green: Execution processing - Pink: State/outputs - Yellow: Calculation operations - Pink: Final answers **Process Flow Comparison:** 1. Traditional Approach (Left): - Linear step-by-step execution - Explicit state management - Requires full task horizon visibility 2. Proposed Abstraction (Right): - Dictionary-based state tracking - Incremental calculation model - Implicit state management through key-value pairs ## Technical Implications 1. **LLM Execution Isolation:** - Left diagram demonstrates traditional LLM execution pipeline - Right diagram shows abstraction layer for dictionary-based operations 2. **State Management Evolution:** - From explicit output tracking (pink box) - To implicit key-value dictionary tracking 3. **Calculation Paradigm:** - Sequential composition (left) - Dictionary-based aggregation (right) ## Limitations - No numerical data trends present - No explicit axis labels or legends - Diagram focuses on process representation rather than quantitative analysis </details> Figure 3: Overview of our framework. (Left) Our framework models long-horizon tasks as a sequence of retrieve-then-compose steps. (Right) We design a simple task that decouples planning from execution: in each turn, we provide the model the plan as key(s), asking it to retrieve their value(s), and compose them to maintain a running sum. We control the number of turns and turn complexity (keys per query). 3 Experiments We design a simple task where even language models with 4 billion parameters can achieve high accuracy, to isolate the capability of long-horizon execution. Setup. As illustrated in Figure ˜ 3, we provide the model with the needed knowledge, a fixed, in-context dictionary $\mathcal{D}:\mathcal{V}→\mathbb{Z}$ , where $\mathcal{V}$ is a vocabulary of common five-letter English words and values are integers sampled uniformly from $[-99,99]$ . The initial state is $S_{0}=0$ . In turn $t∈\{1,...,T\}$ , the model receives an explicit plan $P_{t}=\{k_{t,1},...,k_{t,K}\}$ , which is a set of $K$ keys sampled from $\mathcal{V}$ . For each turn $t$ , the model must execute this plan, which requires updating the state, $S_{t}$ , to maintain a running sum of values for all past queried keys. This requires the retrieve-then-compose steps: 1. Retrieval: Look up the integer value $\mathcal{D}[k]$ for each key $k∈ P_{t}$ 1. Composition: Sum these values and add them to the previous state, $S_{t}=S_{t-1}+\sum_{i=1}^{K}\mathcal{D}[k_{t,i}]$ We choose short English words and two-digit integers to minimize errors arising from tokenization. We provide few-shot examples to clarify the task. More details, including the exact prompt, are provided in Appendix ˜ E. We also disentangle performance on the individual retrieval and composition operations, finding that models have much higher accuracies on each of them alone (Appendix ˜ D). 3.1 Effect of increasing the number of turns We first test our hypothesis that long-horizon execution can be challenging even when a model has the required knowledge and planning ability, and then study the benefits of scaling model size. Setup. We evaluate the Qwen3 (Yang et al., 2025) and Gemma3 (Gemma-Team et al., 2025) model families, as they offer a range of sizes: [4, 8, 14, 32]B and [4, 12, 27]B parameters, respectively. For this experiment, we set the turn complexity to its simplest form ( $K=1$ ), providing a single key per turn, and vary the number of turns. Models are instructed to output the final answer directly, without intermediate thinking tokens, with the format enforced via few-shot examples. We verify that format-following errors are not the primary failure mode (Appendix ˜ F). We also show that the results below hold with chain-of-thought (CoT) prompting, and thinking models (Appendix Figure ˜ 12), and the trends are not affected by the temperature used (Appendix Figure ˜ 13). Result 1: Execution alone is challenging. As seen in Figure ˜ 4 (a), all models except Gemma3-4B and Qwen3-4B achieve near-perfect accuracy on the first step, confirming they have the knowledge required to perfectly do a single step of our task. Yet, task accuracy falls rapidly over subsequent turns (Figure ˜ 4 (c)). Even the best-performing model (Qwen3-32B) sees its accuracy fall below 50% within 15 turns. This confirms our hypothesis that long-horizon execution can be challenging for LLMs, even if they have the needed knowledge and plan. Result 2: Non-diminishing benefits of scaling model size. As shown in Figure ˜ 4 (c), larger models sustain higher task accuracy for significantly more turns, resulting in a clear scaling trend for horizon length (Figure ˜ 4 (b)). We abstain from deriving a “scaling law” since we can only obtain at most four model sizes from the same family, but the improvements do not seem diminishing. This observation is non-trivial. While the benefits of increasing model size are often attributed to improved capacity for knowledge, our task is not knowledge-constrained, as models achieve near-perfect first step accuracy (Figure ˜ 4 (a)), nor is the task more complex so that a larger model would be required. Yet, larger models are clearly more reliable at executing the task for longer. A possible explanation is the redundancy of internal circuits in larger models, which ensembles to reduce error (Lindsey et al., 2025). However, we find that simulating this redundancy with output-level aggregation of parallel compute does not replicate the gains observed from scaling model size (Appendix ˜ B). <details> <summary>2509.09677v2/x3.png Details</summary>  ### Visual Description # Technical Document Extraction ## Subplot (a) **Title**: Turn 1 Accuracy vs. Model Size **X-axis**: Model Size (Billion Parameters) **Y-axis**: Turn 1 Accuracy **Legend**: - **Qwen3** (Blue) - **Gemma3** (Red) **Key Trends**: - **Qwen3**: Accuracy starts at ~0.85 (10B parameters), sharply increases to 1.0 at 20B, and plateaus. - **Gemma3**: Accuracy starts at ~0.75 (10B parameters), gradually rises to ~0.95 at 20B, and plateaus. **Spatial Grounding**: - Legend located in the lower-left corner. - Blue data points (Qwen3) and red data points (Gemma3) match legend colors exactly. --- ## Subplot (b) **Title**: Horizon Length vs. Model Size **X-axis**: Model Size (Billion Parameters) **Y-axis**: Horizon Length **Legend**: - **Qwen3** (Blue) - **Gemma3** (Red) **Key Trends**: - **Qwen3**: Horizon length starts at 4 (10B parameters), increases to 6 (20B), then 12 (30B). - **Gemma3**: Horizon length starts at 2 (10B parameters), increases to 4 (20B), then 8 (30B). **Spatial Grounding**: - Legend located in the lower-left corner. - Blue and red lines match legend colors exactly. --- ## Subplot (c) **Title**: Task Accuracy vs. Task Length **X-axis**: Task Length **Y-axis**: Task Accuracy **Legend**: - **Qwen3-4B** (Light Blue) - **Qwen3-8B** (Blue) - **Qwen3-14B** (Dark Blue) - **Gemma3-4B** (Light Orange) - **Gemma3-12B** (Orange) - **Gemma3-27B** (Dark Orange) - **Trend Line** (Dashed Red) **Key Trends**: - All models show a **decline in task accuracy** as task length increases. - Larger models (e.g., Qwen3-32B, Gemma3-27B) maintain higher accuracy at longer task lengths. - Dashed red trend line indicates a general downward trajectory across all models. **Spatial Grounding**: - Legend located in the lower-left corner. - Colors match legend labels (e.g., dark blue = Qwen3-14B). --- ## Subplot (d) **Title**: Turn Accuracy vs. Task Length **X-axis**: Task Length **Y-axis**: Turn Accuracy **Legend**: - **Qwen3-4B** (Light Blue) - **Qwen3-8B** (Blue) - **Qwen3-14B** (Dark Blue) - **Gemma3-4B** (Light Orange) - **Gemma3-12B** (Orange) - **Gemma3-27B** (Dark Orange) **Key Trends**: - All models exhibit **fluctuating but declining turn accuracy** as task length increases. - Larger models (e.g., Qwen3-32B, Gemma3-27B) show more stable performance at longer task lengths. **Spatial Grounding**: - Legend located in the lower-left corner. - Colors match legend labels (e.g., dark orange = Gemma3-27B). --- ## Notes - **Language**: All text is in English. - **Data Consistency**: Legend colors and line placements are cross-verified for accuracy. - **Trend Verification**: Visual trends (e.g., plateaus, declines) align with numerical data points. - **Component Isolation**: Each subplot is analyzed independently to avoid context-bleeding. </details> Figure 4: Scaling model size has non-diminishing improvements in the number of turns it can execute. The first-step accuracy for our task is near-perfect for all except the smallest models (a). Yet, as the model size is scaled, the horizon length increases significantly (b). We also see the effect of scaling in widening the gap between small and large models in task accuracy (c) and turn accuracy (d) as the number of turns increases. The shaded region is the mean $±$ one standard deviation over 100 samples; the solid line is the moving average over 5 turns; the dotted line is a hypothetical baseline model with constant step-accuracy of 0.99. 3.2 Why Does Turn Accuracy Degrade? The Self-Conditioning Effect One might expect a model’s turn accuracy to remain constant. Yet, Figure ˜ 4 (d) shows the accuracy of individual turns degrading as the number of turns increases. We investigate two competing hypotheses: 1. Degradation as the context length increases. The model’s performance degrades simply due to increasing context length (Zhou et al., 2025a), irrespective of its content. 2. Self-conditioning. The model conditions on its own past mistakes. It becomes more likely to make a mistake after observing its own past errors in previous turns. Setup. To disentangle these factors, we conduct a counterfactual experiment by manipulating the model’s chat history. We control the error rate by injecting artificial output histories with a chosen error rate in the same format. If we fully heal the history, with a $0\%$ error rate, degradation in the model’s turn accuracy between turn 1 and a later turn can be attributed to long-context issues. If a model’s accuracy for a fixed later turn consistently worsens with increasing error rate in prior turns, this would support our self-conditioning hypothesis. Result 3: Self-conditioning causes degradation in turn accuracy beyond long-context. Our results in Figure ˜ 5 (a) show evidence for degradation due to both long-context and self-conditioning. When conditioned on an error-free history (Induced Error Rate = 0.00), model turn accuracy at turn 100 is below its initial value, consistent with prior observations of long-context degradation (Zhou et al., 2025a). More interestingly, as we increase the rate of injected errors into the context, accuracy at turn 100 consistently degrades further. This demonstrates the self-conditioning effect—as models make mistakes, they become more likely to make more mistakes, leading to a continuous degradation in per-turn accuracy throughout the output trajectory as shown in Figure ˜ 5 (b). Result 4: Unlike long-context, scaling model size does not mitigate self-conditioning. At the error rate of 0%, notice that the accuracy at turn 100 consistently improves as you scale model size. As shown in Figure ˜ 5 (b), scaling to frontier (200B+ parameter) models like Kimi-K2 (Kimi-Team et al., 2025), DeepSeek-V3 (DeepSeek-AI et al., 2025), and Qwen3-235B-Instruct-2507 (Yang et al., 2025) largely solves long-context degradation for up to 100 turns, achieving near-perfect accuracy on a healed history. However, even these large models remain susceptible to self-conditioning, as their performance consistently degrades as the induced error rate in their history increases. This may be akin to recent results showing larger models shift in personality during multi-turn conversations (Choi et al., 2024; Becker et al., 2025), where in our case, the drift is toward a personality that makes errors. <details> <summary>2509.09677v2/x4.png Details</summary>  ### Visual Description # Technical Document Analysis of Image ## Section (a): Line Graphs Comparing Model Performance Under Error Rates ### Key Components: 1. **Graph Titles**: - All graphs labeled "Turn Accuracy vs Task Length" - Subtitles indicate specific models: Qwen-3-14B, Qwen-3-32B, Gemma-3-12B, Gemma-3-27B 2. **Axes**: - **X-axis**: Task Length (0–100) - **Y-axis**: Turn Accuracy (0–1.0) 3. **Legend**: - Located at bottom-left corner - Colors correspond to: - **Blue**: Original Run - **Red**: 100% Error Rate - **Orange**: 75% Error Rate - **Yellow**: 50% Error Rate - **Green**: 25% Error Rate - **Dark Green**: 0% Error Rate 4. **Trends**: - All models show **decreasing Turn Accuracy** as Task Length increases - **Error Rate Impact**: - Higher error rates (e.g., 100% red) consistently show **lower accuracy** than lower error rates - Example: Qwen-3-14B (blue) starts at ~0.8 accuracy at Task Length 0, drops to ~0.6 at Task Length 100 with 100% error - Gemma-3-12B (orange) starts at ~0.75 accuracy, drops to ~0.5 with 100% error ### Spatial Grounding: - Legend colors match line colors exactly (e.g., red lines = 100% error rate) - All graphs share identical axis ranges and formatting --- ## Section (b): Bar Charts Comparing Model Robustness ### Key Components: 1. **Left Chart**: - **Title**: Turn Accuracy vs Model - **X-axis**: Models (Qwen-3-32B, Qwen-3-14B, Qwen-3-8B, Qwen-4B, Gemma-12B, Gemma-4B) - **Y-axis**: Turn Accuracy (0–1.0) - **Trends**: - Qwen-3-32B (blue) shows highest baseline accuracy (~0.8) - Qwen-3-14B (light blue) follows (~0.75) - Gemma-4B (pink) has lowest baseline (~0.6) 2. **Right Chart**: - **Title**: Turn Accuracy vs Induced Error Rate - **X-axis**: Induced Error Rate (0.00–1.00 in 0.25 increments) - **Y-axis**: Turn Accuracy (0–1.0) - **Models**: - **DeepSeek-chat-3-0524** (purple) - **Kimi K2** (orange) - **Qwen-3-2507-235B** (brown) - **Trends**: - All models show **linear decline** in accuracy as error rate increases - Example: DeepSeek starts at ~0.95 accuracy at 0% error, drops to ~0.35 at 100% error - Kimi K2 shows steepest decline (~0.9 to ~0.25) ### Spatial Grounding: - Bar colors match legend labels exactly - Error rate increments (0.00, 0.25, 0.50, 0.75, 1.00) are evenly spaced on X-axis --- ## Cross-Section Analysis 1. **Error Rate Sensitivity**: - All models degrade performance as error rates increase - Qwen-3-32B (section a) and DeepSeek (section b) show highest baseline accuracy - Gemma-4B (section a) and Kimi K2 (section b) exhibit steepest declines 2. **Model Robustness**: - Larger models (e.g., Qwen-3-32B) maintain higher accuracy than smaller variants (Qwen-3-14B) - Gemma-3-12B (section a) and Kimi K2 (section b) show moderate robustness 3. **Error Rate Impact**: - 100% error rate reduces accuracy by ~30–40% across all models - 0% error rate preserves near-optimal performance (0.8–0.95 range) --- ## Data Table Reconstruction (Section a) | Model | Task Length | Original Run | 100% Error | 75% Error | 50% Error | 25% Error | 0% Error | |----------------|-------------|--------------|------------|-----------|-----------|-----------|----------| | Qwen-3-14B | 0 | 0.8 | 0.6 | 0.7 | 0.75 | 0.78 | 0.82 | | Qwen-3-14B | 100 | 0.6 | 0.4 | 0.5 | 0.55 | 0.58 | 0.62 | | Qwen-3-32B | 0 | 0.85 | 0.65 | 0.72 | 0.76 | 0.79 | 0.83 | | Qwen-3-32B | 100 | 0.62 | 0.45 | 0.51 | 0.54 | 0.57 | 0.61 | | Gemma-3-12B | 0 | 0.75 | 0.55 | 0.62 | 0.65 | 0.68 | 0.71 | | Gemma-3-12B | 100 | 0.5 | 0.35 | 0.42 | 0.45 | 0.48 | 0.51 | | Gemma-3-27B | 0 | 0.78 | 0.58 | 0.64 | 0.67 | 0.70 | 0.73 | | Gemma-3-27B | 100 | 0.55 | 0.4 | 0.46 | 0.49 | 0.52 | 0.55 | --- ## Notes - All data points extracted from visual trends; exact values approximated - No non-English text detected - All legends and axis labels transcribed verbatim - Spatial relationships (e.g., legend placement) confirmed for accuracy </details> Figure 5: Models self-condition on their previous mistakes, leading to more mistakes in subsequent turns. By manipulating the chat history, we counterfactually vary the fraction of errors in previous turns. We find this increases the likelihood of errors in future turns (left). This shows a source of degradation in turn-wise model accuracy beyond long-context, as in the turn 100 slice (right) model accuracies are much higher when we provide a fully correct history. Scaling model size increases self-conditioning, even for frontier non-thinking models. In Appendix ˜ G, we try the above setup of output manipulations with CoT prompting, finding that accuracy still deteriorates as the induced error rate increases. A potential confounder is that the manipulated outputs deviate from the CoT. We try to mitigate this issue with programmatically generated CoT traces, but still observe self-conditioning. We also try removing CoT traces from previous turns from history, which causes the model to stop using CoT completely. So, we now present results for the Qwen3 thinking models, which are trained with reinforcement learning (RL) to think even when previous turn traces are not presented. As before, we observe their turn 100 accuracy while controlling the error rate in prior turns. <details> <summary>2509.09677v2/x5.png Details</summary>  ### Visual Description # Technical Document Analysis: Turn 100 Accuracy vs. Induced Error Rate ## **Chart Title** - **Title**: "Turn 100 Accuracy" ## **Axes** - **X-Axis**: - **Label**: "Induced Error Rate" - **Range**: 0.00 to 1.00 - **Ticks**: 0.00, 0.25, 0.50, 0.75, 1.00 - **Y-Axis**: - **Label**: "Turn 100 Accuracy" - **Range**: 0.0 to 1.0 - **Ticks**: 0.0, 0.2, 0.4, 0.6, 0.8, 1.0 ## **Legend** - **Position**: Right side of the chart - **Entries**: 1. **Qwen3-4b**: Light blue (■) 2. **Qwen3-8b**: Teal (■) 3. **Qwen3-14b**: Light blue (■) 4. **Qwen3-32b**: Dark blue (■) ## **Data Series** ### **Qwen3-4b (Light Blue)** - **Trend**: - Starts at ~0.75 (x=0.00) - Dips to ~0.65 (x=0.50) - Rises to ~0.85 (x=1.00) - **Data Points**: - x=0.00: 0.75 - x=0.25: 0.70 - x=0.50: 0.65 - x=0.75: 0.80 - x=1.00: 0.85 ### **Qwen3-8b (Teal)** - **Trend**: - Starts at ~0.75 (x=0.00) - Dips to ~0.70 (x=0.50) - Rises to ~0.85 (x=1.00) - **Data Points**: - x=0.00: 0.75 - x=0.25: 0.70 - x=0.50: 0.70 - x=0.75: 0.80 - x=1.00: 0.85 ### **Qwen3-14b (Light Blue)** - **Trend**: - Starts at ~0.75 (x=0.00) - Dips to ~0.65 (x=0.50) - Rises to ~0.85 (x=1.00) - **Data Points**: - x=0.00: 0.75 - x=0.25: 0.70 - x=0.50: 0.65 - x=0.75: 0.80 - x=1.00: 0.85 ### **Qwen3-32b (Dark Blue)** - **Trend**: - Starts at ~0.85 (x=0.00) - Dips to ~0.65 (x=0.50) - Rises to ~0.90 (x=1.00) - **Data Points**: - x=0.00: 0.85 - x=0.25: 0.75 - x=0.50: 0.65 - x=0.75: 0.85 - x=1.00: 0.90 ## **Error Bars** - **Presence**: Vertical error bars at each data point - **Details**: No numerical values provided for error margins; visual length varies by model and error rate. ## **Key Observations** 1. **Model Performance**: - **Qwen3-32b** (dark blue) consistently achieves the highest accuracy across all error rates. - **Qwen3-4b** and **Qwen3-14b** (light blue) show similar trends but lower accuracy than Qwen3-32b. - **Qwen3-8b** (teal) exhibits moderate performance, with a slight dip at x=0.50. 2. **Error Rate Impact**: - All models experience a drop in accuracy at x=0.50 (50% induced error rate). - Accuracy recovers as error rate increases to 1.00, though not to initial levels. 3. **Legend Consistency**: - Colors in the legend match the corresponding lines in the chart (e.g., Qwen3-4b = light blue). ## **Data Table Reconstruction** | Model | x=0.00 | x=0.25 | x=0.50 | x=0.75 | x=1.00 | |--------------|--------|--------|--------|--------|--------| | Qwen3-4b | 0.75 | 0.70 | 0.65 | 0.80 | 0.85 | | Qwen3-8b | 0.75 | 0.70 | 0.70 | 0.80 | 0.85 | | Qwen3-14b | 0.75 | 0.70 | 0.65 | 0.80 | 0.85 | | Qwen3-32b | 0.85 | 0.75 | 0.65 | 0.85 | 0.90 | ## **Conclusion** The chart illustrates the relationship between induced error rates and turn 100 accuracy for four Qwen3 model variants. Higher model sizes (e.g., Qwen3-32b) demonstrate superior accuracy, particularly at higher error rates. All models show a dip at 50% error rate, followed by partial recovery at 100% error rate. </details> Figure 6: Thinking fixes self-conditioning. Qwen3 models with thinking enabled no longer self-condition, even when the entire prior history has wrong answers, in contrast to non-thinking results. Result 5: Thinking fixes self-conditioning. In Figure ˜ 6, we observe that the Qwen3 thinking models do not self-condition—the accuracy of the models at turn 100 remains stable, regardless of the error rate in its context. This could arise from two reasons. First, RL training can reduce the most likely next token prediction behaviour of language models, making them oriented towards task success rather than continuing the context. Second, the removal of thinking traces from prior turns could reduce the influence of prior turns on the model’s output, as it thinks about the new turn independently. By inspecting the models’ thinking traces, we observe that they do not refer back to their answers in prior turns, which could be a potential reason why they do not self-condition. Inspired by this, for non-thinking models, we experiment with context engineering by explicitly removing prior history and find that it indeed mitigates self-conditioning (Section ˜ A.2). We also find that just prompting models to self-verify their answers does not solve self-conditioning completely (Section ˜ A.1). 3.3 What is the length of tasks models can complete in a single turn? In the previous sections, we measured how many turns models can successfully execute a single retrieve-then-compose step. However, most real-world tasks require more complex processing every turn. In fact, in Appendix ˜ C we show that the horizon length of different models can vary significantly at different turn complexities. The total task length a model can handle is a function of both the number of turns and the number of steps to execute per turn. We now measure the latter dimension: the maximum number of steps a model can execute per turn. <details> <summary>2509.09677v2/x6.png Details</summary>  ### Visual Description # Technical Document Extraction: Task Length Analysis ## Chart (a) ### Title: Task Length (Single Turn) #### Axes: - **Y-axis**: Task Length (Single Turn) [0, 1, 2, 3, 4, 5, 6] - **X-axis**: Model Variants - Qwen3-32B - Gemma3-27B - Deepseek-V3 - Kimi-K2 #### Legend: - **Location**: Top-left corner - **Label**: "Without CoT" (Boxed text) #### Data Points: | Model | Color | Value | Legend Match | |----------------|-------------|-------|--------------| | Qwen3-32B | Dark Blue | 2 | ✅ Yes | | Gemma3-27B | Red | 2 | ✅ Yes | | Deepseek-V3 | Blue | 4 | ✅ Yes | | Kimi-K2 | Dark Gray | 6 | ✅ Yes | #### Trends: - **Increasing trend**: Task length escalates from 2 (Qwen3-32B/Gemma3-27B) to 6 (Kimi-K2). - **Highest value**: Kimi-K2 (6) exceeds all others by 50%. --- ## Chart (b) ### Title: Task Length (Single Turn) #### Axes: - **Y-axis**: Task Length (Single Turn) [2⁶, 2⁷, ..., 2¹¹] - **X-axis**: Model Variants - Kimi-K2 - Deepseek-V3 - Deepseek-R1 - Gemini-2.5-Pro - Grok-4 - Claude-4-Sonnet - GPT-5 #### Legend: - **Location**: Top-left corner - **Labels**: - "Thinking" (Solid Gray) - "Chain-of-Thought" (Blue with Diagonal Lines) #### Data Points: | Model | Color | Value | Legend Match | |--------------------|---------------------|--------|--------------| | Kimi-K2 | Solid Gray | 72 | ✅ Yes | | Deepseek-V3 | Blue (Diagonal) | 112 | ✅ Yes | | Deepseek-R1 | Blue (Diagonal) | 120 | ✅ Yes | | Gemini-2.5-Pro | Solid Gray | 120 | ✅ Yes | | Grok-4 | Orange | 384 | ❌ No Match | | Claude-4-Sonnet | Orange | 432 | ❌ No Match | | GPT-5 | Dark Gray | 2176 | ✅ Yes | #### Trends: - **Exponential growth**: Values range from 72 (Kimi-K2) to 2176 (GPT-5), a 30x increase. - **Dominant category**: "Chain-of-Thought" (blue) dominates mid-range (112–120), while "Thinking" (gray) spans extremes (72, 120, 2176). - **Anomaly**: Grok-4 and Claude-4-Sonnet use orange, which is **not present in the legend**. --- ## Critical Observations: 1. **Legend Discrepancy in Chart (b)**: - Grok-4 and Claude-4-Sonnet use orange, but the legend only defines "Thinking" (gray) and "Chain-of-Thought" (blue). This suggests either: - A missing legend entry for orange. - A mislabeling error in the chart. 2. **Color Consistency**: - In Chart (a), all bars align with the "Without CoT" legend. - In Chart (b), "Chain-of-Thought" (blue) and "Thinking" (gray) are consistently applied except for Grok-4/Claude-4-Sonnet. 3. **Performance Hierarchy**: - **Chart (a)**: Kimi-K2 outperforms others by 200% (6 vs. 2–4). - **Chart (b)**: GPT-5 dominates with 2176, far exceeding Claude-4-Sonnet (432) and Grok-4 (384). --- ## Conclusion: The charts compare task lengths for AI models, with Chart (a) focusing on "Without CoT" and Chart (b) contrasting "Thinking" vs. "Chain-of-Thought" approaches. Discrepancies in legend alignment (orange bars in Chart (b)) require further clarification. GPT-5 consistently shows the highest task length across both charts. </details> Figure 7: Benchmarking the length of task models can execute in a single turn. Without CoT or thinking, even the biggest models fail to execute more than a few steps (a). Sequential test time compute (thinking tokens) significantly improves this, especially when trained with RL (b), where GPT-5 is far ahead of the rest. Setup. To quantify the length of task models can complete in one go, without user input, we run a binary search (Lehmer, 1960) to find the highest turn complexity ( $K$ , the number of keys) the model can provide the correct sum for with accuracy $≥ 80\%$ . We evaluate a suite of frontier models like GPT-5 (OpenAI, 2025), Claude-4 Sonnet (Anthropic, 2025), Grok 4 (xAI, 2025), Gemini 2.5 Pro (Gemini Team, 2025), Kimi K2 (Kimi-Team et al., 2025), and DeepSeek-R1 (Guo et al., 2025). An advantage of our benchmark is that it is contamination-free, as new examples can be generated programmatically. Result 6: Without CoT, non-thinking models struggle to chain more than a few steps per turn. In Figure ˜ 7 (left), we first find that when prompted to answer directly, without chain-of-thought, the larger Qwen3 32B, Gemma3 27B, as well as frontier non-thinking models like DeepSeek-V3 (670B), and Kimi K2 (1026B), fail to execute even a turn complexity of more than six. This is consistent with prior work showing the necessity of thinking tokens for transformers to perform sequential tasks (Weiss et al., 2021; Merrill and Sabharwal, 2023). We see that the number of steps the model can execute in a single turn improves significantly with chain-of-thought. This reinforces the importance of reasoning before acting (ReAct (Yao et al., 2023)) for agents, even if this costs more and fills up the context window. We show preliminary evidence that parallel test time compute is not as helpful, with majority voting leading to only marginal improvements in execution length (Appendix ˜ B). Result 7: Benchmarking frontier models. In Figure ˜ 7 (right), we benchmark frontier models on the length of task they can execute in a single turn. We find a surprisingly large gap between GPT-5 (codenamed Horizon) with 2176 steps and others like Claude-4 Sonnet (432 steps), Grok 4 (384 steps), and Gemini 2.5 Pro (120 steps). Overall, even our simple task can separate frontier models in their long-horizon execution capability, and presents a clear opportunity to improve current open-weight models. 4 Related Work Increasing Task Length. Multiple works have recently shown how models worsen as problem complexity increases (Zhou et al., 2025b), often attributed to failures of reasoning (Cheng, 2025; Shojaee et al., 2025). Recently, multiple real-world long-horizon agentic benchmarks have been proposed (Backlund and Petersson, 2025; Xie et al., 2024; Shen et al., 2025), where prior work has studied planning failures (Chen et al., 2024b). By designing a task where no reasoning is required, given that we provide the model the requisite plan and knowledge, we show that execution alone can be a challenge, degrading model accuracy on longer tasks. Our observations on scaling could hold for the related problem of length-generalization—training models to succeed on tasks longer than those seen during training (Fan et al., 2024; Cai et al., 2025). Long Context. Much of prior work has focused on improving the maximum context length that can be provided in the input to a language model (Su et al., 2021), and evaluating whether (Tay et al., 2020) and how (Olsson et al., 2022; Li et al., 2023) models maintain performance as the context gets longer (Tay et al., 2020). Closest is the recent RULER (Hsieh et al., 2024) and GSM-Infinite (Zhou et al., 2025b), which also use synthetic data to systematically evaluate long-context abilities. While long-context will help models execute for longer, it is a different capability compared to long-horizon execution (Zhou et al., 2023; Chen et al., 2024a), as it focuses on performance as a function of input, not output length. We identified one such difference, the self-conditioning effect—where past errors in model output increase the chance of future mistakes, and disentangle this effect from long-context degradation in Section ˜ 3.2. Motivated by a similar effect at the token level, termed exposure bias, Ranzato et al. (2015) proposed training language models with RL. Scaling LLMs and RL. Scaling laws for language models show diminishing returns on the loss for the single step of predicting the next token (Kaplan et al., 2020; Hoffmann et al., 2022). When models competed in simple knowledge-based question-answering tasks such as MMLU (Hendrycks et al., 2020), such single-step measurements could inform us about the rate of progress. This has changed in the last year. Where earlier we could only post-train on human demonstrations (Mishra et al., 2021), language models can now be trained with just rewards (Shao et al., 2024), enabling sophisticated reasoning (Guo et al., 2025; Jain et al., 2024) and agents (Kimi Team et al., 2025). This opens up the opportunity to solve much longer tasks where earlier human supervision would be too expensive to scale. Our work shows how diminishing returns on single-step performance can compound to provide large benefits in the length of tasks a model can solve. This motivates the need to study empirical scaling laws for horizon length in agents (Hilton et al., 2023). Tool Use. In symbolic AI, once tasks are formalized, for example, into STRIPS plans (Fikes and Nilsson, 1971), they can be executed without issues. Prior work (Chen et al., 2024b; Valmeekam et al., 2024) has shown LLMs struggle to match symbolic algorithms for automated planning. In contrast, we show LLMs can fail on straightforward execution (Zhu et al., 2025; Sun et al., 2025; Stechly et al., 2024) over a long horizon even when the plan is provided. Teaching LLMs to use tools offers one way to shift the burden of execution from probabilistic models to reliable programs (Schick et al., 2023). However, reasoning is often fuzzy and not always easy to implement as a tool, requiring the model to execute some steps by itself. Even calling the right tools requires reliable execution from the model (Patil et al., 2025). Reliability. While there has been recent interest in evaluations for LLM reliability (Vendrow et al., 2025; Yao et al., 2024), it does not focus on long-horizon outputs, where the context differs every step. For example, Yao et al. (2024) focus on the $pass^{k}$ metric, which checks if the model makes a mistake when we sample $k$ generations. However, this keeps the input fixed, and at 0 temperature (deterministic sampling), becomes equivalent to $pass@1$ . In long-horizon tasks, error compounds irrespective of temperature, as shown in Appendix Figure ˜ 13. 5 Conclusion In this work, we show how short-task benchmarks may give the illusion of slowing progress for modern language models. We show that scaling model size increases the number of turns a model can execute, while sequential test-time compute increases the length of tasks a model can perform on a single turn. Together, these contribute to dramatically increasing horizon lengths for LLMs. Limitations. As with any “synthetic” task (Allen-Zhu, 2024; Poli et al., 2024; Chollet et al., 2024) used for a controlled study of LLM capabilities, there are a few limitations of our setup. It does not reflect complexities and sources of error arising in real agentic tasks with a large number of possible actions. In such settings, the number of actions and the accuracy of each action can both vary based on the plan, requiring more careful consideration. It would be interesting future work to study the self-conditioning effect when doing diverse actions instead of repeating the same ones. Our results are observations about pretrained LLMs, and not inherent properties of transformers, so they might change with task-specific finetuning. Improvement on our task is necessary, but not sufficient for long-horizon execution on real-world tasks. Finally, our current task accuracy metric does not account for self-correction. In tasks where mistakes are acceptable and easy to undo, self-correction is a promising direction to improve long-horizon execution. Outlook. Scaling up the length of tasks a model can complete would be a major step towards realizing the true potential of general, open-ended agents (Raad et al., 2024). If they are trained in simulated environments created with generative models (Bruce et al., 2024), maintaining accuracy over a long-horizon becomes doubly important. By showing long-horizon execution can be studied on simple tasks, we hope to inspire more research on this capability, as it is an increasingly important capability in the era of experience (Silver and Sutton, 2025). Acknowledgements We thank Maksym Andriushchenko, Nikhil Chandak, Paras Chopra, Dulhan Jayalath, Abhinav Menon, Sumeet Motwani, Mathias Niepert, Lluís Pastor Pérez, Ameya Prabhu, Tim Schneider, Shashwat Singh, and Timon Willi for helpful feedback. AA was funded by the CHIPS Joint Undertaking (JU) under grant agreement No. 101140087 (SMARTY), and by the German Federal Ministry of Education and Research (BMBF) under the sub-project with the funding number 16MEE0444. AA thanks the International Max Planck Research School for Intelligent Systems (IMPRS-IS) and the ELLIS PhD programs for support. The authors gratefully acknowledge compute time on the Artificial Intelligence Software Academy (AISA) cluster funded by the Ministry of Science, Research and Arts of Baden-Württemberg. Author Contributions SG conceived the project. AS led the execution of the experiments with the help of AA, while SG led their planning with the help of AA, AS, and JG. SG and AA wrote the paper, while AS worked on the figures. JG and SS advised the project, providing valuable feedback throughout. References - Allen-Zhu [2024] Zeyuan Allen-Zhu. ICML 2024 Tutorial: Physics of Language Models, July 2024. Project page: https://physics.allen-zhu.com/. - Anthropic [2025] Anthropic. System card: Claude Opus 4 & Claude Sonnet 4, May 2025. URL https://www.anthropic.com/claude-4-system-card. Covers Claude Sonnet 4 and Opus 4. - Backlund and Petersson [2025] Axel Backlund and Lukas Petersson. Vending-Bench: A Benchmark for Long-Term Coherence of Autonomous Agents. arxiv:2502.15840[cs], February 2025. doi: 10.48550/arXiv.2502.15840. URL http://arxiv.org/abs/2502.15840. - Becker et al. [2025] Jonas Becker, Lars Benedikt Kaesberg, Andreas Stephan, Jan Philip Wahle, Terry Ruas, and Bela Gipp. Stay Focused: Problem Drift in Multi-Agent Debate. arxiv:2502.19559[cs], May 2025. doi: 10.48550/arXiv.2502.19559. URL http://arxiv.org/abs/2502.19559. - Bruce et al. [2024] Jake Bruce, Michael D Dennis, Ashley Edwards, Jack Parker-Holder, Yuge Shi, Edward Hughes, Matthew Lai, Aditi Mavalankar, Richie Steigerwald, Chris Apps, et al. Genie: Generative interactive environments. In Forty-first International Conference on Machine Learning, 2024. - Cai et al. [2025] Ziyang Cai, Nayoung Lee, Avi Schwarzschild, Samet Oymak, and Dimitris Papailiopoulos. Extrapolation by Association: Length Generalization Transfer in Transformers. arxiv:2506.09251[cs], August 2025. doi: 10.48550/arXiv.2506.09251. URL http://arxiv.org/abs/2506.09251. - Chen et al. [2024a] Siwei Chen, Anxing Xiao, and David Hsu. LLM-State: Open World State Representation for Long-horizon Task Planning with Large Language Model. arxiv:2311.17406[cs], April 2024a. doi: 10.48550/arXiv.2311.17406. URL http://arxiv.org/abs/2311.17406. - Chen et al. [2024b] Yanan Chen, Ali Pesaranghader, Tanmana Sadhu, and Dong Hoon Yi. Can We Rely on LLM Agents to Draft Long-Horizon Plans? Let’s Take TravelPlanner as an Example. arxiv:2408.06318[cs], August 2024b. doi: 10.48550/arXiv.2408.06318. URL http://arxiv.org/abs/2408.06318. - Cheng [2025] Jingde Cheng. Why cannot large language models ever make true correct reasoning?, 2025. URL https://arxiv.org/abs/2508.10265. - Choi et al. [2024] Junhyuk Choi, Yeseon Hong, Minju Kim, and Bugeun Kim. Examining identity drift in conversations of llm agents. arXiv preprint arXiv:2412.00804, 2024. - Chollet et al. [2024] Francois Chollet, Mike Knoop, Gregory Kamradt, and Bryan Landers. Arc prize 2024: Technical report. arXiv preprint arXiv:2412.04604, 2024. - DeepSeek-AI et al. [2025] DeepSeek-AI, Aixin Liu, Bei Feng, et al. Deepseek-v3 technical report, 2025. URL https://arxiv.org/abs/2412.19437. - Dell’Acqua et al. [2023] Fabrizio Dell’Acqua, Edward McFowland III, Ethan R. Mollick, Hila Lifshitz-Assaf, Katherine C. Kellogg, Saran Rajendran, Lisa Krayer, François Candelon, and Karim R. Lakhani. Navigating the jagged technological frontier: Field experimental evidence of the effects of AI on knowledge worker productivity and quality. Working paper, Harvard Business School Technology & Operations Management Unit, 2023. URL https://ssrn.com/abstract=4573321. Also circulated as The Wharton School Research Paper; last revised 2023-09-27. - Fan et al. [2024] Ying Fan, Yilun Du, Kannan Ramchandran, and Kangwook Lee. Looped Transformers for Length Generalization. In The Thirteenth International Conference on Learning Representations, October 2024. URL https://openreview.net/forum?id=2edigk8yoU. - Fikes and Nilsson [1971] Richard E. Fikes and Nils J. Nilsson. Strips: A new approach to the application of theorem proving to problem solving. Artificial Intelligence, 2(3):189–208, December 1971. ISSN 0004-3702. doi: 10.1016/0004-3702(71)90010-5. URL https://www.sciencedirect.com/science/article/pii/0004370271900105. - Gemini Team [2025] Gemini Team. Gemini 2.5: Pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities. Technical report, Google DeepMind, June 2025. URL https://storage.googleapis.com/deepmind-media/gemini/gemini_v2_5_report.pdf. - Gemma-Team et al. [2025] Gemma-Team, Aishwarya Kamath, Johan Ferret, et al. Gemma 3 technical report, 2025. URL https://arxiv.org/abs/2503.19786. - Guo et al. [2025] Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025. - Hendrycks et al. [2020] Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. arXiv preprint arXiv:2009.03300, 2020. - Hilton et al. [2023] Jacob Hilton, Jie Tang, and John Schulman. Scaling laws for single-agent reinforcement learning. arXiv preprint arXiv:2301.13442, 2023. - Hoffmann et al. [2022] Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al. Training compute-optimal large language models. arXiv preprint arXiv:2203.15556, 2022. - Hsieh et al. [2024] Cheng-Ping Hsieh, Simeng Sun, Samuel Kriman, Shantanu Acharya, Dima Rekesh, Fei Jia, and Boris Ginsburg. RULER: What’s the Real Context Size of Your Long-Context Language Models? In First Conference on Language Modeling, August 2024. URL https://openreview.net/forum?id=kIoBbc76Sy. - Jain et al. [2024] Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar-Lezama, Koushik Sen, and Ion Stoica. Livecodebench: Holistic and contamination free evaluation of large language models for code. arXiv preprint arXiv:2403.07974, 2024. - Kambhampati et al. [2024] Subbarao Kambhampati, Karthik Valmeekam, Lin Guan, Mudit Verma, Kaya Stechly, Siddhant Bhambri, Lucas Saldyt, and Anil Murthy. Llms can’t plan, but can help planning in llm-modulo frameworks. arXiv preprint arXiv:2402.01817, 2024. - Kaplan et al. [2020] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models, 2020. URL https://arxiv.org/abs/2001.08361. - Khan et al. [2025] Sheraz Khan, Subha Madhavan, and Kannan Natarajan. A comment on" the illusion of thinking": Reframing the reasoning cliff as an agentic gap. arXiv preprint arXiv:2506.18957, 2025. - Kimi Team et al. [2025] Kimi Team, Yifan Bai, Yiping Bao, Guanduo Chen, Jiahao Chen, Ningxin Chen, Ruijue Chen, Yanru Chen, Yuankun Chen, Yutian Chen, et al. Kimi k2: Open agentic intelligence. arXiv preprint arXiv:2507.20534, 2025. - Kimi-Team et al. [2025] Kimi-Team, Yifan Bai, Yiping Bao, et al. Kimi k2: Open agentic intelligence, 2025. URL https://arxiv.org/abs/2507.20534. - Kwa et al. [2025] Thomas Kwa, Ben West, Joel Becker, Amy Deng, Katharyn Garcia, Max Hasin, Sami Jawhar, Megan Kinniment, Nate Rush, Sydney Von Arx, et al. Measuring ai ability to complete long tasks. arXiv preprint arXiv:2503.14499, 2025. - LeCun [2023] Yann LeCun. Do large language models need sensory grounding for meaning and understanding? Slide deck, NYU Philosophy of Deep Learning debate, March 2023. URL https://drive.google.com/file/d/1BU5bV3X5w65DwSMapKcsr0ZvrMRU_Nbi/view. Includes slide “Autoregressive LLMs are Doomed.”. - Lehmer [1960] Derrick H Lehmer. Teaching combinatorial tricks to a computer. In Proceedings of Symposia in Applied Mathematics, pages 179–193. American Mathematical Society, 1960. - Li et al. [2023] Yingcong Li, Muhammed Emrullah Ildiz, Dimitris Papailiopoulos, and Samet Oymak. Transformers as Algorithms: Generalization and Stability in In-context Learning. In Proceedings of the 40th International Conference on Machine Learning, pages 19565–19594. PMLR, July 2023. URL https://proceedings.mlr.press/v202/li23l.html. - Lindsey et al. [2025] Jack Lindsey, Wes Gurnee, Emmanuel Ameisen, Brian Chen, Adam Pearce, Nicholas L. Turner, Craig Citro, David Abrahams, Shan Carter, Basil Hosmer, Jonathan Marcus, Michael Sklar, Adly Templeton, Trenton Bricken, Callum McDougall, Hoagy Cunningham, Thomas Henighan, Adam Jermyn, Andy Jones, Andrew Persic, Zhenyi Qi, T. Ben Thompson, Sam Zimmerman, Kelley Rivoire, Thomas Conerly, Chris Olah, and Joshua Batson. On the biology of a large language model. Transformer Circuits Thread, 2025. URL https://transformer-circuits.pub/2025/attribution-graphs/biology.html. - Merrill and Sabharwal [2023] William Merrill and Ashish Sabharwal. The expressive power of transformers with chain of thought. arXiv preprint arXiv:2310.07923, 2023. - METR [2025] METR. Measuring ai ability to complete long tasks, March 2025. URL https://metr.org/blog/2025-03-19-measuring-ai-ability-to-complete-long-tasks/. - Mirzadeh et al. [2024] Iman Mirzadeh, Keivan Alizadeh, Hooman Shahrokhi, Oncel Tuzel, Samy Bengio, and Mehrdad Farajtabar. Gsm-symbolic: Understanding the limitations of mathematical reasoning in large language models. arXiv preprint arXiv:2410.05229, 2024. - Mishra et al. [2021] Swaroop Mishra, Daniel Khashabi, Chitta Baral, and Hannaneh Hajishirzi. Cross-task generalization via natural language crowdsourcing instructions. arXiv preprint arXiv:2104.08773, 2021. - Olsson et al. [2022] Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan, Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli, Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris Olah. In-context Learning and Induction Heads. CoRR, January 2022. URL https://openreview.net/forum?id=nJ10GgImU0. - OpenAI [2025] OpenAI. Gpt-5 system card, August 2025. URL https://cdn.openai.com/gpt-5-system-card.pdf. Canonical system card PDF. - Patil et al. [2025] Shishir G Patil, Huanzhi Mao, Fanjia Yan, Charlie Cheng-Jie Ji, Vishnu Suresh, Ion Stoica, and Joseph E Gonzalez. The berkeley function calling leaderboard (bfcl): From tool use to agentic evaluation of large language models. In Forty-second International Conference on Machine Learning, 2025. - Poli et al. [2024] Michael Poli, Armin W. Thomas, Eric Nguyen, Pragaash Ponnusamy, Björn Deiseroth, Kristian Kersting, Taiji Suzuki, Brian Hie, Stefano Ermon, Christopher Re, Ce Zhang, and Stefano Massaroli. Mechanistic Design and Scaling of Hybrid Architectures. In Forty-First International Conference on Machine Learning, June 2024. URL https://openreview.net/forum?id=GDp7Gyd9nf. - Raad et al. [2024] Maria Abi Raad, Arun Ahuja, Catarina Barros, Frederic Besse, Andrew Bolt, Adrian Bolton, Bethanie Brownfield, Gavin Buttimore, Max Cant, Sarah Chakera, et al. Scaling instructable agents across many simulated worlds. arXiv preprint arXiv:2404.10179, 2024. - Ranzato et al. [2015] Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015. - Schick et al. [2023] Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. Advances in Neural Information Processing Systems, 36:68539–68551, 2023. - Shao et al. [2024] Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Yang Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300, 2024. - Shen et al. [2025] Yongliang Shen, Kaitao Song, Xu Tan, Wenqi Zhang, Kan Ren, Siyu Yuan, Weiming Lu, Dongsheng Li, and Yueting Zhuang. TaskBench: Benchmarking large language models for task automation. In Proceedings of the 38th International Conference on Neural Information Processing Systems, volume 37 of NIPS ’24, pages 4540–4574, Red Hook, NY, USA, June 2025. Curran Associates Inc. ISBN 979-8-3313-1438-5. - Shojaee et al. [2025] Parshin Shojaee, Iman Mirzadeh, Keivan Alizadeh, Maxwell Horton, Samy Bengio, and Mehrdad Farajtabar. The illusion of thinking: Understanding the strengths and limitations of reasoning models via the lens of problem complexity, 2025. URL https://arxiv.org/abs/2506.06941. - Silver and Sutton [2025] David Silver and Richard S Sutton. Welcome to the era of experience. Google AI, 1, 2025. - Snell et al. [2024] Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024. - Stechly et al. [2024] Kaya Stechly, Karthik Valmeekam, and Subbarao Kambhampati. Chain of thoughtlessness? an analysis of cot in planning. Advances in Neural Information Processing Systems, 37:29106–29141, 2024. - Su et al. [2021] Jianlin Su, Yu Lu, Shengfeng Pan, Bo Wen, and Yunfeng Liu. Roformer: Enhanced transformer with rotary position embedding, 2021. - Sun et al. [2025] Simeng Sun, Cheng-Ping Hsieh, Faisal Ladhak, Erik Arakelyan, Santiago Akle Serano, and Boris Ginsburg. L0-Reasoning Bench: Evaluating Procedural Correctness in Language Models via Simple Program Execution. arxiv:2503.22832[cs], April 2025. doi: 10.48550/arXiv.2503.22832. URL http://arxiv.org/abs/2503.22832. - Tay et al. [2020] Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long Range Arena : A Benchmark for Efficient Transformers. In International Conference on Learning Representations, October 2020. URL https://openreview.net/forum?id=qVyeW-grC2k. - Valmeekam et al. [2024] Karthik Valmeekam, Kaya Stechly, Atharva Gundawar, and Subbarao Kambhampati. A Systematic Evaluation of the Planning and Scheduling Abilities of the Reasoning Model o1. Transactions on Machine Learning Research, December 2024. ISSN 2835-8856. URL https://openreview.net/forum?id=FkKBxp0FhR. - Vendrow et al. [2025] Joshua Vendrow, Edward Vendrow, Sara Beery, and Aleksander Madry. Do large language model benchmarks test reliability? arXiv preprint arXiv:2502.03461, 2025. - Weiss et al. [2021] Gail Weiss, Yoav Goldberg, and Eran Yahav. Thinking like transformers. In International Conference on Machine Learning, pages 11080–11090. PMLR, 2021. - xAI [2025] xAI. Grok 4 model card, August 2025. URL https://data.x.ai/2025-08-20-grok-4-model-card.pdf. - Xie et al. [2024] Jian Xie, Kai Zhang, Jiangjie Chen, Tinghui Zhu, Renze Lou, Yuandong Tian, Yanghua Xiao, and Yu Su. Travelplanner: A benchmark for real-world planning with language agents, 2024. URL https://arxiv.org/abs/2402.01622. - Yang et al. [2025] An Yang, Anfeng Li, Baosong Yang, et al. Qwen3 technical report, 2025. URL https://arxiv.org/abs/2505.09388. - Yao et al. [2023] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR), 2023. - Yao et al. [2024] Shunyu Yao, Noah Shinn, Pedram Razavi, and Karthik Narasimhan. tau-bench: A benchmark for tool-agent-user interaction in real-world domains. arXiv preprint arXiv:2406.12045, 2024. - Zhou et al. [2023] Haoyu Zhou, Mingyu Ding, Weikun Peng, Masayoshi Tomizuka, Lin Shao, and Chuang Gan. Generalizable Long-Horizon Manipulations with Large Language Models. arxiv:2310.02264[cs], October 2023. doi: 10.48550/arXiv.2310.02264. URL http://arxiv.org/abs/2310.02264. - Zhou et al. [2025a] Yang Zhou, Hongyi Liu, Zhuoming Chen, Yuandong Tian, and Beidi Chen. Gsm-infinite: How do your llms behave over infinitely increasing context length and reasoning complexity? arXiv preprint arXiv:2502.05252, 2025a. - Zhou et al. [2025b] Yang Zhou, Hongyi Liu, Zhuoming Chen, Yuandong Tian, and Beidi Chen. GSM-$\infty$: How Do your LLMs Behave over Infinitely Increasing Reasoning Complexity and Context Length? In Forty-Second International Conference on Machine Learning, June 2025b. URL https://openreview.net/forum?id=n52yyvEwPa. - Zhu et al. [2025] Minjun Zhu, Qiujie Xie, Yixuan Weng, Jian Wu, Zhen Lin, Linyi Yang, and Yue Zhang. AI Scientists Fail Without Strong Implementation Capability. arxiv:2506.01372[cs], June 2025. doi: 10.48550/arXiv.2506.01372. URL http://arxiv.org/abs/2506.01372. Appendix Appendix A Investigating Potential Fixes for Self-conditioning A.1 Turn-wise Self-Verification Prompting We investigate whether the self-conditioning effect can be mitigated by explicitly prompting the model to perform active self-correction. At each turn, we instruct the model to first re-validate its previously reported state and, if required, recalculate the full historical sum before processing the current turn’s keys. The results, shown in Figure 8, are mixed. For the Gemma3 family with CoT, this setup provides an initial boost in accuracy, successfully breaking the self-conditioning loop in early turns. However, the self-verification process significantly increases the number of tokens generated per turn, causing the model to exhaust its context window much sooner, which leads to a sharper performance collapse in later stages. In contrast, the Qwen3 thinking models show negligible improvement. Manually inspecting their reasoning traces, we find that these models, likely due to their fine-tuning, overthink and frequently fail at the verification step itself, sometimes making arithmetic errors even during their re-calculation process. These findings suggest that prompting self-correction may not be a viable solution. It is computationally expensive, incurring a context-length penalty, and is itself a complex, error-prone execution task that models may not be able to perform reliably. <details> <summary>2509.09677v2/x7.png Details</summary>  ### Visual Description # Technical Document Extraction: Multi-Model Performance Analysis ## Chart 1: Qwen3 8B [Thinking] ### Spatial Grounding - **Legend Position**: Bottom center - **Legend Colors**: - Green: With Self-Verification - Blue: Original Run ### Axes - **X-Axis**: Task Length (0–250) - **Y-Axis**: Turn Accuracy (0.0–1.0) ### Key Trends 1. **With Self-Verification (Green)**: - Initial sharp decline from ~0.98 to ~0.6 at Task Length 50 - Volatile fluctuations between 0.5–0.75 until Task Length 200 - Final plateau at ~0.6 2. **Original Run (Blue)**: - Gradual decline from ~0.95 to ~0.55 at Task Length 100 - Recovery to ~0.7 at Task Length 150 - Final drop to ~0.6 at Task Length 250 ### Data Points - **With Self-Verification**: - Task Length 0: 0.98 - Task Length 50: 0.6 - Task Length 100: 0.65 - Task Length 200: 0.6 - Task Length 250: 0.6 - **Original Run**: - Task Length 0: 0.95 - Task Length 50: 0.85 - Task Length 100: 0.55 - Task Length 150: 0.7 - Task Length 250: 0.6 --- ## Chart 2: Gemma3 12B [CoT] ### Spatial Grounding - **Legend Position**: Bottom center - **Legend Colors**: - Green: With Self-Verification - Blue: Original Run ### Axes - **X-Axis**: Task Length (0–250) - **Y-Axis**: Turn Accuracy (0.0–1.0) ### Key Trends 1. **With Self-Verification (Green)**: - Starts at 0.98, drops to 0.8 at Task Length 50 - Sharp decline to 0.2 at Task Length 200 - Final collapse to 0.0 at Task Length 250 2. **Original Run (Blue)**: - Steady rise from 0.4 to 0.85 at Task Length 150 - Plateaus at ~0.85 until Task Length 250 ### Data Points - **With Self-Verification**: - Task Length 0: 0.98 - Task Length 50: 0.8 - Task Length 100: 0.75 - Task Length 150: 0.8 - Task Length 200: 0.2 - Task Length 250: 0.0 - **Original Run**: - Task Length 0: 0.4 - Task Length 50: 0.5 - Task Length 100: 0.7 - Task Length 150: 0.85 - Task Length 200: 0.85 - Task Length 250: 0.85 --- ## Chart 3: Gemma3 12B [CoT] (Token Generation) ### Spatial Grounding - **Legend Position**: Bottom center - **Legend Colors**: - Green: With Self-Verification - Blue: Original Run ### Axes - **X-Axis**: Task Length (0–250) - **Y-Axis**: Avg. Tokens Generated per Step (0–1400) ### Key Trends 1. **With Self-Verification (Green)**: - Starts at 600 tokens - Peaks at 1200 tokens at Task Length 150 - Catastrophic drop to 0 at Task Length 200 2. **Original Run (Blue)**: - Stable at ~400 tokens until Task Length 200 - Minor fluctuations (380–420) post-200 ### Data Points - **With Self-Verification**: - Task Length 0: 600 - Task Length 50: 800 - Task Length 100: 1000 - Task Length 150: 1200 - Task Length 200: 0 - Task Length 250: 0 - **Original Run**: - Task Length 0: 400 - Task Length 50: 400 - Task Length 100: 400 - Task Length 150: 400 - Task Length 200: 400 - Task Length 250: 400 --- ## Cross-Chart Observations 1. **Self-Verification Impact**: - Qwen3 8B: Moderate accuracy retention (60% baseline) - Gemma3 12B: Complete failure at Task Length 200+ 2. **Token Efficiency**: - Self-Verification correlates with exponential token growth (Chart 3) 3. **Model Scaling**: - Larger models (Gemma3 12B) show more pronounced instability with self-verification ## Critical Anomalies - **Chart 2 Green Line**: Abrupt 0.8→0.2 drop at Task Length 200 (potential data truncation?) - **Chart 3 Green Line**: 1200→0 token collapse at Task Length 200 (systemic failure point) ## Language Note All text is in English. No non-English content detected. </details> Figure 8: Self-verification does not fix self-conditioning. Prompting to self-verify does not suffice to fix the self-conditioning effect completely. It leads to overthinking in thinking models and increases the amount of tokens required per turn, leading to faster context consumption in CoT models. A.2 Context Engineering Another natural mitigation strategy is to limit the model’s exposure to its own past errors in its history. We operationalize this using a simple sliding context window, which is particularly well-suited for Markovian tasks like ours. This approach maintains only the $N$ most recent turns in the model’s context. The rationale is that a smaller context window reduces the probability of the model observing a lot of its own past failures, thereby breaking the negative feedback loop of self-conditioning. As shown in Figure ˜ 9 (a), performance improves significantly as the context window size is reduced, allowing models to sustain execution for longer horizons. While a fixed sliding window is only applicable to tasks without long-range dependencies, this result validates a more general principle: active context management designed to minimize the accumulation of errors in the context is a promising direction for improving long-horizon reliability in LLM agents. <details> <summary>2509.09677v2/x8.png Details</summary>  ### Visual Description # Technical Document Extraction: Line Chart Analysis ## Chart Overview - **Type**: Line chart with three data series - **Purpose**: Visualizes "Turn Accuracy" across varying "Task Length" for different experimental conditions ## Axis Labels & Markers - **X-axis**: - Title: "Task Length" - Range: 0 to 200 - Increment: 25 units - Markers: Numerical ticks at 0, 25, 50, 75, 100, 125, 150, 175, 200 - **Y-axis**: - Title: "Turn Accuracy" - Range: 0.0 to 1.0 - Increment: 0.2 units - Markers: Numerical ticks at 0.0, 0.2, 0.4, 0.6, 0.8, 1.0 ## Legend - **Position**: Bottom-left quadrant - **Entries**: 1. **Blue**: Original Run 2. **Orange**: Context Size=1 Turn 3. **Green**: Context Size=25 Turns ## Data Series Analysis ### 1. Original Run (Blue) - **Trend**: - Initial peak at ~0.75 (Task Length 0) - Sharp decline to ~0.4 by Task Length 50 - Stabilizes with minor fluctuations between 0.35-0.45 - **Key Data Points**: - Task Length 0: ~0.75 - Task Length 25: ~0.7 - Task Length 50: ~0.4 - Task Length 100: ~0.4 - Task Length 200: ~0.38 ### 2. Context Size=1 Turn (Orange) - **Trend**: - Initial dip to ~0.65 at Task Length 25 - Stabilizes with minor oscillations between 0.65-0.7 - **Key Data Points**: - Task Length 0: ~0.7 - Task Length 25: ~0.65 - Task Length 50: ~0.68 - Task Length 100: ~0.67 - Task Length 200: ~0.69 ### 3. Context Size=25 Turns (Green) - **Trend**: - Initial dip to ~0.65 at Task Length 25 - Stabilizes with minor oscillations between 0.7-0.75 - **Key Data Points**: - Task Length 0: ~0.75 - Task Length 25: ~0.65 - Task Length 50: ~0.72 - Task Length 100: ~0.73 - Task Length 200: ~0.74 ## Cross-Reference Verification - **Color Consistency**: - Blue line matches "Original Run" legend entry - Orange line matches "Context Size=1 Turn" - Green line matches "Context Size=25 Turns" - **Legend Placement**: Confirmed at bottom-left quadrant ## Spatial Grounding - **Legend Coordinates**: - X: ~25 (aligned with Task Length 25 marker) - Y: ~0.2 (below Y-axis baseline) ## Language & Textual Content - **Primary Language**: English - **Transcribed Text**: - Axis Titles: "Task Length", "Turn Accuracy" - Legend Labels: "Original Run", "Context Size=1 Turn", "Context Size=25 Turns" ## Conclusion The chart demonstrates that increasing context size (25 turns vs. 1 turn) maintains higher turn accuracy across task lengths compared to the original run. All data series show stabilization after initial fluctuations, with the Original Run experiencing the most significant performance degradation. </details> (a) Context Engineering <details> <summary>2509.09677v2/x9.png Details</summary>  ### Visual Description # Technical Document Extraction: Line Graph Analysis ## 1. **Axis Labels and Markers** - **X-Axis (Horizontal):** - Title: `Task Length` - Markers: `0`, `5`, `10`, `15`, `20`, `25` - Scale: Linear, incrementing by 5 units. - **Y-Axis (Vertical):** - Title: `Task Accuracy` - Scale: Linear, ranging from `0.0` to `1.0` in increments of `0.2`. --- ## 2. **Legend and Data Series** - **Legend Placement:** Bottom center of the graph. - **Data Series:** - **Majority Vote (N=10):** - Color: Gray (`#808080`). - Line Style: Solid. - **Original Run:** - Color: Blue (`#0000FF`). - Line Style: Solid. --- ## 3. **Key Trends and Data Points** ### **Majority Vote (N=10)** - **Trend:** Gradual decline from high to near-zero accuracy as task length increases. - **Data Points (approximate):** - `Task Length = 0`: `0.82` - `Task Length = 5`: `0.30` - `Task Length = 10`: `0.10` - `Task Length = 15`: `0.04` - `Task Length = 20`: `0.02` - `Task Length = 25`: `0.00` ### **Original Run** - **Trend:** Steeper decline compared to Majority Vote, reaching near-zero accuracy faster. - **Data Points (approximate):** - `Task Length = 0`: `0.70` - `Task Length = 5`: `0.25` - `Task Length = 10`: `0.05` - `Task Length = 15`: `0.02` - `Task Length = 20`: `0.01` - `Task Length = 25`: `0.00` --- ## 4. **Visual Observations** - Both lines exhibit **monotonic decay** (no upward trends). - **Original Run** consistently underperforms **Majority Vote (N=10)** across all task lengths. - **Convergence:** Both lines approach `0.0` accuracy at `Task Length = 25`. --- ## 5. **Component Isolation** - **Main Chart:** Occupies the majority of the image. - **Legend:** Positioned at the bottom, clearly distinguishing the two data series. - **No Additional Elements:** No headers, footers, or embedded text beyond axis labels and legend. --- ## 6. **Language and Textual Content** - **Language:** English (no non-English text detected). - **Transcribed Text:** - Axis titles: `Task Length`, `Task Accuracy`. - Legend labels: `Majority Vote (N=10)`, `Original Run`. --- ## 7. **Spatial Grounding** - **Legend Coordinates:** Bottom center (exact placement unspecified, but visually centered). - **Data Point Color Verification:** - Gray line matches `Majority Vote (N=10)`. - Blue line matches `Original Run`. --- ## 8. **Conclusion** The graph compares the performance of two methods (`Majority Vote` and `Original Run`) across increasing task lengths. Both methods show declining accuracy, but `Majority Vote (N=10)` maintains higher accuracy for longer task lengths. No additional textual or tabular data is present in the image. </details> (b) Majority Voting Figure 9: Context engineering and majority voting on Gemma3 12B. Controlling context size reduces the self-conditioning effect, but relies on the Markovian nature of our task. Majority voting at K=1 provides only minimal improvements over the baseline. Appendix B Can Parallel Test-time Compute Scaling Match Thinking? <details> <summary>2509.09677v2/x10.png Details</summary>  ### Visual Description # Technical Document Extraction: Task Accuracy Analysis ## Image Description The image is a line graph titled **"Task Accuracy vs Task Length"**, comparing the performance of two methods: **Majority Vote [No CoT]** and **Chain of Thought Enabled**. The graph uses a grid background with dashed lines for reference. --- ### **Key Components** 1. **Axes**: - **X-axis (Task Length)**: - Labeled "Task Length". - Markers at `0`, `100`, and `200`. - Range: `0` to `200`. - **Y-axis (Task Accuracy)**: - Labeled "Task Accuracy". - Markers at `0.0`, `0.2`, `0.4`, `0.6`, `0.8`, and `1.0`. - Range: `0.0` to `1.0`. 2. **Legend**: - Located at the bottom of the graph. - **Colors**: - `Gray`: Majority Vote [No CoT] (N=100). - `Blue`: Chain of Thought Enabled. 3. **Data Series**: - **Blue Line (Chain of Thought Enabled)**: - Starts at `1.0` task accuracy at `Task Length = 0`. - Gradually declines to approximately `0.75` at `Task Length = 200`. - Trend: **Steady downward slope** with minor fluctuations. - **Gray Line (Majority Vote [No CoT])**: - Starts at `0.2` task accuracy at `Task Length = 0`. - Remains constant at `0.2` for all subsequent task lengths. - Trend: **Immediate and sustained drop** to a low value. --- ### **Trend Verification** - **Blue Line (Chain of Thought Enabled)**: - Visual trend: Slopes downward gradually. - Data points (approximate): - `Task Length = 0`: `1.0` - `Task Length = 100`: `0.85` - `Task Length = 200`: `0.75` - **Gray Line (Majority Vote [No CoT])**: - Visual trend: Sharp drop to `0.2` at `Task Length = 0`, then flat. - Data points: - `Task Length = 0`: `0.2` - `Task Length = 100`: `0.2` - `Task Length = 200`: `0.2` --- ### **Spatial Grounding** - **Legend Position**: Bottom-center of the graph. - **Line Colors**: - Blue (`Chain of Thought Enabled`) matches the blue line. - Gray (`Majority Vote [No CoT]`) matches the gray line. --- ### **Additional Observations** - The graph includes a grid with dashed lines for reference. - No other textual or numerical data is present in the image. - The blue line consistently outperforms the gray line across all task lengths. --- ### **Conclusion** The graph demonstrates that **Chain of Thought Enabled** maintains significantly higher task accuracy compared to **Majority Vote [No CoT]**, which experiences a drastic and sustained decline in performance. The blue line (Chain of Thought) retains ~75% accuracy at maximum task length, while the gray line (Majority Vote) remains at ~20%. </details> Figure 10: Parallel test time scaling on Gemma3 12B at K=2. Majority voting with the same amount of tokens as CoT traces does not match the performance of CoT. We also experiment to validate if parallel scaling in test-time compute can achieve the same improvements as thinking. We verify this by testing if parallel majority voting can replicate the gains from either model scale or sequential computation (thinking). To create a fair comparison, we sample multiple outputs from a non-thinking Gemma3 model at each turn, with the number of samples set to match the average token count of its CoT counterpart. The final answer is determined by a majority vote over these parallel generations. From the results in Figure ˜ 10 and 9 (b), we see that while majority voting yields a marginal performance improvement over the base model, it is insufficient to match the reliability of a larger, non-thinking model, let alone the substantial gains from using CoT reasoning. This suggests that for long-horizon execution, sequential computation provides an advantage that parallel test time scaling cannot match. This contrasts with findings in other domains, such as math or common-sense reasoning, where parallel sampling with self-consistency has been shown to be highly competitive (Snell et al., 2024). Appendix C Number of Turns vs Turn Complexity In our experiments, we show that we can increase the length of the task needed to be performed by either (1) increasing the number of turns or (2) increasing the turn complexity, i.e, providing more inputs in the same turn. To investigate the relationship between these two axes, we perform an experiment where a model has to perform a fixed number of operations while varying the turn complexity. With a higher turn complexity, the model requires fewer turns to reach the fixed number of operations. Results in Figure ˜ 11 (a) indicate there is no strict turn complexity that is consistently the best across model families. Rather, we found that different models behave quite differently for the same turn complexities. Qwen3 32B seems to show poorer performance at lower turn complexities, indicating that it is unable to perform well over a large number of turns, even if the turns are simple themselves. Gemma3 12B shows a different trend. It reaches accuracy peaks at either extreme of the turn complexity spectrum, failing badly at mid-level turn complexities. This indicates it suffers when the turn complexity and the number of turns are both sufficiently high. Another axis of evaluating the number of turns vs turn complexity trade-off is the test-time compute used. From a cost perspective, increasing the number of turns increases the overall cost of inference. We can lower the number of turns by increasing the turn complexity, but that would result in an increase in the per-turn inference cost, as a result of the added complexity. For the same experiment above, we track the number of output tokens used for computation (including thinking tokens) per sample, and again find diverging results for each family in Figure ˜ 11 (b). <details> <summary>2509.09677v2/x11.png Details</summary>  ### Visual Description # Technical Document Extraction: Bar Charts for Qwen3 32B and Gemma3 12B ## Chart 1: Qwen3 32B ### Labels and Axis Titles - **X-Axis**: "Turn Complexity" with values: 3, 4, 5, 6, 9, 10, 12, 15, 18, 20, 30, 36, 45, 60, 90, 180 - **Y-Axis**: "Task Accuracy After 180 Steps" (range: 0.0 to 1.0) - **Legend**: Located on the right side of the chart. Colors: - **Orange**: 180 Steps - **Green**: 120 Steps ### Data Points and Trends - **Orange Bars (180 Steps)**: - **Trend**: General increase in accuracy with higher complexity, peaking at 90 (0.780) and dropping at 180 (0.550). - **Values**: - 3: 0.250 - 4: 0.350 - 5: 0.100 - 6: 0.400 - 9: 0.400 - 10: 0.200 - 12: 0.350 - 15: 0.450 - 18: 0.450 - 20: 0.300 - 30: 0.400 - 36: 0.400 - 45: 0.400 - 60: 0.650 - 90: 0.780 - 180: 0.550 - **Green Bars (120 Steps)**: - **Trend**: Consistent increase in accuracy with higher complexity. - **Values**: - 3: 0.250 - 4: 0.350 - 5: 0.100 - 6: 0.400 - 9: 0.400 - 10: 0.200 - 12: 0.350 - 15: 0.450 - 18: 0.450 - 20: 0.300 - 30: 0.400 - 36: 0.400 - 45: 0.400 - 60: 0.650 - 90: 0.780 - 180: 0.550 ## Chart 2: Gemma3 12B ### Labels and Axis Titles - **X-Axis**: "Turn Complexity" with values: 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 - **Y-Axis**: "Task Accuracy After 120 Steps" (range: 0.0 to 1.0) - **Legend**: Located on the right side of the chart. Colors: - **Green**: 120 Steps - **Orange**: 180 Steps ### Data Points and Trends - **Green Bars (120 Steps)**: - **Trend**: High accuracy at lower complexities, peaking at 1 (1.000) and decreasing with higher complexity. - **Values**: - 1: 1.000 - 2: 0.890 - 3: 0.780 - 4: 0.390 - 5: 0.160 - 6: 0.080 - 8: 0.060 - 10: 0.100 - 12: 0.140 - 15: 0.200 - 20: 0.500 - 24: 0.640 - 30: 0.500 - 40: 0.640 - 60: 0.620 - 120: 0.200 - **Orange Bars (180 Steps)**: - **Trend**: Lower accuracy overall, with a peak at 20 (0.500) and a drop at 120 (0.200). - **Values**: - 1: 1.000 - 2: 0.890 - 3: 0.780 - 4: 0.390 - 5: 0.160 - 6: 0.080 - 8: 0.060 - 10: 0.100 - 12: 0.140 - 15: 0.200 - 20: 0.500 - 24: 0.640 - 30: 0.500 - 40: 0.640 - 60: 0.620 - 120: 0.200 ## Notes - **Language**: All text is in English. - **Color Consistency**: - Qwen3: Orange = 180 Steps, Green = 120 Steps. - Gemma3: Green = 120 Steps, Orange = 180 Steps. - **Data Extraction**: All values are transcribed directly from the bars, with spatial grounding confirmed via legend alignment. </details> (a) For the same number of total steps, different turn complexities lead to different outcomes. We find no trend across families. <details> <summary>2509.09677v2/x12.png Details</summary>  ### Visual Description # Technical Document Extraction: Scatter Plots for Qwen3 32B and Gemma3 12B ## Image Description The image contains two scatter plots comparing **Final Task Accuracy** against **Average Output Tokens** for two language models: **Qwen3 32B** (left) and **Gemma3 12B** (right). Each plot uses color-coded data points to represent different experimental configurations, with numerical labels indicating specific metrics (e.g., steps, accuracy values). --- ## Key Components ### 1. **Axis Labels and Titles** - **Left Plot (Qwen3 32B):** - **X-axis**: "Average Output Tokens" (range: 0 to 60,000) - **Y-axis**: "Final Task Accuracy after 180 steps" (range: 0.0 to 1.0) - **Title**: "Qwen3 32B" - **Right Plot (Gemma3 12B):** - **X-axis**: "Average Output Tokens" (range: 0 to 25,000) - **Y-axis**: "Final Task Accuracy after 120 steps" (range: 0.0 to 1.0) - **Title**: "Gemma3 12B" --- ### 2. **Legend and Data Points** #### **Qwen3 32B (Left Plot)** - **Legend**: Located on the left side of the plot. Colors correspond to numerical labels (steps or accuracy values): - **Purple**: 180 steps - **Blue**: 120 steps - **Green**: 60 steps - **Yellow**: 30 steps - **Teal**: 20 steps - **Dark Blue**: 10 steps - **Data Points**: - **Purple (180 steps)**: - [10,000 tokens, 0.55 accuracy] - [12,000 tokens, 0.60 accuracy] - [15,000 tokens, 0.45 accuracy] - **Blue (120 steps)**: - [15,000 tokens, 0.40 accuracy] - [18,000 tokens, 0.35 accuracy] - **Green (60 steps)**: - [20,000 tokens, 0.45 accuracy] - [25,000 tokens, 0.30 accuracy] - **Yellow (30 steps)**: - [30,000 tokens, 0.20 accuracy] - [40,000 tokens, 0.10 accuracy] - **Teal (20 steps)**: - [20,000 tokens, 0.35 accuracy] - [25,000 tokens, 0.12 accuracy] - **Dark Blue (10 steps)**: - [30,000 tokens, 0.20 accuracy] #### **Gemma3 12B (Right Plot)** - **Legend**: Located on the right side of the plot. Colors correspond to numerical labels (steps or accuracy values): - **Yellow**: 1 step - **Green**: 2 steps - **Blue**: 3 steps - **Purple**: 4 steps - **Dark Blue**: 5 steps - **Teal**: 6 steps - **Light Blue**: 8 steps - **Dark Green**: 10 steps - **Light Yellow**: 12 steps - **Dark Purple**: 15 steps - **Dark Teal**: 20 steps - **Dark Green**: 24 steps - **Dark Blue**: 30 steps - **Purple**: 40 steps - **Yellow**: 120 steps - **Data Points**: - **Yellow (1 step)**: - [14,000 tokens, 1.0 accuracy] - **Green (2 steps)**: - [16,000 tokens, 0.90 accuracy] - **Blue (3 steps)**: - [18,000 tokens, 0.85 accuracy] - **Purple (4 steps)**: - [15,000 tokens, 0.60 accuracy] - **Dark Blue (5 steps)**: - [20,000 tokens, 0.55 accuracy] - **Teal (6 steps)**: - [22,000 tokens, 0.40 accuracy] - **Light Blue (8 steps)**: - [24,000 tokens, 0.25 accuracy] - **Dark Green (10 steps)**: - [25,000 tokens, 0.15 accuracy] - **Light Yellow (12 steps)**: - [14,000 tokens, 0.20 accuracy] - **Dark Purple (15 steps)**: - [16,000 tokens, 0.30 accuracy] - **Dark Teal (20 steps)**: - [18,000 tokens, 0.60 accuracy] - **Dark Green (24 steps)**: - [20,000 tokens, 0.50 accuracy] - **Dark Blue (30 steps)**: - [22,000 tokens, 0.40 accuracy] - **Purple (40 steps)**: - [24,000 tokens, 0.30 accuracy] - **Yellow (120 steps)**: - [14,000 tokens, 0.20 accuracy] --- ## Trends and Observations ### **Qwen3 32B** - **Accuracy vs. Tokens**: - Higher token counts (e.g., 30k–60k) generally correlate with lower accuracy, especially for configurations with fewer steps (e.g., 10–30 steps). - Configurations with more steps (e.g., 180 steps) show moderate accuracy (0.45–0.60) at lower token counts (10k–15k). - **Notable Outlier**: A purple point at 15k tokens with 0.60 accuracy (180 steps) stands out as a high-performing configuration. ### **Gemma3 12B** - **Accuracy vs. Tokens**: - Accuracy decreases as token counts increase, particularly for configurations with fewer steps (e.g., 1–10 steps). - Configurations with more steps (e.g., 20–40 steps) maintain higher accuracy (0.40–0.60) across token ranges. - **Notable Outlier**: A yellow point at 14k tokens with 1.0 accuracy (1 step) indicates perfect performance for a minimal configuration. --- ## Spatial Grounding and Color Matching - **Qwen3 32B Legend**: - Position: Left side of the plot. - Color-to-label mapping confirmed for all data points (e.g., purple = 180 steps). - **Gemma3 12B Legend**: - Position: Right side of the plot. - Color-to-label mapping confirmed for all data points (e.g., yellow = 1 step). --- ## Final Notes - No non-English text or additional languages are present. - All data points and labels are explicitly transcribed, with trends verified against visual patterns. - The plots emphasize the trade-off between **output token count** and **task accuracy**, with step count acting as a critical variable. </details> (b) Average output tokens used to complete the execution vs final accuracy. We see that for Qwen3 32B, more turns lead to more token usage, even at lower turn complexities, pointing to overthinking. Gemma3 12B, on the other hand, uses fewer tokens for very low turn complexity or very high turn complexity. Figure 11: Relation between the turn complexity and the number of turns. <details> <summary>2509.09677v2/x13.png Details</summary>  ### Visual Description # Technical Document Extraction: Task Accuracy Analysis ## Chart (a) *Thinking Disabled* K=2 - **Title**: *Thinking Disabled* K=2 - **X-axis**: Task Length (2–6) - **Y-axis**: Task Accuracy (0.0–0.5) - **Legend**: Bottom-left - **Colors/Labels**: - Light orange: Gemma3-4B - Orange: Gemma3-12B - Dark red: Gemma3-27B - Light blue: Qwen3-4B - **Trends**: - All lines slope downward as task length increases. - Gemma3-27B starts highest (0.45 at task length 2), Qwen3-4B lowest (0.15 at task length 2). - Lines converge near task length 6 (all ~0.05 accuracy). ## Chart (b) *Thinking Enabled* - **Title**: *Thinking Enabled* - **X-axis**: Task Length (0–200) - **Y-axis**: Task Accuracy (0.0–1.0) - **Legend**: Bottom-left - **Colors/Labels**: - Light orange: Gemma3-4B - Orange: Gemma3-12B - Dark red: Gemma3-27B - Light blue: Qwen3-4B - Blue: Qwen3-8B - Teal: Qwen3-14B - Dark blue: Qwen3-32B - **Trends**: - All lines decline with increasing task length. - Gemma3-27B starts highest (0.95 at task length 0), Qwen3-32B lowest (0.75 at task length 0). - Qwen3-32B plateaus near 0.6 at task length 200; Gemma3-27B drops to ~0.3. ## Chart (c) *Thinking Enabled* K=10 - **Title**: *Thinking Enabled* K=10 - **X-axis**: Task Length (0–600) - **Y-axis**: Task Accuracy (0.0–1.0) - **Legend**: Bottom-left - **Colors/Labels**: - Light orange: Gemma3-4B - Orange: Gemma3-12B - Dark red: Gemma3-27B - Light blue: Qwen3-4B - Blue: Qwen3-8B - Teal: Qwen3-14B - Dark blue: Qwen3-32B - **Trends**: - Steeper decline for Gemma3 models vs. Qwen3. - Qwen3-32B maintains ~0.5 accuracy at task length 600; Gemma3-27B drops to ~0.1. ## Chart (d) Model Size vs. Horizon Length - **Title**: *Thinking Enabled* - **X-axis**: Model Size (Billion Parameters) (10–30B) - **Y-axis**: Horizon Length (0–125) - **Legend**: Bottom-right - **Colors/Labels**: - Red: Gemma3 - Blue: Qwen3 - **Trends**: - Qwen3 models show linear increase in horizon length with model size (e.g., 40 → 120 as size increases from 10B to 32B). - Gemma3 models remain flat (~10 horizon length across all sizes). ## Key Observations 1. **Model Performance**: - Larger models (e.g., Gemma3-27B, Qwen3-32B) generally outperform smaller variants in task accuracy. - Qwen3 models exhibit better scalability in horizon length with increased model size. 2. **Task Complexity**: - Task accuracy degrades significantly with longer task lengths, especially under "Thinking Disabled" conditions. - Enabling thinking (K=2, K=10) mitigates accuracy loss but does not eliminate it entirely. 3. **Efficiency Trade-offs**: - Qwen3 models achieve higher horizon lengths at comparable computational costs (model size) compared to Gemma3. ## Notes - All charts use line plots except (d), which uses scatter points. - No non-English text detected. - Spatial grounding confirms legend placement matches visual alignment in all charts. </details> Figure 12: Scaling trends hold even after enabling Sequential Test Time compute. We compare model performance with thinking disabled (a) against thinking enabled (b, c) at varying turn complexities. (a) Without thinking, all models fail to execute even two steps ( $K=2$ ) in a single turn. (b) In contrast, enabling thinking prevents this performance collapse, with all models successfully handling $K=2$ . (c) When the turn complexity is further increased to $K=10$ , performance degrades, but a clear scaling trend emerges. (d) This trend is explicitly shown, illustrating that for complex turns, the horizon length increases consistently with model size, reinforcing the benefits of scaling model size even when thinking is enabled. <details> <summary>2509.09677v2/x14.png Details</summary>  ### Visual Description # Technical Document Extraction: Model Accuracy Analysis ## Chart 1: Step Accuracy vs. Task Length ### Axes and Labels - **X-axis**: Task Length (0 to 100) - **Y-axis**: Step Accuracy (0.0 to 1.0) - **Title**: Step Accuracy ### Legend - **Gemma3-4B**: Light orange - **Gemma3-12B**: Orange - **Gemma3-27B**: Red - **Qwen3-4B**: Light blue ### Key Trends 1. **Gemma3-4B** (light orange): - Starts at ~0.8 accuracy, declines steadily to ~0.2 by Task Length 100. - Slope: Gradual decline. 2. **Gemma3-12B** (orange): - Starts at ~0.9, declines to ~0.4 by Task Length 100. - Slope: Moderate decline. 3. **Gemma3-27B** (red): - Starts at ~0.95, declines to ~0.5 by Task Length 100. - Slope: Steeper decline than 12B. 4. **Qwen3-4B** (light blue): - Starts at ~0.7, declines to ~0.1 by Task Length 100. - Slope: Sharpest decline among all models. ## Chart 2: Task Accuracy vs. Task Length ### Axes and Labels - **X-axis**: Task Length (0 to 40) - **Y-axis**: Task Accuracy (0.0 to 1.0) - **Title**: Task Accuracy ### Legend - **Qwen3-8B**: Light blue - **Qwen3-14B**: Blue - **Qwen3-32B**: Dark blue - **Gemma3-4B**: Light orange ### Key Trends 1. **Qwen3-8B** (light blue): - Starts at ~0.95, drops to ~0.3 by Task Length 40. - Slope: Steep decline. 2. **Qwen3-14B** (blue): - Starts at ~0.9, drops to ~0.2 by Task Length 40. - Slope: Moderate decline. 3. **Qwen3-32B** (dark blue): - Starts at ~0.85, drops to ~0.1 by Task Length 40. - Slope: Steepest decline. 4. **Gemma3-4B** (light orange): - Starts at ~0.95, drops to ~0.05 by Task Length 40. - Slope: Gradual decline. ## Spatial Grounding - **Legend Placement**: Bottom of each chart. - **Color Consistency**: - Left Chart: Light orange (Gemma3-4B) matches light orange lines. - Right Chart: Light orange (Gemma3-4B) matches light orange lines. ## Component Isolation - **Left Chart**: Focuses on step accuracy across longer task lengths (0–100). - **Right Chart**: Focuses on task accuracy across shorter task lengths (0–40). ## Observations - **Model Performance**: - Larger models (e.g., Gemma3-27B, Qwen3-32B) maintain higher accuracy longer but decline sharply. - Smaller models (e.g., Qwen3-4B, Gemma3-4B) degrade faster but retain some accuracy at longer task lengths. - **Task Length Impact**: - Accuracy degrades non-linearly as task length increases. - Qwen3 models exhibit steeper declines compared to Gemma3 models. ## Data Extraction ### Left Chart Data Points (Approximate) | Model | Task Length 0 | Task Length 25 | Task Length 50 | Task Length 75 | Task Length 100 | |---------------|---------------|----------------|----------------|----------------|-----------------| | Gemma3-4B | 0.8 | 0.6 | 0.4 | 0.2 | 0.1 | | Gemma3-12B | 0.9 | 0.7 | 0.5 | 0.3 | 0.2 | | Gemma3-27B | 0.95 | 0.8 | 0.6 | 0.4 | 0.3 | | Qwen3-4B | 0.7 | 0.5 | 0.3 | 0.1 | 0.05 | ### Right Chart Data Points (Approximate) | Model | Task Length 0 | Task Length 10 | Task Length 20 | Task Length 30 | Task Length 40 | |---------------|---------------|----------------|----------------|----------------|----------------| | Qwen3-8B | 0.95 | 0.7 | 0.4 | 0.2 | 0.1 | | Qwen3-14B | 0.9 | 0.6 | 0.3 | 0.15 | 0.05 | | Qwen3-32B | 0.85 | 0.5 | 0.2 | 0.08 | 0.02 | | Gemma3-4B | 0.95 | 0.75 | 0.5 | 0.25 | 0.05 | ## Notes - All values are approximate due to visual interpretation of the chart. - No non-English text detected. </details> Figure 13: Temperature does not impact the trends observed. We reproduce the same trends in Figure ˜ 4, when running with temperature 0. Appendix D Deconstructing Errors in Retrieve-then-compose Steps To further isolate the source of execution errors, we decompose our task into its two constituent operations–retrieval and addition–and evaluate models on them individually: - Retrieval-Only Task. A stateless task where, at each turn, the model is given a key and must simply return the corresponding integer value from the dictionary. No running sum is maintained. This isolates the retrieval component. - Addition-Only Task. A stateless task where, at each turn, the model is given two random integers to add. No running sum is maintained. This isolates the arithmetic component. - Prefix-sum Task. A stateful task where, at each turn, the model is given an integer directly and must add it to its previously reported running sum. This isolates the combination of arithmetic and state-tracking components. From Figure ˜ 14, we can observe that models achieve near-perfect performance on the stateless retrieval and addition task, indicating that neither simple dictionary lookup nor addition is a significant source of error. In contrast, the prefix sum task, while significantly better than our task, still exhibits a slow degradation over time. This leads to two key insights. First, the difficulty lies not in the atomic operations themselves, which models perform with high accuracy in isolation over long horizons. Second, this suggests that the primary source of degradation is the state-management component of the task. While stateless retrieval and addition are trivial, the requirement to reliably maintain and update a running sum introduces higher chances of error. This suggests that the models struggle with the requirement to concurrently manage information lookup and state updates. <details> <summary>2509.09677v2/x15.png Details</summary>  ### Visual Description # Technical Document Extraction: Turn Accuracy Analysis ## Image Description The image is a **line graph** titled **"Turn Accuracy"**, comparing the performance of two models across varying task lengths. The graph includes two data series, axis labels, a legend, and numerical markers. --- ## Key Components ### 1. **Axes and Labels** - **X-Axis**: - **Title**: `Task Length` - **Range**: `0` to `1000` - **Markers**: `0`, `200`, `400`, `600`, `800`, `1000` - **Y-Axis**: - **Title**: `Turn Accuracy` - **Range**: `0.00` to `1.00` - **Markers**: `0.00`, `0.25`, `0.50`, `0.75`, `1.00` ### 2. **Legend** - **Placement**: Bottom of the graph - **Labels**: - `Gemma3-27b` (Red line) - `Qwen3-32b` (Blue line) ### 3. **Data Series** #### **Gemma3-27b (Red Line)** - **Trend**: - Starts at approximately `0.95` turn accuracy at `Task Length = 0`. - Declines steadily, reaching `~0.10` at `Task Length = 1000`. - Data points exhibit increasing variability (error bars) as task length increases. - **Key Data Points**: - `Task Length = 0`: `0.95` - `Task Length = 200`: `~0.75` - `Task Length = 400`: `~0.50` - `Task Length = 600`: `~0.35` - `Task Length = 800`: `~0.25` - `Task Length = 1000`: `~0.10` #### **Qwen3-32b (Blue Line)** - **Trend**: - Starts at approximately `0.90` turn accuracy at `Task Length = 0`. - Remains relatively flat, ending at `~0.75` at `Task Length = 1000`. - Data points show minimal variability across task lengths. - **Key Data Points**: - `Task Length = 0`: `0.90` - `Task Length = 200`: `~0.85` - `Task Length = 400`: `~0.80` - `Task Length = 600`: `~0.78` - `Task Length = 800`: `~0.75` - `Task Length = 1000`: `~0.75` --- ## Observations 1. **Model Performance**: - `Gemma3-27b` experiences a significant drop in turn accuracy as task length increases, suggesting reduced robustness for longer tasks. - `Qwen3-32b` maintains higher and more stable accuracy across all task lengths, indicating better scalability. 2. **Error Bars**: - `Gemma3-27b` error bars grow larger at longer task lengths, reflecting higher variance in performance. - `Qwen3-32b` error bars remain consistent, indicating stable performance. 3. **Legend Accuracy**: - Red line corresponds to `Gemma3-27b` (confirmed via legend). - Blue line corresponds to `Qwen3-32b` (confirmed via legend). --- ## Conclusion The graph highlights a clear divergence in performance between the two models. `Qwen3-32b` outperforms `Gemma3-27b` in maintaining turn accuracy for longer tasks, with less variability. This suggests `Qwen3-32b` may be more suitable for applications requiring consistent performance across varying task complexities. </details> <details> <summary>2509.09677v2/x16.png Details</summary>  ### Visual Description # Technical Document Analysis: Task Accuracy vs. Task Length ## 1. Chart Type and Structure - **Chart Type**: Line graph - **Components**: - **X-axis**: Task Length (0–100) - **Y-axis**: Task Accuracy (0.0–1.0) - **Legend**: Located at the bottom of the chart - **Lines**: Four distinct data series with unique styles/colors ## 2. Axis Labels and Markers - **X-axis**: - Label: "Task Length" - Ticks: 0, 20, 40, 60, 80, 100 - **Y-axis**: - Label: "Task Accuracy" - Ticks: 0.0, 0.2, 0.4, 0.6, 0.8, 1.0 ## 3. Legend Details - **Position**: Bottom center of the chart - **Entries**: - **Red Dashed Line**: Retrieval - **Purple Dash-Dot Line**: Cumulative Addition - **Green Dotted Line**: Addition - **Blue Solid Line**: Cumulative Retrieval + Addition ## 4. Data Series Analysis ### 4.1 Retrieval (Red Dashed Line) - **Trend**: Flat line at 1.0 across all Task Length values - **Key Points**: - [0, 1.0], [20, 1.0], [40, 1.0], [60, 1.0], [80, 1.0], [100, 1.0] ### 4.2 Cumulative Addition (Purple Dash-Dot Line) - **Trend**: Gradual decline from 1.0 to ~0.65 - **Key Points**: - [0, 1.0] - [20, ~0.92] - [40, ~0.88] - [60, ~0.83] - [80, ~0.77] - [100, ~0.68] ### 4.3 Addition (Green Dotted Line) - **Trend**: Flat line at 1.0 across all Task Length values - **Key Points**: - [0, 1.0], [20, 1.0], [40, 1.0], [60, 1.0], [80, 1.0], [100, 1.0] ### 4.4 Cumulative Retrieval + Addition (Blue Solid Line) - **Trend**: Sharp initial drop to 0, then flat - **Key Points**: - [0, 1.0] - [10, 0.0] - [20, 0.0] - [40, 0.0] - [60, 0.0] - [80, 0.0] - [100, 0.0] ## 5. Cross-Referenced Observations - **Color Consistency**: - Red dashed line matches "Retrieval" legend entry - Purple dash-dot line matches "Cumulative Addition" legend entry - Green dotted line matches "Addition" legend entry - Blue solid line matches "Cumulative Retrieval + Addition" legend entry - **Trend Verification**: - All flat lines (Retrieval, Addition) maintain 1.0 accuracy - Cumulative Addition shows stepwise degradation - Cumulative Retrieval + Addition exhibits catastrophic failure at Task Length = 10 ## 6. Spatial Grounding - **Legend Coordinates**: Bottom center (exact [x, y] unspecified but visually centered) - **Line Placement**: - Top: Retrieval (red) and Addition (green) - Middle: Cumulative Addition (purple) - Bottom: Cumulative Retrieval + Addition (blue) ## 7. Critical Insights - **Task Length Thresholds**: - Cumulative Retrieval + Addition fails completely after Task Length = 10 - Cumulative Addition degrades by ~35% over Task Length = 100 - **Performance Parity**: - Retrieval and Addition tasks maintain perfect accuracy - Combined task (Cumulative Retrieval + Addition) shows non-linear failure ## 8. Missing Elements - No textual annotations or annotations on data points - No gridlines visible in the chart - No secondary y-axis or annotations ## 9. Language Analysis - **Primary Language**: English (all labels, axis titles, and legend entries) - **No Foreign Text Detected** ## 10. Summary The chart demonstrates task accuracy degradation under increasing task length. Retrieval and Addition tasks maintain perfect accuracy, while cumulative tasks exhibit failure modes: 1. **Cumulative Retrieval + Addition**: Catastrophic failure at Task Length = 10 2. **Cumulative Addition**: Gradual degradation over Task Length = 100 </details> Figure 14: Analysis of execution failures. (a) Self-conditioning effect emerges as tasks get longer. Even for models that ace the task at a task length of 100, the Turn Accuracy drops constantly as we further increase the turns. (b) Models are good at the tasks individually, but not on their composition. State tracking introduces additional difficulty. Appendix E Experimental Setup E.1 Task Details We create a dictionary where keys consist of common five-letter English words, and the values consist of integers uniformly sampled from $-99$ to $99$ . The range of values is deliberately kept large to minimize the chance of an assistant being wrong in an earlier turn correcting its response by pure accident. For our experiment, we first create a fixed set of $100$ keys. Then, we create multiple rollouts (samples) of $50,000$ steps. For each rollout, we uniformly sample a separate set of values to be assigned to each key, in order to increase experimental breadth. Next, at each step, we uniformly sample a key to be provided at that step with replacement. This gives us a list of keys to be processed in order, which is exactly the plan to be executed by the agent. To account for the turn complexity ( $K$ ), we group $K$ consecutive keys together and represent them as one turn. Thus, we can fully specify our intended evaluation by (1) specifying the number of samples (rollouts) needed, (2) the turn complexity, $K$ , and (3) the number of turns required. This gives us a superset of data from which we sample rollouts to use in our experiments. For the Qwen3 and Gemma3 families, we sample 100 rollouts. For frontier models, due to cost limitations, we sample 20-50 rollouts. To ensure consistency in evaluation, we provide the same rollouts to each model. E.2 Prompting Each LLM is provided a standardized prompt describing the task at the start of the conversation. This prompt specifies the dictionary containing the five-letter word keys and their corresponding values. Further, the prompt specifies the number of keys that will be provided to the LLM at each subsequent turn. To ensure format following, the prompt also contains few-shot examples with different turn complexities. Finally, the LLM is asked to provide the running sum after each turn in <answer> tags. An example conversation is shown below. E.3 Prompting for Thinking Models To enable models to use chain-of-thought prompting, we add the line ‘‘Think step by step before answering.’’ to the prompt and also add CoT traces to the few-shot examples. We find that models stop performing CoT reasoning after a few turns, as it starts conditioning on the answer format in its history. Thus, we end up including the chain-of-thought trace in the conversation history, to ensure the model does not forget the CoT instruction. This is a trade-off we had to make as it increases the input context of the LLM, however, it was essential to ensure instruction following. Thinking models provided their reasoning in <think> tags, which were removed from the conversation history. No other changes were needed to make the thinking models follow instructions. E.4 Model Specifications For chain-of-thought prompting, we set the per-turn output token limit to $10,000$ tokens, and for thinking models, the token limit is set to $32,000$ tokens, consistent with token limits provided by OpenRouter. We ensure that these token limits are sufficient to complete the required computations. We use a temperature of $0.6$ and a top-p value of $0.95$ for all Gemma models. For Qwen, we use a temperature of $0.6$ and a top-p value of $0.95$ for thinking mode and a temperature of $0.7$ and a top-p value of $0.8$ for non-thinking as recommended in their documentation. https://huggingface.co/Qwen/Qwen3-32B We find in Figure ˜ 13 that temperature does not affect the observed trends by much. E.5 Compute Details All experiments were conducted on machines equipped with 4x NVIDIA A100 GPUs with 40/80GB memory. Frontier model evaluations were performed using OpenRouter. Starting Prompt: You are an AI assistant. I will provide you with a dictionary and then give you keys in groups of 2. Your task is to keep a running total (starting from 0) by adding the values associated with the keys I provide. In each turn, I’ll provide 2 keys (comma-separated). Respond with the current running sum, enclosed in <answer> tags. Examples: Dictionary to maintain: ‘apple’: 5, ‘banana’: 0, ‘cherry’: 7, ‘grape’: -4, ‘kiwi’: 2, ‘mango’: -1 Example 1: keys in groups of 2 User: apple, banana Assistant: <answer>5</answer> User: cherry, grape Assistant: <answer>8</answer> User: kiwi, mango Assistant: <answer>9</answer> Example 2: keys in groups of 3 User: apple, banana, cherry Assistant: <answer>12</answer> User: grape, kiwi, mango Assistant: <answer>9</answer> Example 3: keys in groups of 6 User: apple, banana, cherry, grape, kiwi, mango Assistant: <answer>9</answer> Now, here is the actual task: Dictionary to maintain: ’doubt’: -64, ‘alone’: 46, ‘adult’: 84, ‘fault’: -19, ‘brain’: -45, ‘blind’: 68, ... ‘coach’: -31, ‘alarm’: 88, ‘could’: 25, ‘cable’: -32 Ready to start! IMPORTANT: DO NOT OUTPUT ANY OTHER TEXT OUTSIDE ANSWER TAGS. Only provide the final running sum OF ALL TURNS in <answer> tags. User: alarm,coach Assistant: <answer>57</answer> User: doubt,cable Assistant: <answer>-39</answer> Appendix F Format Following Failures In any LLM evaluation, format following failures are a common source of error that is often neglected. In our experiments, any model can have 2 types of format following failures: (1) They do not provide <answer> tags in their answer, and (2) They do not provide a valid integer within <answer> tags. To minimize format following failures, we ensure clarity in the starting prompt with clear format instructions, as well as few-shot examples. To empirically verify that model errors on our task are actually execution errors and not just format following errors in disguise, for each experiment, we also track the format failure fraction: the fraction of samples that do not correctly follow the format, with the failure being either (1) or (2). It is important to note that while we try to minimize any such error to the best of our abilities, we still count format following as a limitation of the model and hence a source of error. Our results for format following failures are presented in Figure ˜ 15 for the experiments presented in Section ˜ 3. We observe that smaller models are more susceptible to format failures, with the Qwen3 family in particular being worse at following format instructions. Overall, the fraction for format following errors is low (around 0.1), with the Qwen3-8B being an exception. We find that the error here actually comes from the model trying to cheat, and do the entire summation inside the <answer> tags (For example, <answer>39 + 51 = 90</answer>). This is explicitly forbidden as we do not allow chain-of-thought or thinking in this experiment, and thus we count this as an error. Gemma3 4B fails at later turns due to context length limitations; however, that does not affect any results, as its accuracies drop much earlier. <details> <summary>2509.09677v2/x17.png Details</summary>  ### Visual Description # Technical Document Analysis of Format Failure Fraction Graphs ## Overview The image contains four line graphs (a-d) comparing format failure fractions across different task lengths for various AI models. Key parameters include: - **K values**: 1, 2 (disabled thinking), 2 (enabled thinking), 10 (enabled thinking) - **Models**: Gemma3-4B, Gemma3-12B, Gemma3-27B, Qwen3-4B, Qwen3-8B, Qwen3-14B, Qwen3-32B - **Axes**: - X-axis: Task Length (0-200 for a-c; 0-600 for d) - Y-axis: Format Failure Fraction (0-1) --- ## Graph Descriptions ### (a) K=1 **Legend**: - Light orange: Gemma3-4B - Dark orange: Gemma3-12B - Red: Gemma3-27B - Light blue: Qwen3-4B - Dark blue: Qwen3-8B - Teal: Qwen3-14B - Navy: Qwen3-32B **Trends**: - **Gemma3-4B**: Gradual increase from ~0.1 to ~0.3 (x=0-200) - **Gemma3-12B**: Sharp spike at x=100 (failure fraction ~0.9), then drops to ~0.1 - **Gemma3-27B**: Stable at ~0.05 - **Qwen3 models**: - 4B/8B: Stable ~0.2 - 14B/32B: Stable ~0.1 ### (b) K=2, Thinking Disabled **Legend**: Same as (a) **Trends**: - **Gemma3-4B**: Stable ~0.1 - **Gemma3-12B**: Stable ~0.05 - **Gemma3-27B**: Stable ~0.02 - **Qwen3 models**: - 4B/8B: Stable ~0.15 - 14B/32B: Stable ~0.05 ### (c) K=2, Thinking Enabled **Legend**: Same as (a) **Trends**: - **Gemma3-4B**: Stable ~0.05 - **Gemma3-12B**: Stable ~0.02 - **Gemma3-27B**: Stable ~0.01 - **Qwen3 models**: - 4B/8B: Stable ~0.05 - 14B/32B: Stable ~0.02 ### (d) K=10, Thinking Enabled **Legend**: Same as (a) **Trends**: - **Gemma3-4B**: Stable ~0.05 - **Gemma3-12B**: Sharp spike at x=400 (failure fraction ~0.9), then drops to ~0.05 - **Gemma3-27B**: Stable ~0.01 - **Qwen3 models**: - 4B/8B: Stable ~0.05 - 14B/32B: Stable ~0.02 --- ## Key Observations 1. **Model Performance**: - Larger models (e.g., Gemma3-27B, Qwen3-32B) generally show lower failure fractions. - Thinking enabled reduces failure fractions across all models. 2. **Task Length Sensitivity**: - Failure fractions spike at specific task lengths (e.g., x=100 in (a), x=400 in (d)). - Spikes correlate with model architecture (e.g., Gemma3-12B in (a) and (d)). 3. **K Value Impact**: - Higher K values (e.g., K=10) with thinking enabled reduce failure fractions compared to K=1. --- ## Spatial Grounding & Validation - **Legend Position**: Bottom of all graphs (x=0-200 for a-c; x=0-600 for d). - **Color Consistency**: - Confirmed matches between legend labels and line colors across all graphs. - Example: Gemma3-12B (dark orange) consistently appears as a dark orange line. ## Conclusion The graphs demonstrate that thinking-enabled models with higher K values achieve lower format failure fractions, particularly for longer task lengths. Spikes in failure fractions occur at specific task lengths, suggesting architectural limitations in certain models. </details> Figure 15: Format following is not the primary mode of failure. We analyze the fraction of errors attributed to incorrect format following for the experiments presented in Section ˜ 3. Overall, format adherence is high and not the primary source of execution errors. For the experiments presented in Figure ˜ 15, we find the Qwen3 family to be prone to format following errors in the case where we have thinking disabled for $K=2$ . We again find this to be the consequence of models trying to cheat and use extra tokens for computation inside the answer tags. This is fixed by enabling thinking. Following this, the errors in format become negligible. At $K=10$ , we see Gemma3 12B sharply rise to a format failure fraction of 1.0, again due to a full context window. Appendix G Chain-of-Thought Self-Conditioning While our self-conditioning analysis provides clear insights for thinking models, extending this to models using Chain-of-Thought (CoT) presents some significant methodological challenges. First, a fundamental prerequisite for reliable CoT reasoning is the inclusion of prior CoT traces in the context history. As we observed with the Gemma3 models, they often condition on the format of the context; if prior turns lack CoT traces, the models cease to generate them, even when explicitly instructed to do so. Consequently, this experiment for CoT must include the full reasoning trace for every preceding turn. This requirement immediately makes the setup practically infeasible, as the verbose nature of CoT traces would rapidly exhaust the context window limits of even frontier models. Second, even if context length were not a constraint, the process of injecting controlled errors into CoT histories is not straightforward. A naive approach of only altering the final answer while preserving the original, correct CoT trace creates an unfaithful history. When conditioned on a history where reasoning and conclusions are contradictory, the model is no longer being tested on its execution reliability but on how it resolves inconsistency—it might learn to distrust its own reasoning, introducing a confounding variable. <details> <summary>2509.09677v2/x18.png Details</summary>  ### Visual Description # Technical Document Analysis of Provided Image ## Chart 1: Gamma-3-12B CoT (Left Chart) ### Axes and Labels - **X-axis**: Task Length (0 to 80) - **Y-axis**: Turn Accuracy (0 to 0.4) ### Legend - **Colors and Labels**: - Blue: Original Run - Red: 100% Error Rate - Orange: 75% Error Rate - Yellow: 50% Error Rate - Green: 25% Error Rate - Purple: 0% Error Rate ### Key Trends and Data Points 1. **Original Run (Blue)**: - Starts at ~0.3 Turn Accuracy at Task Length 0. - Gradual decline to ~0.15 by Task Length 20. - Further drops to ~0.05 by Task Length 60. - Final value near 0 at Task Length 80. 2. **100% Error Rate (Red)**: - Begins at ~0.25 Turn Accuracy at Task Length 0. - Sharp drop to ~0.05 by Task Length 20. - Remains near 0.05 until Task Length 60. - Final value near 0 at Task Length 80. 3. **75% Error Rate (Orange)**: - Starts at ~0.2 Turn Accuracy at Task Length 0. - Peaks at ~0.15 around Task Length 10. - Declines to ~0.05 by Task Length 40. - Final value near 0 at Task Length 80. 4. **50% Error Rate (Yellow)**: - Begins at ~0.15 Turn Accuracy at Task Length 0. - Peaks at ~0.1 around Task Length 10. - Drops to ~0.05 by Task Length 30. - Final value near 0 at Task Length 80. 5. **25% Error Rate (Green)**: - Starts at ~0.1 Turn Accuracy at Task Length 0. - Peaks at ~0.075 around Task Length 20. - Declines to ~0.025 by Task Length 60. - Final value near 0 at Task Length 80. 6. **0% Error Rate (Purple)**: - Begins at ~0.05 Turn Accuracy at Task Length 0. - Peaks at ~0.025 around Task Length 40. - Remains near 0.025 until Task Length 60. - Final value near 0 at Task Length 80. ## Chart 2: Format Failure Fraction (Right Chart) ### Axes and Labels - **X-axis**: Task Length (0 to 1000) - **Y-axis**: Format Failure Fraction (0 to 1) ### Legend - **Colors and Labels**: - Blue: Original Run - Red: 100% Error Rate - Orange: 75% Error Rate - Yellow: 50% Error Rate - Green: 25% Error Rate - Purple: 0% Error Rate ### Key Trends and Data Points 1. **Original Run (Blue)**: - Remains near 0 until Task Length 600. - Jumps to 1 at Task Length 600. - Stays at 1 for all subsequent Task Lengths. 2. **100% Error Rate (Red)**: - Remains near 0 until Task Length 400. - Jumps to 1 at Task Length 400. - Stays at 1 for all subsequent Task Lengths. 3. **75% Error Rate (Orange)**: - Remains near 0 until Task Length 200. - Jumps to 1 at Task Length 200. - Stays at 1 for all subsequent Task Lengths. 4. **50% Error Rate (Yellow)**: - Remains near 0 until Task Length 200. - Jumps to 1 at Task Length 200. - Stays at 1 for all subsequent Task Lengths. 5. **25% Error Rate (Green)**: - Remains near 0 until Task Length 600. - Jumps to 1 at Task Length 600. - Stays at 1 for all subsequent Task Lengths. 6. **0% Error Rate (Purple)**: - Remains near 0 until Task Length 800. - Jumps to 1 at Task Length 800. - Stays at 1 for all subsequent Task Lengths. ## Spatial Grounding and Validation - **Legend Placement**: Both charts have legends at the bottom. - **Color Consistency**: - Left Chart: Blue (Original Run) matches the steepest decline. - Right Chart: Red (100% Error Rate) aligns with the earliest jump to 1. - **Trend Verification**: - Left Chart: Lines with higher error rates (e.g., red, orange) show earlier and sharper declines. - Right Chart: Higher error rates (e.g., red, orange) trigger earlier jumps to 1. ## Conclusion The charts illustrate the relationship between task length, error rates, and performance metrics (Turn Accuracy and Format Failure Fraction). Higher error rates correlate with earlier performance degradation in both metrics. </details> Figure 16: CoT does not fix self-conditioning. We observe that even with programmatically generated CoT history, the Gemma3 models cannot mitigate self-conditioning. The alternative is to programmatically generate flawed CoT traces. We implemented and experimented with this, and as seen in Figure ˜ 16, CoT does not mitigate the self-conditioning effect. However, this setup also introduces its own complexities. For our simple task, there are multiple distinct points of failure within a single trace: an error in the retrieval step (looking up an incorrect value) or an error in the composition step (an arithmetic mistake). A controlled experiment would need to systematically manage the type, frequency, and location of these injected errors, making the setup intractable. Even establishing a “perfectly correct” (Induced Error Rate = 0.00) baseline history is problematic. A model might have a CoT trace with flawed reasoning (e.g., a minor calculation error that cancels out), which we then replace with the correct final answer. Such a history is also unfaithful. Given these challenges—the practical infeasibility due to context length and the difficulty of designing a faithful error injection mechanism, we limit our self-conditioning analysis to non-thinking and thinking models. Appendix H Proof and Analysis of Proposition 1 **Proposition 1** *Assuming a constant per-step accuracy $p$ and no self-correction, the horizon-length $H$ at which a model can achieve a success rate $s$ is given by: $$ H_{s}(p)=\frac{\ln(s)}{\ln(p)} $$* * Proof* Let $p$ be the constant probability of successfully executing a single step. Under the assumption of no self-correction, a task of length $H$ is successful only if all $H$ independent steps are executed correctly. The probability of this joint event, $P(\text{success},H)$ , is the product of the individual step probabilities: $$ P(\text{success},H)=\underbrace{p\times p\times\cdots\times p}_{H\text{ times}}=p^{H} $$ This is equivalent to the Task Accuracy at turn $H$ , i.e., $\text{TA}(H)=p^{H}$ . We define the horizon-length $H$ as the number of turns at which the probability of success equals a desired rate $s$ . Therefore, we set our expression for the success probability equal to $s$ : $$ p^{H}=s $$ Solving for $H$ , $$ \ln(p^{H})=\ln(s)\Rightarrow H\cdot\ln(p)=\ln(s) $$ $$ H_{s}(p)=\left\lceil\frac{\ln(s)}{\ln(p)}\right\rceil\approx\frac{\ln(s)}{\ln p} $$ This completes the proof. ∎ H.1 Implications for Horizon Length ( $H_{0.5}$ ) We can apply this general result to our specific metric, the Horizon Length ( $H_{0.5}$ ), which is defined as the number of turns at which Task Accuracy drops to $s=0.5$ , $$ H_{0.5}(p)=\left\lceil\frac{\ln(0.5)}{\ln p}\right\rceil=\left\lceil-\frac{\ln(2)}{\ln p}\right\rceil \tag{2} $$ For analysis, we use the continuous approximation: $$ H_{0.5}(p)\approx-\frac{\ln(2)}{\ln p} \tag{2} $$ Sensitivity to Small Changes in Step Accuracy. This formulation allows us to analyze the sensitivity of the horizon length to small improvements in per-step accuracy by taking the derivative with respect to $p$ , $$ \frac{dH_{0.5}}{dp}=-\ln(2)\cdot\left(-\frac{1}{(\ln p)^{2}}\cdot\frac{1}{p}\right)=\frac{\ln 2}{p(\ln p)^{2}} \tag{2} $$ This implies that a small change in accuracy $\Delta p$ results in a change in horizon length $\Delta H_{0.5}$ of, $$ \Delta H_{0.5}\approx\frac{\ln 2}{p(\ln p)^{2}}\,\Delta p $$ Near-Perfect Accuracy Regime. The effect is most dramatic when accuracy is already high. For near-perfect accuracy, let $p=1-\varepsilon$ where $\varepsilon\ll 1$ . Using the Taylor approximation $\ln(1-\varepsilon)≈-\varepsilon$ , we can simplify the expression for $H_{0.5}$ , $$ H_{0.5}\approx-\frac{\ln(2)}{\ln(1-\varepsilon)}\approx-\frac{\ln(2)}{-\varepsilon}=\frac{\ln 2}{\varepsilon}=\frac{\ln 2}{1-p} \tag{2} $$ The sensitivity in this regime becomes, $$ \frac{dH_{0.5}}{dp}\approx\frac{\ln 2}{(1-p)^{2}}\quad\Rightarrow\quad\Delta H_{0.5}\approx\frac{\ln 2}{(1-p)^{2}}\,\Delta p $$ This demonstrates that as $p→ 1$ , the improvement in horizon length for a fixed gain in step accuracy grows quadratically, highlighting the compounding benefits of scale.