Why Multi-Step AI Agents Compound Failure

A 95%-accurate agent step feels safe. It isn't. Chain ten of those steps and the run succeeds about 60% of the time. Chain twenty and you're at 36%. Nobody changed the model — the chain just got longer, and probability did the rest.

That gap is why an agent can ace a demo and then fall apart the week you ship it. The demo runs two or three steps. Production runs five, ten, twenty. We've watched it happen on our own builds, and the math behind it is simple enough to do on a napkin.

This is the quantitative cousin of a question we wrote about before — the reason 89% of AI agents never ship isn't the model. That post is about the qualitative demo-to-production gap: context, edge cases, the stuff a controlled demo hides. This one is narrower and colder. It's about why long chains fail even when every single step is good, purely as a matter of multiplication.

Here's the napkin version.

The failure math, in one line

Multiply the per-step success rates and you get the whole-run success rate. That's the entire idea.

If each step succeeds independently with probability p, and the run needs all n steps to land, the run succeeds with probability p to the nth power. The accuracy doesn't add up across steps. It multiplies down.

Here's what 95% per step does as the chain grows:

At 95% per step the run drops to about 60% by step 10 and 36% by step 20. At 90% per step it falls off a cliff — under 35% by step 10.

Run the numbers yourself. 0.95 to the 5th is about 77%. To the 10th, about 60%. To the 20th, about 36%. Drop the per-step rate to 90% and ten steps already put you under 35%. The curve is steep because exponents are steep.

You're optimizing the wrong number

The instinct, when an agent flakes, is to reach for a better model. Push per-step accuracy from 95% to 97%, ship the upgrade, move on. That instinct is aimed at the wrong variable.

The base of the exponent is your per-step accuracy. The exponent itself is the number of steps. And the exponent dominates. Going from 95% to 99% per step is a real engineering lift, and it buys you a 20-step run at about 82% instead of 36%. Cutting the same run from 20 steps to 5 buys you about 77%, for a fraction of the effort, by deleting work the agent didn't need to do.

Fiddler AI put a number on the surprise: an estimated 88% of enterprise agents that work in controlled demos fail when deployed to real workflows(opens in new tab). The same writeup notes that consistency is worse than single-run accuracy suggests — agent performance on one benchmark dropped from a 60% success rate on a single run to 25% over eight consecutive runs. That decay is the compounding curve showing up as run-to-run variance.

It also explains why bigger models keep disappointing on long tasks. Princeton researchers cited in that piece found reliability improved only modestly across 18 months of capability gains. Capability is the base. Reliability over a long chain is the exponent. You can move the base a lot and barely move the chain.

Why demos hide it

Demos are short on purpose. A demo that runs two or three steps sits at 86–95% success — it looks rock-solid because it is, at that length. As Flavius Dinu lays out in the math behind why multi-step AI agents fail in production(opens in new tab), demos hide the problem precisely because they show two to three steps, while production is five or more.

So the demo isn't lying about the steps it shows. It's lying by omission about the steps it doesn't. The buyer sees the happy path at chain-length three and reads it as 95%. Production is chain-length fifteen, and 95% to the fifteenth is a coin flip you keep losing.

This is the same trap we flagged in the kill-switch piece — build the kill switch before your AI agent ships — from the other direction. There the worry is a long chain doing damage with no stop. Here it's a long chain failing quietly because the failure was baked into the arithmetic before anyone wrote a line of code.

What actually moves the number

Three levers, in order of leverage. None of them is "wait for a better model."

Shorten the chain. Every step you delete shrinks the exponent, and the exponent is what hurts. Collapse three reasoning hops into one tool call. Pre-compute a value instead of having the agent derive it. Hand the agent a narrower task with fewer decisions. The cheapest reliability win is the step you never run.

Verify between steps. A check that catches a bad step and retries it resets the product — you're no longer multiplying one long fragile chain, you're multiplying several short reliable ones. This is why a 20-step run split into four verified 5-step segments behaves nothing like a raw 20-step run. The verifier doesn't have to be another model; often a cheap assertion ("did the file actually get written?", "is this JSON valid?") catches the failure before it propagates.

Put a human in the loop for the risky actions. Not every step deserves a gate. The ones that move money, delete data, or send messages to real people do. A human approval on the three or four irreversible actions in a chain converts a silent compounding failure into a caught one. The agent does the 90% that's reversible; you sign off on the 10% that isn't.

The pattern underneath all three: stop trying to make one long chain perfect. Make it shorter, segment it, and gate the parts that bite. We lean on this every time we wire an agent into something that touches production — it's how the same models that flake at twenty steps stay trustworthy at five.

How we think about it on our own builds

When we design an agent flow at Dimantika, the first question isn't "which model." It's "how many steps does this really need, and which ones are irreversible." That framing comes straight out of the math above.

A flow that drafts a blog post, scores it, and on a pass publishes it is three steps where one is irreversible. So the publish step is gated and the rest run free. A flow that touches billing gets a verifier after every state change, because a silent failure there is expensive and the chain is long enough that 95% per step isn't good enough on its own. The arithmetic tells us where to spend the engineering.

That's the whole point of doing the napkin math first. It tells you, before you build anything, where the chain will break and which steps deserve a guardrail. The model matters less than most teams think. What you do with the shape of the chain matters a lot more.

FAQ

Does a 95% accurate AI agent fail 5% of the time?

Only on a single step. Across a multi-step run it's worse, because the steps multiply. A 95%-per-step agent succeeds about 60% of the time over ten steps and about 36% over twenty, since the whole run needs every step to land. The single-step number flatters you; the chain is where reliability actually gets decided.

How do I make a long agent chain more reliable without a better model?

Attack the chain, not the base accuracy. Delete steps so the exponent shrinks, add cheap verification between steps so a failure gets caught and retried instead of propagating, and require human approval on the few irreversible actions. Cutting a run from twenty steps to five does more for whole-run success than a realistic model upgrade does, and it costs less engineering.

Why do AI agents pass demos but fail in production?

Demos are short, usually two or three steps, where a 95%-per-step agent looks near-perfect. Production chains run five steps or more, where the same per-step accuracy compounds down into frequent failure. The demo isn't faked; it just runs at a chain length where the failure math hasn't kicked in yet. The qualitative side of that gap — context, edge cases, missing guardrails — is its own problem, which we cover in the reason 89% of AI agents never ship isn't the model.