One wrong step does not stay one mistake. In a study of 2,518 agent runs, a single wrong step made the next step roughly 11 to 14 times likelier to fail [1]. The agent recovered from its first mistake in only 30.5% of runs. In 38.5% of them, it never noticed the error at all [1].

The big picture:

Most work on agent uptime targets the model. The 2026 evidence points at the seams between steps instead.

A catalogue of 150 production incidents shows the failures cluster at component boundaries. An error crosses a boundary, spreads, and quality drops with no alarm raised. Parts that are each correct agree on a wrong answer together [3].

What strikes me is where the controls that worked sit. They act on the seam. Circuit breakers cut cascade spread by 89% in controlled tests. Output gates caught 73% of the quiet quality loss, and isolating a part cut the blast radius by 64% [3]. Teams that run three or more of these controls cut their mean time to recovery (MTTR) by 71% [3].

None of that shows up in the final output. One operator’s eight-week review of 22 incidents found each one had a silent phase: the system was failing while every automated check stayed green [2]. People reading the output caught about 70% of those errors, not the tests [2].

A small fault turns into an outage by simple sums. Google’s site reliability book runs the math: when 5% of requests stall on a 100-second deadline, they eat a frontend’s whole 1,000-thread pool. Only 19.6% of requests get served, so the error rate lands at 80.4% [5]. For an agent, that shared pool is the chain of steps that trust the ones before it.

By the numbers

  • 11 to 14 times — Next-step penalty: After one wrong step, the next is roughly 11 to 14 times likelier to be wrong [1].
  • 30.5% — Recovery rate: The share of runs where the agent recovers from its first error. In 38.5% of runs it never spots the mistake at all [1].
  • 89% — Cascade spread cut: How much circuit breakers reduced error spread in controlled tests, against 64% for isolating a part and 73% for output gates [3].
  • 3.1% — Containment without enforcement: Drop quarantine and rollback and containment falls to 3.1%, barely better than no defense at all [4].

What I’d watch:

I keep coming back to the order of the controls, because the test data is blunt. Taking out screening and verification lowers containment. Removing quarantine and rollback lowers it further [4]. Screening with no enforcement spent 34,991 tokens, the most of any setup, and contained almost nothing [4].

I am watching where teams put the gate and whether it actually stops a step.

  • A gate between stages: A check on one stage’s output before the next stage reads it. That is the cheapest place to stop an error compounding.
  • A quarantine path: Somewhere for a suspect step’s output to go that is not the next step’s input. Rollback is the control whose removal costs the most containment [4].
  • A containment rate: Scoring a release by the share of injected faults that never reached the next stage. That beats judging a run by whether the task passed [4].
  • A small step-checker: A four-billion-parameter model that labels each step right or wrong beat six frontier judges at finding the first mistake [1]. I want to see how many teams run a check like that against their own traces, rather than calling a bigger model.

One more signal is worth tracking. A survey found 41.1% of engineers hit agent trouble daily or more, and their top blocker is tracking state [6]. That matches the rest of this evidence, just seen from the other end.

The catch

The figures here point a direction; they are not a service-level agreement. My read is that the containment ladder is a shape worth copying, not a promise.

Three limits stand out. The 11 to 14 times penalty comes from lab runs, not live traffic [1]. The fault-injection percentages come from controlled tests, not field telemetry [3]. The test spreads are huge, with one setup swinging by 35 percentage points, so 3.1% is a direction and not a precise estimate [4].

The survey carries a softer bias. A company that sells durable execution, the exact thing its respondents say they lack, paid for the research [6]. The finding lines up with the other data, but I would not quote it as neutral.

The last caveat is the math. The 80.4% example assumes nothing else goes wrong [5]. Real systems shed load, time out early, or fall back to a cache. Containment is the extra assumption. Without it, a small fault is free to become an outage.

At a glance

  • The Big Shift: Agent uptime is being measured in the wrong place. The 2026 evidence puts the failure at the boundary between steps: one wrong step makes the next roughly 11 to 14 times likelier to fail, and most runs never recover.
  • Why It Matters: Boundary controls have measured effects, including 89% less cascade spread, a 64% smaller blast radius, and 71% faster recovery for teams that run three or more of them. They cost less than the outage they prevent.
  • What I’d Watch: Whether containment becomes a measured number rather than a claimed pattern. The signals:
  • A stage gate: A check on a stage’s output before the next stage reads it, which stops an error from compounding.
  • A containment rate: The share of injected faults that never reach the next stage, scored per release.
  • A small step-checker: A cheap model that labels each step right or wrong, beating much larger models at finding the first mistake.
  • The Catch: Every figure here is bounded. The lab runs are not production, the test swings by tens of points, the postmortem review is one operator’s system, and the survey was paid for by a vendor.

Related reading

Sources

[1] Salman Rahman et al., “Locating Hidden Failures Makes Long-Horizon Agents More Reliable” (Traverse), arXiv:2609.17930, 2026-09-15 — 2,518 trajectories and 6,967 mistakes classified into 78 failure types; the 11 to 14 times next-step compounding, recovery in 30.5% of runs, non-detection in 38.5%, and the four-billion-parameter “Scout” verifier that beat six frontier judges (https://arxiv.org/html/2609.17930v1) [2] Wei Wu, “When Errors Become Narratives: A Longitudinal Taxonomy of Silent Failures in a Production LLM Agent Runtime”, arXiv:2606.14589, 2026-06-12 — an eight-week window (2026-04-09 to 2026-06-02) with 22 incidents, every one carrying a silent phase, one meta-pattern appearing at least 28 times, roughly 70% found by human observation, and the 0% ex-ante / 87% ex-post governance audit (https://arxiv.org/html/2606.14589v1) [3] “Compound AI System Reliability: A Failure Taxonomy and Resilience Pattern Catalog from 150 Production Incidents”, arXiv:2610.02503, 2026-10-01 — 150 incidents, 23 failure modes across five categories, and controlled fault-injection effects: 89% less cascade propagation, 73% of silent degradation caught by output gates, 64% blast-radius reduction from isolation, and 71% off mean time to recovery at three or more patterns (https://arxiv.org/html/2610.02503v1) [4] Yizhe Xie, Congcong Zhu, Xinyue Zhang et al., “From Spark to Fire: Modeling and Mitigating Error Cascades in LLM-Based Multi-Agent Collaboration”, arXiv:2603.04474v2, 2026-05-11 — the containment ablation (14.4% ± 35.2 without screening and verification, 3.1% ± 10.1 without quarantine or rollback, 2.2% ± 14.7 with no defense) and the no-blocking variant’s 34,991 tokens at 85.7 ± 21.0 seconds (https://arxiv.org/html/2603.04474v2) [5] Google, “Site Reliability Engineering”, chapter 22, “Addressing Cascading Failures” — the worked example in which 5% of requests sitting on a 100-second deadline consume 5,000 thread-seconds of a 1,000-thread frontend, leaving 19.6% of requests served and an 80.4% error rate (https://sre.google/sre-book/addressing-cascading-failures/) [6] Temporal, “The State of Development 2026” — 554 respondents surveyed 2026-04-29 to 2026-05-25; 41.1% meet agent issues daily or more, 9.0% say continuously, and the top blocker to wider use is tracking state (https://temporal.io/reports/state-of-development-2026)