So I was talking to a guy who runs engineering at a mid-size fintech company last month — they’d just killed an AI agent project. Six months of work. Four engineers. The agent was supposed to handle customer onboarding paperwork automatically. Fill forms, verify IDs, flag edge cases. Standard stuff.
It never shipped.
They burned something like $400K on it. And when I asked what went wrong, he didn’t say “the AI hallucinated” or “it wasn’t smart enough.” He said the agent kept calling the wrong API endpoints. Like, consistently. It would mix up the sandbox and production URLs, or pass parameters in the wrong format, or just give up silently when an endpoint returned a 500 error instead of retrying.
Apparently this isn’t unusual at all.
Presenc AI, a company that works with about 60 enterprises on agent deployments, put out some data recently that stopped me mid-scroll. They broke down every failure mode they’d seen across their customer base and the number one cause wasn’t hallucination. Not even close. Hallucination accounted for only 12% of failures.
The biggest culprit? Tool errors. 28% of all agent failures came from the AI simply messing up when interacting with external systems — wrong API calls, malformed queries, authentication failures, timeout handling that just… didn’t happen. The agent would confidently call the wrong function and never notice.
Here’s the full breakdown from their data:
- Tool execution errors: 28%. The agent calls an API wrong, or passes garbage parameters, or can’t handle rate limits.
- Memory and context collapse: 22%. The agent loses track of what it’s doing halfway through a multi-step task. It forgets step 3 by the time it reaches step 7.
- Planning failures: 18%. The agent comes up with a plan that’s logically wrong. Not buggy — just a plan that doesn’t solve the problem.
- Context poisoning: 14%. Bad data or contradictory instructions get into the agent’s working memory and corrupt everything downstream.
- Hallucination: 12%. Making stuff up. The thing everyone talks about. Dead last among the major failure modes.
So we’ve been worrying about the wrong problem. Everyone’s obsessed with whether the AI is going to lie to us, when the real issue is much dumber — the AI doesn’t know how to use a screwdriver.
Why tool use is so brittle
Think about what an agent actually does when you ask it to “book me a flight to Berlin next Tuesday.” It has to figure out what tools are available (flight APIs? a calendar app?), choose the right one, format the request correctly, handle whatever comes back, deal with errors, and keep track of where it is in the process. That’s like five different skills, and failing at any one of them kills the whole chain.
And the tools themselves are part of the problem. CyberQuickly published an analysis of nine different failure classes in agentic systems, and one thing they kept finding: most enterprise tools weren’t designed to be called by AI. Their APIs are inconsistent. Error responses are formatted differently. Rate limits aren’t documented. The agent has to figure all of this out on the fly, and it mostly guesses wrong.
I was surprised to learn that Mercor ran a set of benchmarks called APEX-Agents earlier this year — real professional tasks from banking, consulting, and law firms. Gemini 3 Flash scored under 25%. GPT-5.2 scored under 25%. These aren’t dumb models. They’re the best we’ve got. And they’re failing three quarters of real professional tasks because the gap between “knowing stuff” and “doing stuff” is still enormous.
The memory problem nobody talks about
22% of failures come from memory collapse. That number deserves more attention than it gets.
Here’s what it looks like in practice: your agent starts a task with clear context — say, analyzing a legal document and flagging compliance issues. By the time it’s on page 40 of the document, it’s forgotten the compliance framework it was supposed to use. Or it repeats checks it already did. Or — and this one’s fun — it “remembers” something that never happened because context from an earlier, unrelated conversation bled into the current task.
DeepMind’s team ran into a spectacular version of this with their Pokémon-playing Gemini agent. The agent was supposed to navigate the game world and make strategic decisions based on what it saw on screen. But it started hallucinating Pokémon that weren’t there — because visual elements from earlier frames had “poisoned” its context window and the agent couldn’t distinguish between what was on screen now versus what had been on screen ten minutes ago.
Cognition AI (the Devin people) have been saying publicly that “context engineering is the new prompt engineering” and honestly? They’re right. Managing what goes into an agent’s working memory — and keeping it clean — is turning out to be way harder than anyone expected.
So why do companies keep trying?
Because when agents work, they really work.
BCG found that agents deployed successfully cut process times by 40-70% in document-heavy workflows. McKinsey’s latest numbers suggest companies that crack agent deployment see ROI within 4-6 months. IDC is projecting $180 billion in spending on agentic AI by 2027.
And NVIDIA’s State of AI 2026 report found something interesting: the companies succeeding with agents aren’t the ones with the best models. They’re the ones who spent the most time on the boring stuff — tool documentation, error handling, context management, human-in-the-loop checkpoints. The unsexy plumbing around the agent matters more than the model itself.
The pattern I keep seeing goes like this: company gets excited about agents → builds a pilot → agent works great in demos → pushes toward production → agent breaks on real-world edge cases → company either abandons it or strips it way down.
Nobody publishes the post-mortems. That’s the frustrating part. You get the glossy case studies and the breathless blog posts, but the 60% that failed? Radio silence. Which is why that Presenc AI data caught my attention — it’s one of the only honest breakdowns of what’s actually going wrong at scale.
I don’t know what the fix is. Better tool documentation would help. Stricter error handling would help. But I think the real bottleneck is something squishier — we’re building agents that are really good at reasoning and then asking them to do tasks that are mostly about execution. And execution is boring. It’s about retry logic and format validation and knowing when to ask for help. The models aren’t trained for boring.
Maybe the 60% failure rate isn’t a sign that agents are doomed. Maybe it’s a sign that we’re solving the hard problem first — reasoning — and the plumbing will catch up. But I wouldn’t bet your company’s $400K pilot budget on it just yet.