Double the task, quadruple the failure

The dream sold all year is the agent that works your whole day — you hand it a goal at 9am, it grinds for eight hours, you come back to a finished job. Sequoia even put a date on it: reliable 8-hour workday agents "by late 2026." I'd love that too. But the math has a problem with it.

The compounding wall

A task made of many steps only succeeds if every step succeeds. That's a product, not a sum. So errors don't add — they multiply. A 2026 paper, "The Long-Horizon Task Mirage," puts numbers on it: doubling a task's duration roughly quadruples the failure rate rather than doubling it. A modest 2% error per step becomes a 33% chance of failing the whole task over just 20 dependent steps.

Measured across ten models and four length buckets, aggregate pass@1 falls from 76.3% on short tasks to 52.1% on very-long ones — a 24-point, super-linear drop. And it's not only per-step error: after 25–30 tool calls, even 200K-token context windows lose the thread — models forget early results and re-run steps they already finished.

Reliability isn't a property of the model. It's a property of how many things have to go right in a row without a checkpoint.

Why a better model won't save you

This is the trap in "just wait for the next model." Push the per-step error from 2% down to 1% and, over 20 steps, you still fail ~18% of the time. Halving the error rate doesn't halve the pain, because it's fighting an exponent. There is no near-term model good enough to make a naïve 100-step chain reliable. The curve wins.

The fix is architecture, not patience

The 25% of teams whose agents actually reach production aren't running longer chains. They're running shorter ones, with structure around them:

• Decompose. Break the eight-hour job into short, independently-checkable tasks. A chain of ten 10-step tasks with a checkpoint between each beats one 100-step run — by a lot.
• Checkpoint. Save verified state between steps so a failure costs one task, not the whole day. Don't make step 90 depend on the model still remembering step 3.
• Verify, then continue. Gate each stage on a cheap check — the deterministic result, a second model, a schema — before the next stage builds on it. Catch the 2% before it compounds.
• Keep the window clean. More turns is not more thinking. Past ~30 tool calls, context rot sets in; a fresh, focused context beats a bloated one carrying 90 steps of history.

This is the same lesson I keep landing on from different directions: one agent that does everything does nothing well, and orchestration is the real architecture. Long-horizon reliability is orchestration wearing a stopwatch.

The bottom line

Doubling the task quadruples the failure — that's not a model flaw, it's arithmetic. The all-day autonomous agent doesn't arrive because a lab ships a smarter brain; it arrives because you stopped asking one brain to get 100 things right in a row.

Don't build a longer chain. Build a shorter one, checked at every link.