Your agent nailed the demo and stalled in production. Here is why: a 95%-reliable step run 20 times in a row succeeds only 36% of the time. Not 95%. Not 90%. Thirty-six percent. AI agents fail because errors multiply across steps instead of adding, and one step that succeeds 95% of the time collapses to about 36% across a 20-step chain, because 0.95 raised to the 20th power equals 0.3585.
This is the compounding-error problem: in a sequential agent, end-to-end success equals the product of per-step success rates (p to the power n), not their average.
That single fact explains most of the gap between a slick agent demo and a production agent that stalls. The demo shows one good step. The product runs a long chain where every step has to land. This post works through that math, why benchmark scores hide it, what the failure looks like on a real task, and the design moves that actually shorten the chain.
AI agent compounding errors: the multiplication math
When you chain independent steps that each must succeed, the probability the whole chain succeeds equals the product of every step's success probability, not the average. Reliability is multiplied, not averaged. MindStudio puts it plainly: chain five agents at 95% reliability each and end-to-end success collapses to 77%, since 0.95 to the 5th power equals 0.7737.
The decay is exponential. Each step you add does not subtract a fixed penalty. It multiplies what remains. Going from 5 steps to 20 steps at the same 95% per-step reliability cuts your success rate from 77% to 36%. The table below shows how fast the floor drops at three per-step reliability levels.
Find your per-step reliability, find your step count, read the survival rate.
| Steps in chain | 90% per step | 95% per step | 99% per step |
|---|---|---|---|
| 1 step | 90.0% | 95.0% | 99.0% |
| 5 steps | 59.0% | 77.4% | 95.1% |
| 10 steps | 34.9% | 59.9% | 90.4% |
| 20 steps | 12.2% | 35.8% | 81.8% |
Read the table by column. At 90% per step, a 20-step task is essentially a lottery ticket at 12.2%. At 95%, you barely clear a third. Only the 99% column survives a long chain, holding 81.8% across 20 steps. That gap between 95% and 99% per step looks tiny on a benchmark sheet and decides whether a 20-step agent works at all.
Ship a step at 95% and run it 20 times, and you lose two out of three tasks. The model never got dumber. The chain just got longer.
What the trap looks like on one real task
Numbers in a table feel abstract until you watch them eat a real workflow. Take an invoice-processing agent: read an email, extract the vendor, match it to a record, pull the PO, compare line items, check the total against the contract, flag mismatches, post to the ledger, notify approvers, and write the audit log. Count the discrete steps and you land near twelve.
Now say each step works 97% of the time. That is a strong per-step number, better than many production agents hit on messy inputs. End-to-end the agent still finishes only 69% of invoices, because 0.97 to the 12th power equals 0.6938. Roughly three in ten invoices derail somewhere, and not always at the same step. The demo with one clean invoice looked flawless. The Monday batch of 400 invoices loses 120 of them to the exponent.
Worse, the failures are quiet. The agent extracts the wrong vendor in step 2, matches a plausible-looking record, and every later step builds on the bad foundation with full confidence. No crash, no stack trace. A wrong number flows into the ledger and looks exactly like a right one until a human catches it weeks later.
Why benchmark scores mislead about real agents
Most benchmark numbers measure single-step accuracy, so they describe one good move, not a chain of them. A model scoring 95% on a task benchmark is reporting the top row of the table. The agent built on it has to survive the bottom row, and nothing on the scoreboard warns you about that drop.
METR measured what happens when tasks get longer instead of harder. Their finding: frontier models hit almost 100% success on tasks a human finishes in under 4 minutes, but succeed under 10% of the time on tasks that take a human more than 4 hours. Same models, same intelligence. Only the chain length changed.
METR also frames capability as a task-completion time horizon: the length of task a model can finish autonomously at 50% reliability. They report that horizon has been doubling about every 7 months for the last 6 years. The headline reads as raw capability gain, but the underlying metric measures reliability over duration precisely because long chains are where agents break.
When you read a benchmark, ask one question: is this a single-step score or an end-to-end task score? A single-step score tells you the per-step number to plug into the table. It does not tell you whether your agent's chain will finish.
Here is what most write-ups get wrong
Two numbers dominate the 2026 coverage of agent failure. Gartner predicts that more than 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. An MIT study circulated alongside it found roughly 95% of enterprise AI pilots delivered no measurable return. Most write-ups stack those two stats next to a line about hype and stop there.
Here is what most write-ups get wrong: they treat the 40% cancellation rate as a strategy failure (wrong use case, weak ROI, hype). A large part of it is arithmetic. A pilot that demos at 95% per step and then ships a 15-step or 20-step workflow lands in the 30-to-40% success band by the math alone, no bad strategy required. The project gets canceled because end-to-end success was never going to clear the bar, and the cancellation reads as "unclear business value" on the slide. The exponent showed up in the budget review months before anyone named it.
Half the canceled agent projects did not pick the wrong problem. They picked a chain too long to survive its own per-step error rate.
Why AI agents fail: the 4 real failure modes
The multiplication rule explains the headline number. The actual failures show up as four recurring patterns, and each one quietly lowers per-step reliability or lengthens the chain.
Error accumulation
Most agent errors are not loud crashes. They are plausible wrong outputs. The agent makes a small mistake in step 2, produces something that looks correct, and every later step builds confidently on the bad foundation. Prodigal describes the same effect in production: small error rates at each step multiply into large failure rates overall, and the chain absorbs a wrong-but-plausible early step instead of catching it.
Context drift
Long chains carry long context. As the conversation grows, the agent dilutes earlier constraints, restates them imperfectly, or pushes them out of the window. The agent re-derives facts it already knew and sometimes derives them differently the second time. Every re-derivation is another step, and every step is another multiplication against your success rate.
Tool and parse errors
Agents act through tools, and real tools return rate limits, malformed responses, timeouts, and schema mismatches. MindStudio documents these as a core failure mode: a code execution environment times out and the agent treats the absence of output as a successful result, or a rate limit silently drops a call and the agent fabricates the data it expected back. Because the agent reasons about tool output as plain text, it proceeds instead of flagging the failure, so real per-step reliability on tool-heavy actions runs below the clean benchmark number. Drop even a couple of points of per-step reliability and the bottom-row numbers in the table fall further.
No recovery path
The math above assumes a failed step means a failed task. That holds only without recovery. An agent with no checkpoint, no retry, and no verification has exactly one shot per step, so the raw product is its real success rate. Recovery is the lever that breaks the multiplication, which is the whole point of the next section.
Three levers that break the exponent
You beat compounding errors three ways: raise per-step reliability toward 99%, cut the number of steps, or add recovery so a failed step does not kill the task. The strongest systems do all three.
- Cut steps first. Fewer multiplications beats every other fix. A short chain of mediocre steps beats a long chain of great ones. Collapse three brittle reasoning hops into one tool call with a clear schema, and merge redundant planning passes. A 5-step chain at 95% (77%) outperforms a 20-step chain at 95% (36%) without any change to the model.
- Add checkpoints. Save verified state at known-good points so a failure restarts from the last checkpoint instead of step zero. This turns one long fragile chain into several short ones, and short chains hold the top rows of the table.
- Verify between steps. A cheap validation check after a step (schema match, range check, a second model confirming the output) catches plausible-wrong results before the chain absorbs them. Catching and retrying a step raises its effective reliability toward the 99% column.
- Make tools idempotent. If a step can safely run twice, you can retry on failure without corrupting state. Idempotency is what makes retries free, and free retries are what let a verify-and-retry loop reach the 99% column.
- Use external memory. Anything the agent can read instead of re-derive is a step removed from the chain. Stored facts, prior decisions, and user context do not need to be reconstructed each run.
Why verify-and-retry pays off the most
Recovery is worth its own math because the payoff is large and counterintuitive. Take a single step that works 90% of the time. Add a verification check and one independent retry on failure, and its effective reliability jumps to 99%, because the only way to still fail is to miss twice: 1 minus (0.10 times 0.10) equals 0.99. One retry moved a 90% step into the 99% column.
Push that across a chain and the table inverts in your favor. A 20-step agent at a true 90% per step survives only 12% of the time. Wrap each step in verify-and-retry so each lands at an effective 99%, and the same 20-step chain holds 82%, because 0.99 to the 20th power equals 0.8179. You changed no models and added no capability. You only refused to let any single step fail silently.
Reframe the goal. You are not trying to make the model smarter. You are trying to make the chain shorter and the steps recoverable. Reliability is multiplied, not averaged, so both moves directly attack the exponent in the success formula.
Where external memory shortens the chain
A large share of agent steps are reconstruction: re-reading earlier context, re-establishing user preferences, re-deciding things the agent already decided in a prior run. Remove that reconstruction and you remove steps, which is the most reliable way to move up the table.
This is the practical role of an external memory layer. MemX (memx.app) stores facts, decisions, and context outside the model so the agent reads them back instead of re-deriving them. A preference recalled from memory is one lookup, not a multi-step chain of inference that can drift. A higher end-to-end success rate at the same per-step reliability falls out for free.
External memory is not a fix for a model that gets steps wrong. It will not turn a 90% step into a 99% step. What it does is cut the count of steps that have to happen at all, and on a 20-step chain that is the difference between the 36% row and something you can ship.
Two numbers decide your agent: how many steps, and how often each one recovers. Shrink the first, raise the second.
01Why do AI agents fail even when the model is accurate?
Because errors multiply across steps. A 95%-accurate step run 20 times in a chain succeeds only 36% of the time, since 0.95 to the 20th power is 0.3585. The model can be strong on each step and still fail the overall task.
02What is the compounding error problem in AI agents?
It is the fact that a multi-step chain succeeds only if every step succeeds, so the total success rate is the product of each step's reliability, not the average.
03How many steps before an agent becomes unreliable?
At 90% per-step reliability, a 10-step chain drops to about 35% (0.9^10). At 95% it holds about 60% (0.95^10=0.599). Only near 99% per-step do 20-step chains stay above 80% (0.99^20=0.818).
04Do benchmark scores predict agent reliability?
Not directly. Most benchmarks measure single-step accuracy, one move in isolation. METR found frontier models hit almost 100% success on tasks humans finish in under 4 minutes, but under 10% on tasks taking over 4 hours, so longer chains break what benchmarks rate highly.
05How do you make AI agents more reliable?
Shorten the chain, add checkpoints so failures restart from a known-good state, verify outputs between steps, make tools idempotent so retries are safe, and use external memory so the agent re-derives fewer facts. Each move attacks the multiplication directly.
