Are enterprise AI agents actually ready for production?

I've spent the last couple of years helping teams drag agents from "wow, great demo" to something that survives contact with real users, and I've come around to thinking "ready for production" is just the wrong frame. An agent isn't ready or not-ready the way a database is up or down. It's ready for a specific, bounded job, inside guardrails, with a human somewhere in the loop for anything expensive or irreversible. Ask "is this agent ready to do X within these limits" and you can actually answer it. Ask "are agents ready" and you get a hype cycle.

The stat everyone throws around is that most agent pilots never ship. I've seen 88% quoted most often; some sources push it to ~95%. Pick your number, the direction's the same. And it's almost never because the model is dumb.

The demo runs on a clean slice of data somebody hand-picked, one tidy prompt, a task with an obvious finish line. Production is the opposite - duplicate customer records, a permissions model nobody documented, three systems that spell the same field three different ways, and a task that runs forty minutes across six tools instead of one clean exchange.

The thing that actually kills these in production is non-determinism, and specifically that you can't tell in advance when the agent is going to be confidently wrong. A normal system fails loudly. An agent fails quietly, sounds completely sure of itself, and does it in a way your test suite never anticipated.

I've watched agents score 95%+ on internal evals and then bleed money in week one because a tool timed out mid-loop and the agent just., improvised its way around it. Something like a third of catalogued production incidents trace back to a tool failure the agent didn't handle gracefully. Golden-path tests don't catch that, because the golden path assumes the tools work.

The teams who do get to production mostly look the same. A few patterns I'd bet on:

- They treat evaluation and observability as infrastructure, not an afterthought. If you can't trace every tool call and decision step, you're flying blind and you won't know it's broken until the business impact already landed.

- Reliability comes from deterministic guardrails and modular design, not better prompting. Keep the LLM on intent and language understanding; route anything that needs to be exact (money, queries, state changes) to typed, testable code.

- Human-in-the-loop on high-stakes actions, with real approval gates. Not because the model's useless, but because "confidently wrong and irreversible" is the failure mode that ends the program.

- Narrow scope. The single-agent-does-everything build gets exponentially harder to debug. Decompose early.

Where it's genuinely working right now: customer support triage, SDR/outbound, internal ops and knowledge retrieval, coding assistance. Banking and insurance are further along than most (they already live and breathe audit trails), while healthcare and public sector lag - which tells you the bottleneck is governance and data, not intelligence.

So: ready? For a scoped, observable, guardrailed workflow with an owner and a rollback plan - yeah, and plenty are already in production earning their keep. As a drop-in autonomous employee you point at your messiest process and walk away - not close, and I'd be skeptical of anyone selling that.

Curious what everyone else is seeing. For those of you who got something to prod - what actually broke first when real traffic hit it?