Back to Blog
Research

Priya Patel7 min
Tab

Gary Marcus just said AI agents have mostly been a dud with failure rates of 70% on some tasks. That's not clickbait. That's a disaster. Everyone's still talking about benchmarks and 'agentic workflows' but nobody wants to talk about what happens when the agent breaks. What happens when it clicks the wrong button. What happens when it gets stuck in an infinite loop. If you're deploying a computer use agent today and you're not obsessing over error handling and recovery, you're not building software. You're gambling.

The 70% Failure Rate Nobody Wants to Admit

Marcus is right. In some domains, AI agents are still barely better than random. That 70% number comes from real-world testing on complex, multi-step workflows where reliability actually matters. When you stack five or six steps together, an 80% reliable agent fails 70% of the time. That's exponential. That's math. That's why most enterprise deployments are still manual. They can't afford the error rate. The irony is the benchmarks are getting better. OSWorld-Verified now shows models like Qwen3.8 Max reaching 86.1% and Claude Fable hitting 85%. Those are impressive numbers on paper. But benchmarks are not workflows. Benchmarks are controlled environments with clean inputs and clear success criteria. Real workflows have weird UIs, broken pages, rate limits, authentication glitches, and systems that just don't behave the way you expect. That's where the 70% failure rate shows up.

Why Most Error Handling Is Just Wishful Thinking

  • Most vendors promise 'smart recovery' but deliver nothing. Operator requires confirmations for sensitive sites like email. That's not recovery. That's a guardrail.
  • OpenAI's Operator system card says it mitigates mistakes with confirmations and watch mode. That's reactive. That's not handling failures. That's pausing the task and asking a human to intervene.
  • Anthropic's agentic misalignment research shows LLMs can take sophisticated actions when processing routine emails. That's exactly the kind of behavior that breaks workflows. They follow instructions. They don't understand context.
  • AgentDebugX and other tooling exists to capture traces and diagnose failures, but it's mostly for observability. You can see the failure. You still have to write the recovery logic yourself.
  • Claude's computer use tool has improved, but the API errors are still opaque. You get rate limits, timeouts, and cryptic messages. Good luck writing robust recovery code around that.

Manual data entry costs U.S. companies $28,500 per employee every year because automation is too risky. If AI agents fail 70% of the time, they're not automation. They're just another tool you have to babysit.

What Good Error Handling Actually Looks Like

Real error handling isn't a checkbox. It's a strategy. It starts with detection. You need to know when something has gone wrong before the user even notices. That means tracing the full trajectory of actions, checking intermediate states, and verifying outputs at each step. Then comes diagnosis. Was it a transient fault? A rate limit? A UI change? A misalignment with the model's intent? You can't recover if you don't know why you failed. Once you know the cause, you need multiple recovery strategies. Retry with exponential backoff. Switch to an alternative workflow. Ask for human clarification. Reset and start over. The key is having options instead of one monolithic retry button that might just repeat the same mistake.

Parallel Execution Makes Recovery Harder, Not Easier

Multi-agent orchestration sounds great in theory. Run 10 agents in parallel. Speed everything up. But parallel execution increases the attack surface for errors. If one agent fails, you need to detect it, understand why, and coordinate with the others. That's coordination overhead. That's more code. That's more things that can break. Most orchestrators treat agents as black boxes. They submit a task and wait for a result. If the agent fails, the orchestrator either gives up or retries blindly. That's not robust. The best orchestrators understand the agent's capabilities, monitor its state, and can intervene when something goes off the rails.

Why Coasty Actually Handles Errors Instead of Pretending They Don't Exist

We built Coasty around the reality that agents fail. We don't pretend 100% success rates are achievable. We obsess over what happens when they don't succeed. Coasty controls real desktops, browsers, and terminals. That means we can see exactly what the agent sees. We can verify intermediate states. We can detect failures in real time. Our computer use agent is built around recovery-first design. It doesn't just retry. It diagnoses. It has multiple fallback strategies. It can pause and ask for human clarification when it's uncertain. It can switch to an alternative workflow when the primary path is blocked. We also support agent swarms for parallel execution, with built-in coordination and recovery. If one agent encounters an error, the others can continue or adapt. That's what enterprise-grade computer use actually looks like.

If you're still evaluating AI agents based solely on benchmark scores, you're making a mistake. An 85% success rate on a controlled benchmark is meaningless if the agent fails 70% of the time on real workflows. Error handling and recovery are what actually matter. That's why Coasty exists. We don't just run agents. We handle the failures so you don't have to. Try Coasty today and see the difference when an agent actually knows how to recover instead of just failing and asking you to press retry. Visit coasty.ai to get started.

© 2026 Coasty

Backed byYCombinator