The Illusion of Diminishing Returns: Measuring Long Horizon Execution in LLMs

TL;DR

Single-step benchmark gains look diminishing but compound into exponential growth in the length of tasks a model can complete end-to-end; even when knowledge and plan are explicitly provided in-context, long-horizon execution remains a distinct failure mode. The authors isolate execution by chaining retrieve-then-compose steps over an in-context key-value dictionary, and find (i) per-step accuracy degrades as turns accumulate via a “self-conditioning” effect (errors in the context make future errors more likely), (ii) self-conditioning is not mitigated by scaling model size — but is fixed by thinking/RL-trained reasoning models, and (iii) sequential test-time compute (CoT, thinking) is what unlocks long single-turn execution: GPT-5 “Horizon” hits 2176 steps vs Claude-4 Sonnet 432 / Grok 4 384 / Gemini 2.5 Pro 120, while non-thinking frontier models (DeepSeek-V3, Kimi K2) can’t chain even four steps.

Key claims

Under constant step accuracy and no self-correction, the horizon length at any target success rate grows hyperbolically with single-step accuracy; small gains beyond ~80% step accuracy translate into rapidly increasing achievable task lengths [§2.1, Prop. 1, Fig. 2].
METR’s empirically reported exponential growth in agent horizon length (doubling every ~7 months) is consistent with diminishing per-step improvements: the step-accuracy increment required to sustain exponential horizon-length growth is itself a diminishing function of time [§2.1, Fig. 1].
Long-horizon execution is genuinely hard even when the model has the required knowledge and plan in-context — Qwen3-32B falls below 50% task accuracy within 15 turns of a simple in-context dictionary-lookup-and-sum task [§3.1, Fig. 4c, Result 1].
Scaling model size yields non-diminishing improvements in number of turns successfully executed, even on a knowledge-free, plan-provided task — refuting “scaling only helps via knowledge/planning capacity” as the only explanation for size gains [§3.1, Fig. 4b–c, Result 2].
Per-step accuracy degrades with turn index, not just due to long-context limits — counterfactually injecting controlled error rates into the chat history sharpens degradation in proportion to injected error rate, isolating a “self-conditioning” effect [§3.2, Fig. 5a, Result 3].
Self-conditioning is not removed by scaling: at 0% injected error, Kimi-K2, DeepSeek-V3, and Qwen3-235B reach near-perfect turn-100 accuracy on healed histories, but all still degrade as the induced error rate rises [§3.2, Fig. 5b, Result 4].
Thinking models (Qwen3 thinking variants) eliminate self-conditioning — their turn-100 accuracy is invariant to the error rate in the history; inspection of thinking traces shows they do not refer back to prior turn answers [§3.2, Fig. 6, Result 5].
Without chain-of-thought, frontier non-thinking LLMs (DeepSeek-V3 670B, Kimi K2 1026B) cannot chain more than ~6 retrieve-then-compose steps in a single turn; CoT dramatically increases single-turn execution length [§3.3, Fig. 7 left, Result 6].
Frontier thinking-model single-turn execution lengths separate sharply: GPT-5 “Horizon” 2176 steps, Claude-4 Sonnet 432, Grok 4 384, Gemini 2.5 Pro 120 [§3.3, Fig. 7 right, Result 7].
Parallel test-time compute (majority voting across parallel samples) gives only marginal execution-length gains relative to sequential CoT — sequential thinking is the load-bearing axis [Appendix B].
Context engineering — removing prior history from non-thinking models — also mitigates self-conditioning, consistent with the mechanistic hypothesis that next-token training makes models continue their error-prone trajectory [§3.2, §A.2].

Method

Isolate execution by reducing the task to chained retrieve-then-compose steps over an in-context key-value dictionary D: word → int (five-letter English words to two-digit integers, chosen to minimize tokenization artifacts). At each turn t, the model receives an explicit plan P_t (a set of keys) and must update a running sum state S_t = S_{t-1} + Σ_{k∈P_t} D[k]. Two control axes: number of turns (sequential dimension) and turn complexity K (number of keys per turn — the single-turn execution dimension). Both knowledge (the dictionary) and plan (the keys) are provided, removing planning and parametric-knowledge confounds.

For self-conditioning, the chat history is counterfactually rewritten with a chosen injected error rate ∈ {0, …}; if model accuracy at turn 100 worsens monotonically with injected error rate, self-conditioning is isolated from generic long-context degradation. For single-turn execution length, a binary search finds the maximum K at which the model maintains target accuracy (e.g. 50%).

Results

Qwen3-32B horizon length (~15 turns at 50% task accuracy) substantially exceeds Qwen3-4B (~few turns) at near-identical single-step accuracy on the first step [Fig. 4]. Output-level majority voting does not replicate the model-size gains [Appendix B].
At induced-error-rate 0.5 in the history, all tested models show sharply degraded turn-100 accuracy vs the 0.0 baseline; 200B+ scale (Kimi-K2, DeepSeek-V3, Qwen3-235B) fixes the long-context piece but not the self-conditioning piece [Fig. 5].
Qwen3 thinking variants: turn-100 accuracy approximately flat across injected error rates in [0, ~]; non-thinking Qwen3 declines sharply over the same range [Fig. 6].
Single-turn execution length, binary search at the model’s accuracy threshold: GPT-5 (“Horizon”) 2176, Claude-4 Sonnet 432, Grok 4 384, Gemini 2.5 Pro 120 — a >5× gap between GPT-5 and the next best frontier model [Fig. 7 right].
DeepSeek-V3 and Kimi K2 without CoT fail at single-turn complexity >6; with CoT, the thinking variants (R1, K2-Thinking) extend to >100 steps in one turn [Fig. 7 left].

Why it’s interesting

This paper formalizes the intuition that “the bottleneck for agents is reliability over many steps, not single-shot accuracy”, and gives the cleanest filed datapoint for why sequential test-time compute (i.e. thinking) is so much more useful for agentic work than parallel test-time compute — the binding constraint is self-conditioning on past errors, which sequential reasoning routes around but majority voting does not. The hyperbolic-step-accuracy → horizon-length result reframes METR-style horizon-doubling trends: even ostensibly “diminishing” gains on short-task benchmarks can be the signature of healthy exponential progress on the metric that matters for long agentic projects, which is directly relevant to how the team interprets per-step-accuracy plateaus on MMLU/SWE-Bench-Verified-style benchmarks.

It contrasts directly with The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity, which used Apple’s controlled puzzle setup to argue that thinking models give an illusion of thinking and collapse on harder tasks — this paper’s response is that the collapse is in execution, not reasoning, and that the right fix is sequential test-time compute (and the right metric is horizon length at target accuracy). It complements MiroThinker: Pushing the Performance Boundaries of Open-Source Research Agents via Model, Context, and Interactive Scaling‘s claim that “interaction depth” is a third scaling axis by providing the underlying mechanistic story (self-conditioning) for why depth doesn’t come for free with model size. The execution-vs-planning decomposition also reframes Step 3.5 Flash‘s and Qwen3-Coder-Next Technical Report‘s reliance on sequential reasoning for SWE-Bench Pro / Terminal-Bench: the gap they exploit between thinking and non-thinking frontier models likely is the self-conditioning gap measured here.