Solving a Million-Step LLM Task with Zero Errors

TL;DR

This work addresses the reliability challenge of executing ultra-long tasks with LLMs, proposing MAKER and the broader MDAP framework to achieve zero-error execution on tasks exceeding one million steps. By decomposing tasks into minimal subtasks (MAD), applying a robust first-to-ahead-by-k voting scheme for error correction, and using red-flagging to suppress correlated failures, the approach demonstrates scalable, low-cost long-horizon reasoning. The study provides formal scaling insights, cost projections, and a concrete million-step success in the Towers of Hanoi benchmark, along with analyses of error decorrelation and the impact of red-flagging. The results suggest a paradigm shift from purely scaling up base models to deploying massively decomposed, modular agentic systems that are safer, more scalable, and applicable to real-world organizational and societal problems.

Abstract

LLMs have achieved remarkable breakthroughs in reasoning, insights, and tool use, but chaining these abilities into extended processes at the scale of those routinely executed by humans, organizations, and societies has remained out of reach. The models have a persistent error rate that prevents scale-up: for instance, recent experiments in the Towers of Hanoi benchmark domain showed that the process inevitably becomes derailed after at most a few hundred steps. Thus, although LLM research is often still benchmarked on tasks with relatively few dependent logical steps, there is increasing attention on the ability (or inability) of LLMs to perform long range tasks. This paper describes MAKER, the first system that successfully solves a task with over one million LLM steps with zero errors, and, in principle, scales far beyond this level. The approach relies on an extreme decomposition of a task into subtasks, each of which can be tackled by focused microagents. The high level of modularity resulting from the decomposition allows error correction to be applied at each step through an efficient multi-agent voting scheme. This combination of extreme decomposition and error correction makes scaling possible. Thus, the results suggest that instead of relying on continual improvement of current LLMs, massively decomposed agentic processes (MDAPs) may provide a way to efficiently solve problems at the level of organizations and societies.

Figures (10)

• Figure 1: Orthogonal directions to scaling AI. The predominent approach to scaling AI is to make more and more 'intelligent' base LLMs. This paper introduces a framework and implementation of an orthogonal approach: MAKER, which solves the full task (described in Section \ref{['sec:results']}) with zero errors. In this figure, API cost per output token (as of 10/2025, from openai, anthropic, and together) is used as a proxy for intelligence, and consecutive error-free steps for base LLMs are computed from their per-step error rate (Figure \ref{['fig:single_step_rates']}b). Appendix \ref{['app:fig1_log_scale']} gives a log scale version of the plot.
• Figure 2: generate_solution
• Figure 3: MAKER error-free solve rate scaling laws resulting from Eq. \ref{['eq:solve_rate']}. ($a$) For a task with one million steps, MAKER, with first-to-ahead-by-$k$ error correction enables high probability zero-error solutions for practical values of $k$, even as the base per-step error rate approaches 1-in-10; ($b$) For the lower per-step error rates, in theory even a low $k$ allows scaling far beyond one million steps.
• Figure 4: MAKER cost scaling laws resulting from Eqs. \ref{['eq:k_min']} and \ref{['eq:mad_cost']}. ($a$) The value of $k$ required in first-to-ahead-by-$k$ voting to maintain a 0.9 solution probability for the full task increases logarithmically with the number of steps in the task; ($b$) The corresponding expected cost of running the system increases log-linearly. These plots illustrate the scalability of MAKER, in theory, to millions of steps and beyond.
• Figure 5: Task decomposition scaling laws resulting from Eq. \ref{['eq:overall_cost']}. ($a$) For a task with 1M steps, as the number of steps assigned to each agent increases (and thus the number of agents decreases), there is an exponential increase in the expected cost to complete the task with sufficient reliability. Notice that while the x-axis is $\log(.)$ scale, the y-axis is $\log(\log(.))$ scale. ($b$) As the size of the task scales, this pattern continues: setups where agents are assigned more steps incur orders-of-magnitude of additional cost.