The number your accuracy metrics are hiding
When you measure per-step accuracy, you are measuring the probability that a single step succeeds. That feels like the right signal. It is not the right signal for a multi-step agent, because steps are not independent events and their probabilities compound.
The arithmetic is straightforward. If each step in a 10-step workflow succeeds 85% of the time, and each step depends on the previous one reaching a correct state, the probability that all 10 steps succeed is 0.85 raised to the power of 10. That is approximately 0.197. Your agent completes the task correctly about one time in five, even though every individual step looks healthy in your dashboard.
This is not a model quality problem in isolation. It is a measurement problem. Per-step accuracy tells you about local performance. End-to-end task completion rate tells you whether the agent is actually doing what you deployed it to do.
The gap between those two numbers is where most production failures live. A 2026 analysis of 73 real production agent incidents found that agents failed silently in ways traditional monitoring missed entirely, with failures stacking across multiple layers rather than clustering at any single point. No infrastructure-level alert fires when a reasoning step silently degrades.
How error cascades work in practice
Silent failure at one step does not stop the agent. The agent continues, carrying a corrupted or incomplete state forward into every subsequent step. Each downstream step then runs on bad inputs, compounding the original error rather than containing it. By the time the workflow produces an output, the failure may be invisible in any individual span.
Cursor's customer support agent demonstrated this clearly in April 2025. When retrieval returned no authoritative data, the agent fabricated a device login policy that did not exist. The model completed its step, the workflow continued, and the fabricated answer reached customers. No step appeared to fail. The output was confidently wrong. The result was subscription cancellations and public coverage on Reddit and Hacker News before the company identified what had happened.
The same pattern, operating at much larger scale, contributed to a six-hour Amazon outage in March 2026. AI agents acting on inferences from outdated internal wiki documentation cascaded their errors across checkout and account access systems, blocking millions of customers. Post-incident response included additional senior-engineer review requirements and renewed human-in-the-loop controls. The agents had passed pre-deployment evaluation. They failed when embedded in the actual workflow.
This pattern appears consistently in deployment data. According to a March 2026 enterprise review, 60% of production agent failures trace back to data quality, context gaps, or governance failures rather than model capability. Agents pass staging evaluations and fail in production because staging does not reproduce the data conditions the live workflow encounters.
What evaluation infrastructure actually catches
The difference between agents that improve and agents that silently degrade is whether your evaluation infrastructure measures trajectories rather than snapshots.
Motorway built a production evaluation pipeline for its dealer stock search agent in July 2026, working with AWS to measure tool selection accuracy, task completion rate, and query correctness across multi-step workflows. Before the pipeline, the agent returned incorrect results in roughly 1 in 8 queries. After instrumenting the full trajectory, tool selection accuracy rose from 87% to 98%, task completion from 82% to 96%, and issue detection time dropped from hours to minutes. The step-level metrics had not revealed the problem. The end-to-end trajectory did.
Trajectory evaluation means recording every span in a workflow, scoring each one, and then evaluating whether the sequence of decisions produced a correct final state. Three specific capabilities make this work:
- Failure mode tracing: when an end-to-end run fails, the trace shows which step produced the corrupted state and what the agent's reasoning was at that point. Without this, your team debugs by inference rather than evidence.
- Regression gates in CI/CD: each code or prompt change runs against a fixed test suite that checks end-to-end completion rate, not just unit-level step accuracy. A change that improves step 3 accuracy but drops end-to-end completion by 4 points fails the gate.
- Behavioural schema validation: the agent's sequence of actions is checked against a defined activity schema on every run. A step that succeeds technically but violates the expected action sequence is flagged before it reaches production. You can read more about designing these evaluation gates in our guide to validating agent behaviour against expected outcomes.
Anthropic's own internal deployment illustrates the ceiling this creates. As of June 2026, the automated evaluation layer caught approximately one-third of historical outages that would otherwise have reached production, and Claude's success rate on complex engineering tasks climbed to 76% over six months. Continuous evaluation against defined outcomes, not periodic manual review, drove that improvement.
Allianz's seven-agent ceiling and what it took to hold it
Allianz's Project Nemo is a seven-agent claims automation system processing natural catastrophe claims in Australia. Specialized agents handle coverage, weather data, fraud detection, payout calculation, and audit, with a human claims professional reviewing the audit summary before final authorization. The system completes workflows in under five minutes. Human oversight is structurally embedded at the final step rather than applied ad hoc.
What makes this work at production scale is that each agent in the orchestration has a defined scope and a defined output contract. Multi-agent orchestration introduces a compounding reliability problem: if seven agents each run at 90% step accuracy and each agent runs five steps, the end-to-end completion probability across the full pipeline drops substantially. Allianz contains this through specialization, explicit handoff validation, and a mandatory human review gate. The audit agent does not just summarize. It validates that the preceding agents' outputs are internally consistent before passing control to the human reviewer.
This is the structural answer to the compounding problem: bounded agent scope, validated handoffs, and evaluation gates between agents, not just within them. Our guide to detecting agent quality decay in production covers how to instrument these handoff points specifically.
The observability-without-evaluation gap
A 2026 LangChain survey of more than 1,300 practitioners found that 89% had implemented observability for their agents, but only 52% had implemented evaluations. Observability tells you what the agent did. Evaluation tells you whether what it did was correct. Running one without the other means you have complete logs of a failure you cannot characterise.
Prefactor instruments agents via SDK and records spans at each step, then scores quality and risk against defined schemas. The span record gives you the trace; the scores give you the signal. Evals and observability serve different purposes, and the evaluation layer is the part most teams skip because it requires defining what correct looks like before you can measure deviation from it.
That definition is the work. Once it exists, the gap between 85% per-step accuracy and 65% end-to-end success becomes a solvable engineering problem rather than a production surprise.
Where to start
Instrument one agent end-to-end before you instrument all of them. Define what a correct final state looks like for that agent's task, run a fixed evaluation set against the full trajectory, and record where failures originate in the step sequence. Once you have that baseline, regression gates in CI/CD and handoff validation follow naturally.
Start evaluating your agents and read the docs for instrumentation guides and schema validation setup.