10.5Why long agent chains fail
An AI agent that gets each step right 95% of the time sounds dependable. Give it a task of twenty steps and it fails most of the time. Turn the dials below to see why small error rates compound, what a check between steps buys back, and why a model checking its own work buys back very little.
- 1Read
In 2025 the research group METR (Model Evaluation and Threat Research) timed people on software tasks and then set AI agents the same tasks. The agents of the day succeeded almost every time on tasks that took a person under 4 minutes, and less than 10% of the time on tasks that took a person more than about 4 hours. METR summarises an agent by the length of task it completes half the time; for the best model they tested, Claude 3.7 Sonnet, that was about 50 minutes, and the figure had been doubling roughly every seven months since 2019.
Toby Ord then showed that METR's results fit a very simple rule: an agent has a constant chance of failing in each minute of work, so its success rate halves every time the task gets a fixed amount longer, like a half-life. He notes it is unknown whether this holds beyond that task suite. The rest of this page builds the same rule out of steps, so you can see where it comes from.
- 2Set
Picture a task an agent does in a row of steps: read a file, call a tool, edit, run, and so on. Set how often a single step goes right, and how many steps the task takes.
- Whole task goes right
- 36%
- Longest task above 50%
- 13 steps
- 3Run
A hundred agents, one row each, attempt the task. Each step goes right or wrong at random with the chance you set. Nothing checks the work, so an agent that gets a step wrong does not know it: it carries on and reports the task as done.
- Right all the way
- Went wrong, carried on
- Right
- 39
- Wrong, handed in as done
- 61
Of 100 agents, 39 finished every step correctly. 61 got a step wrong without noticing and handed in a wrong result as if it were done.
- 4Plot
The chance the whole task goes right is the per-step chance multiplied by itself once for every step. That is a falling curve: each step takes the same share off whatever is left. The square marks your task.
Show as a table
Chance the whole task goes right against its number of steps, at 95% per step Steps Whole task succeeds 1 95% 5 77% 10 60% 15 46% 20 36% 25 28% 30 21% 40 13% 50 8% NoteA step that goes right 95% of the time sounds reliable. Twenty of them in a row go right only 36% of the time (0.95 multiplied by itself 20 times is 0.358). The task fails more often than it succeeds, and no single step looks like the problem.
The curve never flattens. Every extra step multiplies the chance by the same factor, so a long enough task fails almost surely, however good each step is.
- 5Check
Now put a check after every step: something outside the agent, like a test suite, a compiler or a schema, that looks at the result. It catches a share of the wrong steps and sends the agent back to try again, up to 2 times. If the step is still wrong after that, the run stops and says so, which is a failure but an honest one. The hundred agents below are the same ones as in step 3, with the same luck on every first try.
- Right all the way
- Went wrong, carried on
- Stopped by the checker
- Right
- 83
- Wrong, handed in as done
- 17
- Stopped
- 0
- Retries
- 86
Of 100 agents, 83 finished every step correctly. 17 got a step wrong without noticing and handed in a wrong result as if it were done. 0 were stopped by the checker after running out of retries, and the checker sent agents back for 86 retries in all.
- Goes right, no check
- 36%
- Goes right, with the check
- 81%
- Model calls per task
- 41.6
- 6Swap
Now change who does the checking. An independent check, such as a test suite, fails for its own reasons. A second call to the same model, asked whether the first call was right, tends to miss the same things the first call missed. Set how many of the model's mistakes are blind spots it cannot see in its own work.
- Independent check
- No check
Show as a table
Chance the whole task goes right against its number of steps, with an independent check and with no check Steps Independent check No check 1 99% 95% 5 95% 77% 10 90% 60% 15 85% 46% 20 81% 36% 25 77% 28% 30 73% 21% 40 66% 13% 50 59% 8% - No check
- 36%
- Independent check
- 81%
- Same model checks
- 42%
NoteSame number of checks, same cost, and most of the gain is gone. With these settings the independent check lifts the task from 36% to 81%; the model checking itself reaches only 42%, keeping 14% of the gain. A checker can only catch the mistakes it can see, and a model reviewing its own work shares the blind spots that caused them.
The published record is harsher than this toy. Huang and colleagues (2024) found that asking GPT-4 to review and revise its own answers to grade-school maths problems lowered its score from 95.5% to 89.0% over two rounds, at five calls instead of one. The same loop improved results only when the correct answer was used to decide when to stop: an outside check, smuggled in. That is the argument of why self-critique loops fail.
- 7Split
Instead of one long chain, split the task into independent pieces, each a short chain of its own, with a test at the end of each piece that catches 80% of wrong pieces (the catch rate from step 5) and reruns a failed piece up to 2 times.
- No tests
- 36%
- Test each piece
- 78%
- Model calls per task
- 29.1
NoteCutting the task into pieces changes nothing by itself: all 20 steps still have to go right, so with no tests the chance stays at 36% however many pieces you make. What helps is a test at each seam that can send one short piece back. Here that reaches 78% with 29.1 calls, against 81% and 41.6 calls for a check after every step. A short piece is cheap to redo, and its result is easy to test.
- 8Go
When you design an agent, walk each step and name the thing outside the model that decides whether that step worked. Where you cannot name one, keep the chain short.
10.5.1How the model works
This is a toy. Every attempt at a step goes right with the same chance p, independently of every other attempt, so a task of n steps with no checks goes right with chance pn. Real steps are not independent: one bad step often makes the next one harder, and some steps are much riskier than others. Independence is the simplifying assumption that makes the arithmetic visible.
The checker sees each attempt. It catches a wrong one with its catch rate and never flags a right one. A caught step is retried up to 2 times; still wrong after that, the run stops. When the same model checks itself, a share of its mistakes are blind spots that checker never catches, so its real catch rate is the catch rate times the share it can see. Model calls count each attempt and each check as one call. In step 7, a piece of m steps behaves like one big step that goes right with chance pm, and its test works like the checker. The percentages in the readouts come from these formulas; the hundred rows are a random draw, seeded from the link, so they wander around the formula the way a real sample would.
The model leaves out a checker that wrongly rejects good work, the cost of a retry that is longer than a step, and the way a self-reviewing model can talk itself out of a right answer. The first two would cost both kinds of checker. The third is the one Huang and colleagues measured, and it would make the self-check look worse still.
10.5.2Sources
- Thomas Kwa, Ben West, Joel Becker and others (METR), Measuring AI Ability to Complete Long Software Tasks, arXiv 2503.14499, 2025.
- METR, Measuring AI Ability to Complete Long Tasks (blog post, 19 March 2025). The near 100% under 4 minutes and under 10% over about 4 hours figures in step 1 are from this post.
- Toby Ord, Is there a half-life for the success rates of AI agents?, arXiv 2505.05115, 2025.
- Jie Huang, Xinyun Chen, Swaroop Mishra and others, Large Language Models Cannot Self-Correct Reasoning Yet, ICLR 2024 (arXiv 2310.01798). The grade-school maths figures in step 6 (the GSM8K benchmark, Grade School Math 8K) are from its tables 2 and 3.