Agent chain reliability calculator: compound success and retries
Updated November 2026
A chain of agent steps succeeds only when every step does, so its reliability is the per-step rate multiplied by itself once per step. A ten-step chain at 95 percent per step finishes about 60 percent of runs. Giving each step one retry raises that to 97.53 percent, but only for steps that are safe to repeat.
| Run success rate without retries | 59.87% |
|---|---|
| Run success rate with retries | 97.53% |
| Expected failed runs per 100 without retries | 40.13 runs |
| Expected failed runs per 100 with retries | 2.47 runs |
What does this calculator work out?
You give it the number of steps in a run, the chance that one step succeeds, and how many retries each step gets. It returns the chance that the whole run succeeds without retries and with them. It also returns the expected number of failed runs out of every 100 for both cases.
A chain of agent steps fails if any one step fails, so small per-step losses multiply. Anthropic makes the same point in its multi-agent research write-up: because errors compound, minor issues for traditional software can derail agents entirely.
What do you enter?
- Steps (count): The number of agent steps a run needs to complete one after another. Count each tool call or handoff that must succeed. Default 10, allowed range 1 to 200.
- Per-step success rate (percent): How often one step finishes correctly on the first attempt. Take it from your own logs by dividing successful step attempts by all step attempts. Default 95, allowed range 0 to 100.
- Retries per step (count): How many extra attempts a step gets after a failure. Zero means a single attempt. Default 1, allowed range 0 to 10.
How is the result calculated?
Without retries, the run succeeds only if every step succeeds, so the per-step rate is multiplied by itself once for each step. With retries, a step fails only if the first attempt and every retry all fail. That chance is the failure rate raised to the power of attempts, where attempts are retries plus one. Subtract it from 1 to get the step's success rate with retries, then multiply that across the steps in the same way. The failure figure is 100 minus the run success rate in percent, read as expected failures out of every 100 runs.
run success, no retries = p ^ n step success with retries = 1 - (1 - p) ^ (r + 1) run success, retries = (1 - (1 - p) ^ (r + 1)) ^ n failures per 100 runs = 100 - run success in percent
p = per-step success rate as a fraction n = steps r = retries per step ```
Worked example
With the defaults of 10 steps, 95 percent per step and 1 retry, the run succeeds 59.87 percent of the time without retries, which is 40.13 failed runs per 100. With one retry per step, each step succeeds with probability 1 minus 0.05 squared, which is 0.9975. Ten of those in a row give a run success rate of 97.53 percent, or 2.47 failed runs per 100.
What does the result not tell you?
The arithmetic is illustrative and runs only on the numbers you enter, so it describes your inputs rather than measuring your system. The model treats each step as failing on its own, so one failure does not make the next more or less likely. Real chains often break that assumption. A shared outage, a bad tool or a corrupted piece of context can make a step's retries fail along with its first attempt, and the success rate with retries will then be lower than the calculator shows. AWS notes that when failures come from overload, retries that increase load can make matters significantly worse and can delay recovery by keeping the load high.
Retries only help when repeating the action is safe. AWS gives its view that APIs with side effects aren't safe to retry unless they provide idempotency. Temporal defines idempotence as performing an operation multiple times with the same result as performing it once. A step that sends an email or charges a card needs that guarantee before you count its retries.
Which sources does this page use?
- How we built our multi-agent research system \ Anthropic (anthropic.com), reviewed November 2026
- Timeouts, retries, and backoff with jitter (aws.amazon.com), reviewed November 2026
- Activity Definition (docs.temporal.io), reviewed November 2026
What do people ask about this calculator?
Why does a 95 percent step give such a low run success rate?
Each step is another chance to fail, and the chances multiply. Ten such steps leave the run at 59.87 percent. See debugging multi-agent systems for finding which step fails most.
Should I just add more retries?
More retries raise the figure in this model, but they cost time and add load, and they are unsafe for steps that cannot be repeated. For runs that keep going without end, see preventing agent loops.
Does a central orchestrator change the numbers?
The formula applies to any chain where every step must succeed, whatever coordinates it. What the central orchestrator pattern does with a failed step decides whether that step is retried or the run stops.