Every AI agent demo shares the same dirty secret: models that ace individual reasoning steps still fall apart when asked to string hundreds of them together. Apple’s machine learning research group just published work that puts a name on one specific reason why — the “no-recovery bottleneck” — and proposes a fix called LEAD that measurably extends how long a model can execute before collapsing. The paper, published to Apple Machine Learning Research in July 2026, comes from Denys Pushkin and Emmanuel Abbé, who hold joint affiliations at EPFL and Apple.
The result worth remembering: with LEAD, OpenAI’s o4-mini solves the Checkers Jumping puzzle up to complexity n=13, where the standard decomposition approach fails beyond n=11. Two extra complexity levels may sound modest until you register that difficulty in these puzzles compounds — each level up demands a longer flawless execution chain than the last.
The problem: models don’t fail on hard steps, they fail on long chains
The failure mode LEAD addresses is well documented but stubbornly unsolved. LLMs degrade rapidly on tasks that require executing long sequences of reasoning steps, even when each individual step is easy and even when the model is handed the correct high-level strategy up front. Difficulty scales with execution length, not per-step complexity.
Researchers call the measurable version of this the compositionality gap: the success rate on a composed task is consistently lower than what you’d predict by multiplying the success rates of its isolated subtasks. Notably, prior work has found this gap persists across model scales — bigger models get better at individual steps, but the composition penalty doesn’t disappear.
To study the phenomenon cleanly, the authors evaluate on two algorithmic puzzles with adjustable complexity and known optimal strategies: Tower of Hanoi and Checkers Jumping. Both were previously proposed as benchmarks in Apple’s widely discussed 2025 paper on reasoning models, The Illusion of Thinking, which used the same puzzle environments to probe where “thinking” models break down. By providing the solution strategy in the prompt, the new work explicitly isolates execution from planning — the question is not whether the model can figure out what to do, but whether it can actually do it for hundreds of steps without derailing.
Decomposition helps — until it hits the no-recovery bottleneck
The conventional medicine for long-horizon instability comes in two flavors, which the paper distills into fundamental motifs. The first is context truncation: periodically restart generation with only the essential summary needed to proceed. The second is task decomposition, taken here to its logical extreme as “Atomic Decomposition” — every single step executed in a separate model call with a minimal-context prompt.
The first empirical finding is that decomposition is genuinely necessary. Comparing the two motifs head-to-head, the authors show that deliberately isolating reasoning steps — not just managing context length — is the primary driver of reliable execution across models and benchmarks. A model that periodically summarizes and restarts still drifts; a model that executes each step in a clean, minimal context stays stable far longer.
But extreme isolation creates its own failure mode, and this is the paper’s central diagnosis. Atomic Decomposition is memoryless by design: each step happens in a vacuum, so a local error has no mechanism to get caught and corrected. It simply propagates. The authors show this structural weakness becomes critical because model errors are not spread evenly across steps — the error distribution is highly non-uniform. A small number of “hard” steps attract consistent, repeated mistakes, and in a memoryless pipeline those mistakes are irreversible. That is the no-recovery bottleneck: overall success stops being limited by the model’s average competence and becomes hostage to a handful of high-entropy junctions where it reliably stumbles.
The Tower of Hanoi comparison makes the mechanism vivid. Hanoi is a uniform task — every step is roughly as easy as every other — and minimal-context atomic execution handles it stably. Checkers Jumping has genuinely hard junctions, and that’s exactly where pure atomic decomposition dies.
Figure: Pushkin & Abbé, arXiv:2603.06870
How LEAD threads the needle
LEAD — Lookahead-Enhanced Atomic Decomposition — keeps the isolation that makes atomic execution stable while adding just enough shared context to make errors correctable. Two mechanisms do the work, per the paper:
Short-horizon future validation. Instead of committing to a step and moving on blind, LEAD rolls each candidate step forward a few steps into the future. A locally plausible move that leads somewhere inconsistent gets flagged before it becomes permanent — the lookahead acts as a cheap corrective signal that pure atomic decomposition structurally lacks.
Aggregation of overlapping rollouts. LEAD generates multiple overlapping rollouts and combines them through consistency filtering and a smoothed voting mechanism. Because the rollouts overlap, the same step gets attempted in several slightly different contexts, and the vote washes out the one-off errors while letting consistent signal through.
The ablation study answers which ingredient matters more: removing any component degrades performance, but aggregation is the most critical piece. Voting across overlapping rollouts, more than the lookahead depth itself, is what carries the method. The reported experiments hold the number of rollouts at k=8 and consistency threshold at t=3, while the validation horizon adapts to task complexity.
The headline results extend beyond o4-mini. The authors report that LEAD significantly extends the reliable reasoning horizon of frontier models including o4-mini, Qwen3-235B-Thinking and GPT-5.2, outperforming existing stepwise baselines across the board. The bottleneck, in other words, is not a quirk of one model family — and neither is the fix.
Why this matters more outside the puzzle box
Algorithmic puzzles are a proxy, and the authors are explicit about that framing. The real-world shape of this problem is the AI agent that executes a 40-step workflow: file operations, API calls, form fills, multi-stage data transformations. Today’s agent frameworks already lean on decomposition — planners that break goals into subtasks, executors that handle one subtask per call. LEAD’s diagnosis says that architecture has a predictable failure signature: it will work beautifully until it hits a hard junction, then fail the same way every time, with no mechanism to notice.
The prescription — validate a few steps ahead, run overlapping attempts, vote — is architecture-level advice that agent builders can act on without waiting for a better base model. It costs more inference per step, which the paper acknowledges with a dedicated cost analysis, but it converts a hard ceiling into a soft, budget-dependent one — a trade most production teams will gladly price in, since a workflow that silently derails at step 30 costs far more to detect and repair than the extra rollouts would have. Spending compute on overlapping rollouts at the junctions that matter is a very different proposition from spending it uniformly everywhere.
There’s also a quiet continuity worth noting. The Illusion of Thinking sparked a long argument about whether reasoning models actually reason or merely pattern-match until complexity overwhelms them. This paper is a constructive sequel from the same research organization: rather than relitigating whether models collapse on long horizons, it accepts the collapse as measurable fact, locates the precise structural cause in one popular mitigation strategy, and engineers around it. Whatever the answer to the philosophical question, the reliable-execution horizon just moved — and for anyone shipping agents, that’s the number that pays the bills.
