Skip to content
Fast Company Executive Board

The Fast Company Executive Board is a private, fee-based network of influential leaders, experts, executives, and entrepreneurs who share their insights with our audience.

Why enterprise AI agents fail at scale

What it actually takes to make them work.

[Photo: Getty Images]

Profile photo of Cornelius Renken

Head of AI Apply · Kombo

Most demonstrations of enterprise artificial intelligence agents on LinkedIn look impressive at first. A browser agent filling out a tedious government form that you’ve needed to complete for the past year, all without human intervention. In a controlled environment, the system looks fully capable and exciting.

I’ve learned the hard way that the capability of enterprise AI changes when you’re building the product.

The same workflow that is reliable during testing starts failing unpredictably when rolled out to users. The browser may load too slowly, a third-party application programming interface (API) may change its response format, or an infrastructure dependency crashes halfway through execution, leaving you with wasted infrastructure spend. A workflow that succeeds 95% of the time sounds excellent until it runs at enterprise volume and generates hundreds of operational failures a day.

WHY REPEATABILITY MATTERS

Most teams underestimate this part of enterprise AI. Making the demo work is rarely the limiting factor: Repeatability is the constraint. The real challenge is whether the agent can execute reliably across thousands of variations and changing environments without collapsing under complexity. And when it does fail, how does the system reconcile those failures?

Until AI, enterprise software had mostly been designed around deterministic code. Inputs produce known outputs, engineers define tests in advance, and exceptions are handled once and the fix sticks. AI agents operate fundamentally differently. They are probabilistic systems interacting with environments that are themselves unpredictable. New edge cases occur with the same code, simply because the model produced a different output that day or encountered a website that does not fit into the expected input.

Projects that fail at this stage usually fail not because the underlying models are weak, but because the surrounding infrastructure was never designed for broad-enough execution. Recovery is often treated as secondary engineering work. In practice, self-healing and quality assurance behavior needs to be foundational.

SELF-HEALING AS ARCHITECTURE, NOT PROMPT

The first instinct when an agent fails is to let the agent itself figure it out. Give it the error and let it reason its way out. This has been one of the most expensive mistakes I’ve made. An agent that retries an entire workflow when something goes wrong burns cost and latency in equal measure. What has worked better for me is treating the workflow as a series of explicit, verifiable steps, and only retrying the step that broke.

In browser automation work that means running an assertion after every action to verify that the page state changed the way we expected. Did the input value change? Did the page navigate? When any of these assertions fail, we know precisely which step went wrong and can retry that step in isolation or fail cleanly with a specific error.

Some of the strangest edge cases I’ve seen were enterprise systems where standard browser interactions just didn’t work. The page was coded in some obscure legacy way, and clicking an input wouldn’t do anything. Without verifying each workflow step, an AI agent gets stuck in a loop of “I tried everything,” eventually giving up after burning money. Verification catches these failures immediately, allowing the system to fall back to an alternative interaction method.

In general, if an API returns a rate limit error, the workflow should pause and resume, not restart. If a model produces an uncertain output, the system should know to take a second sample. None of this needs to be the model’s job to figure out at runtime.

OBSERVABILITY FOR PROBABILISTIC SYSTEMS

Traditional software teams rely on logs and metrics to debug systems. In my experience, that’s not enough for agentic systems, because the failures rely heavily on context.

At Kombo, the single highest-leverage thing we’ve built is a fixture-driven test harness. Every time something breaks in production, the input becomes a fixture, and we run the same extraction 50 to 100 times against it. When we change a prompt or schema, we re-run the suite and see whether the change helped. Without this kind of harness, it’s easy to make vibe-based changes to prompts and ship regressions you don’t notice for weeks.

This is also why so many enterprise agent deployments stall after a promising pilot. Teams optimize for demo quality instead of the test infrastructure they need to operate the system at scale.

MISUNDERSTOOD ECONOMICS

Conversation around enterprise AI still focuses on model capability—whether the latest model reasons or codes better. For anyone shipping production agents, cost architecture is just as important. A workflow that costs a few dollars to run is not expensive in isolation. At enterprise volume it can decide whether the product is commercially viable.

The teams I’ve seen succeed treat model usage as an infrastructure optimization problem. It often means routing tasks dynamically to the cheapest model that meets the reliability bar for that step, caching aggressively, and splitting up workflows into smaller reasoning steps with tighter context. It also means being honest about where you don’t need a model at all. Normalizing a phone number or converting a zip code to a city are solved problems with deterministic libraries. Reaching for a large language model adds cost and a non-zero failure rate to something that should never fail.

A SYSTEMS ENGINEERING PROBLEM

In practice, this all looks much more like a typical engineering problem, not some novel AI issue to solve. The hard topics to solve are orchestration, failure recovery, concurrency, permissions, and cost control. The AI model serves as only one part of the system.

Teams building systems today should architect for “swapability.” Models will keep getting cheaper and more capable. When a better model drops, you’ll want architecture that can take advantage of it.

Enterprise adoption has never depended on whether technology works once. It depends on whether it keeps working after the thousandth exception. That’s the bar I’d hold any production agent to before calling it real infrastructure.

Cornelius Renken is head of AI Apply at Kombo.