At 95% accuracy per step, a 20-step agent has only 35% real success: errors multiply (p^n), they don't add up. The cure isn't a smarter model, but raising per-step reliability and shortening the chains.
An agent that gets it right 95% of the time sounds like a dream hire. Picture bringing it on: it almost never fails, it slips up one move in twenty, it's practically perfect. Now hand it a real task — research, decide, call an API, transform the data, write the result, verify — and watch that flawless 95% crumble into a coin flip that's worse than a coin flip. The demo was honest. The agent didn't lie. What lied was the arithmetic in your head, because you assumed errors add up when in reality they multiply. This is the essay on the cruelest — and most ignored — law in agent engineering.
Lusser's Law: why a chain is only as strong as the product of its links
In the 1950s, a German engineer named Robert Lusser formulated an uncomfortable law for serial systems: when N components all have to work for the whole to work, total reliability is the product of the individual reliabilities — not the average, not the minimum. The formula is brutally simple: p to the power of n. If each step succeeds with probability p and the task requires n chained steps where each one depends on the last, end-to-end success is p^n. Lusser derived it working on V-2 missiles, systems where a single faulty link turned the entire machine into flaming scrap. Seventy years later, the same law governs something Lusser never imagined: an AI agent reasoning step by step.
Do the math and the smile freezes on your face
Let's plug in numbers at 95% per step, that figure that sounds like an A-plus. Five steps: 0.95^5 = 77%. You've already lost nearly a quarter of your runs. Ten steps: 59%. You've just crossed the line where most of your runs fail more often than a mediocre worker. Twenty steps: 35%. Your agent with 95% accuracy per step completes the full task one time in three. Fifty steps — a truly ambitious agentic flow, with tools, branches and checks — lands at a devastating 7%. There was no model degradation, no bad day, no bad prompt. Every step held its spotless 95%. It was multiplication, silent and relentless, that devoured your product.
The demo mirage: why they shine on stage and blow up in production
Now you understand why agents are stars on stage and disasters on the night shift. The demo is short by design: two or three steps, a rehearsed happy path, a p^n that still lives in comfortable territory. Production is long by nature: twenty, thirty, fifty links where each one inherits the slight drift of the last. It's the difference between sinking a free throw — you nail nine out of ten — and sinking forty free throws in a row without missing a single one: the second feat is nearly impossible even if your aim is excellent. The demo measures one shot. Production measures the streak. And long streaks are where p^n waits for you with a knife. Gartner has already put a number on the disillusionment: it projects that more than 40% of agentic AI projects will be cancelled by 2027, many of them over costs and ROI that never arrive — the price of discovering Lusser's Law with real money instead of a spreadsheet.
The cure isn't a smarter model: it's more reliable links and shorter chains
The industry's reflex is to demand a smarter model, as if the problem were brainpower. The math says otherwise. Raise per-step reliability from 95% to 99% and those same twenty steps jump from 35% to 81%: one percentage point per link hands you back the whole product. That's the hidden leverage of p^n — the exponent punishes with the same ferocity it rewards. Which leaves exactly two real levers, and neither is 'wait for GPT-N'. First: raise p, the reliability of each step, with verification, schema validation at every boundary, and checkpoints that catch the drift before it propagates. Second: lower n, shorten the chain, break the giant task into short, verifiable subtasks instead of one monolithic fifty-move epic. A disciplined agent isn't the one that reasons the prettiest; it's the one that errs less per step and chains fewer steps per task.
The mental framework to take home
Hold on to this line and repeat it every time an agent demo leaves you slack-jawed: errors multiply, they don't add up. It's the reusable framework that separates whoever builds toys from whoever builds systems. Before you trust an agent with a business process, don't ask 'how smart is it?'. Ask two things: 'what's its reliability per step?' and 'how many steps does it chain?'. Multiply p^n in your head and you'll know, before spending a dollar, whether you're looking at a product or a stage mirage. This law is a sibling of another we've already covered — the math of 27%, the gap between what an agent pulls off in the demo and what it sustains in production: that one measures the drop, this one explains the exact mechanism that produces it. Read them together and you'll have the full picture of why so many agentic pilots never make it to the factory floor.
How we see it
At NeuralOS we don't fight p^n with optimism or promises of a magic model: we fight it with architecture. The Automations engine is designed around Lusser's Law even if the name isn't stamped on it: short, verifiable steps instead of monolithic chains, durable waits that freeze the state without losing the thread, resumability to pick up exactly where the process left off, and checkpoints that catch the drift before multiplication turns it into catastrophe. Each of those mechanisms attacks the same equation from a different angle: it raises p, shortens the effective n, and makes sure a failure at step 19 doesn't torch the other eighteen that already went right. We don't promise infallible agents — no one honest can, the math won't allow it. We promise something more useful: an engine that respects the cruel law instead of pretending it doesn't exist, so your flows survive the night shift and not just the midday demo.