Errors compound multiplicatively, so 0.9 to the sixth is about 0.53; chain length is exponential cost, and cutting hops or adding a final critic beats grinding up per-step accuracy.
Imagine a relay where six people in a row each have to copy a sentence by hand, and each person gets it right nine times out of ten. It feels like the message should arrive almost perfectly, because every person is so good. But the only way the final sentence is right is if all six people happened to get it right that round. Multiply 0.9 by itself six times and you get about 0.53. The message arrives correctly only a little better than half the time. That is why teams that look strong at every station can still fail more than half their tasks. Shortening the relay or adding one person who checks the final sentence against the original both help a lot more than trying to make each person slightly more accurate.
Concept explanation~2 min read
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Concept explanation~2 min read
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Multi agent chains have a deceptively simple failure mode: errors compound. The whole task succeeds only when every hop succeeds, and the probabilities multiply. That fact alone explains a large share of the disappointment that production teams experience when they ship a multi agent architecture that looked great in demos.
This question gives you the smallest possible version of the calculation: six agents, each 90 percent correct, and asks for the end to end rate. The number is 53 percent. The lesson is what to do about it.
The multiplicative formula and the shape of the curve
For a chain where each step succeeds independently with probability p, and the task succeeds only when all steps succeed, end to end accuracy is the product of per step probabilities. For a uniform chain of length n at rate p, this collapses to:
Plug in p equal to 0.9 and n equal to 6 and you get about 0.531. That is the number that surprises engineers who reason additively. 'Six steps that are each 90 percent good must be roughly 90 percent good overall' is wrong by almost 40 percentage points.
The slope is the headline
The interesting thing is not the value at n equal to 6; it is how fast the value moves as n changes.
- n equal to 4: 0.656
- n equal to 6: 0.531
- n equal to 8: 0.430
- n equal to 10: 0.349
Each additional hop costs roughly 5 to 6 percentage points of end to end accuracy at the 90 percent per step rate. That is the exponential biting. A team that decides to 'add a planning agent and a routing agent and a formatting agent' to a previously working chain is paying a real reliability tax.
Situations where this technique stops working.
2–4 min · Everything important, quickly.
# A back of envelope tool: end to end accuracy under multiplicative compounding
from functools import reduce
from operator import mul
def chain_accuracy(per_step):
return reduce(mul, per_step, 1.0)
uniform_chain = [0.9] * 6
print(round(chain_accuracy(uniform_chain), 3)) # 0.531
# Lever 1: cut hops
shorter = [0.9] * 4
print(round(chain_accuracy(shorter), 3)) # 0.656
# Lever 2: push per step accuracy up
stronger = [0.95] * 6
print(round(chain_accuracy(stronger), 3)) # 0.735
# Lever 3: add a terminal verifier that recovers some fraction of failures
base = chain_accuracy([0.9] * 6)
verifier_recovery = 0.6 # critic catches 60% of compounded errors
recovered = base + (1 - base) * verifier_recovery
print(round(recovered, 3)) # 0.812| Intervention | Effect on a 6 hop 90 percent chain | Cost |
|---|---|---|
| Baseline (6 hops, 0.9 each) | 0.531 end to end | Six agent calls |
| Cut to 4 hops | 0.656 | Lose two agents, redistribute work |
| Per step 0.9 to 0.95 | 0.735 | Heavy per agent prompt and eval work |
| Add terminal critic (60 percent recovery) | 0.812 | One extra agent call per task |
| Cut to 4 hops + add critic | 0.862 | Structural redesign plus one call |
Real products, models, and research that use this idea.
- Anthropic's 2024 multi agent research blog described 'compounding error' as the dominant failure mode in long agent chains, motivating shorter trajectories with verification hops.
- LangChain's 2025 multi agent design guidance recommends fewer than four sequential hops and a terminal critic for production reliability above 80 percent.
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would the analysis change if you modelled correlated errors instead of independent ones?
Introduce a correlation coefficient between adjacent agents; the joint failure probability becomes higher than the product, so end to end accuracy drops below the multiplicative floor. Use a small Monte Carlo to estimate the gap on a real workload.
Red flags & common mistakes
The phrases that signal junior thinking. Click to expand.
Red flags & common mistakes
The phrases that signal junior thinking. Click to expand.
Reasoning additively about chain accuracy, so a team of six 90 percent agents feels like it should be 'about 90 percent good' instead of 53 percent good, and then debugging individual agents when the architecture itself is the problem.
60 second bullets to scan on the way to the call.
The multiplicative formula for end to end success in a chain
Why six 90 percent agents land near 53 percent, not 90 percent
Primary sources. Browse if you want the original framing.
Same topic, related formats. Practice these next.