In December 2024, a research team led by Carnegie Mellon University published TheAgentCompany, a benchmark with 175 real office tasks — opening a support ticket, updating a financial spreadsheet, reviewing a record, closing out a project report — inside a simulated environment built with the same tools any company already uses. The result: even the best-performing AI agent finished only 30% of the tasks on its own.
The detail that matters isn't the number by itself, it's the setting it came from. That benchmark was built, step by step, to catch exactly where and how the agent went wrong: every task had programmed checkpoints, and an evaluator scored the outcome against the expected result. That's the opposite of what happens when an ordinary company puts an agent to work on a routine. No one programmed a check at every step, and the wrong output just keeps moving — it becomes an email, a number in a spreadsheet, an answer to a customer.
According to The GenAI Divide report from MIT NANDA, published in August 2025 based on more than 300 analyzed AI initiatives and 150 interviews with business leaders, 95% of enterprise generative AI projects deliver no measurable financial return. Gartner projects a similar cut from the other end of the process: it forecasts that more than 40% of agentic AI projects will be canceled by the end of 2027, citing rising cost, unclear value, and inadequate risk controls. Neither reason is "the AI model is bad." The common thread is different: no one knew, precisely, what the agent had done until the result was already wrong.
The Error That Never Stops the System
A system that crashes announces itself: an error message, a screen, someone calling support. An agent that fails slowly does none of that. It finishes the task, hands back an output that looks normal, and moves on. In the TheAgentCompany benchmark, the tasks spanned six areas of an ordinary company: software development, project management, data, administrative work, human resources, and finance. In none of them did the agent stop when it got something wrong — it produced an answer, just the wrong one, with the same confidence as the right one.
Outside the controlled setting of a benchmark, the picture is worse. A survey by Gravitee of around 750 technology leaders in the United States and the United Kingdom, published in 2026, found that 90% of companies run AI agents in production with no monitoring at all. On average, only 52% of those agents' actions have any kind of oversight, and just 9.5% of companies monitor more than 81% of the agents they have running. Roughly half of the work happens with no one watching.
For a company in Brazil or Latin America just starting to put AI agents to work on collections, customer support, or invoice reconciliation, this is the right moment to settle that question up front — not after a quarter of wrong numbers. Whoever enters this cycle now has the advantage of copying the right design from the first agent onward, instead of finding out about the problem once it has already become an audit.
The problem also grows on its own once an agent works across steps: if the second step treats the first step's wrong output as true, the error stops being the size of one answer and becomes the size of an entire process. That is the mechanism that makes a silent error more expensive than one that crashes — it has time to spread before anyone notices it exists.
The Blind Spot in Success Dashboards
The most common response to these numbers is installing a dashboard: how many tasks the agent completed, what its success rate was, how long each run took. That measures whether the agent ran. It does not measure whether what it produced was correct. Those are different questions, and confusing one for the other is exactly what the numbers above describe.
The MIT NANDA report reaches the same conclusion by a different route. Its authors attribute the 95% of projects with no measurable return not to the quality of the AI models used, but to how companies integrated these agents into real work — without a process designed to check, step by step, what was coming out. Only 5% of the projects analyzed generated a clear financial gain, and the trait they shared was exactly that: real integration with the work, not an isolated pilot.
Gartner projects a similar cut from the budget side, and the reason it cites — inadequate risk controls — points to the same gap. When someone finally asks who is accountable for an agent, the answer is usually missing: the same Gravitee survey measured that only 7.2% of companies have a named individual with formal accountability for an AI agent's behavior. For most, the answer is "it's not defined," "it's everyone's job," or it was simply never discussed.
Without that person, even a well-built dashboard doesn't help. Someone needs to see the wrong number and have both the authority and the obligation to investigate why it's wrong. A dashboard with no owner is just a decorative chart.
What Has to Be in Place
An environment that catches errors early is defined by verifiable mechanisms, not by one more dashboard.
Human approval before a sensitive action. The agent stops and asks a person to confirm before acting — sending a document, changing a record, releasing a payment — instead of running through to the end on its own. This is the point where an error gets stopped before it becomes a consequence.
An audit trail for every step executed, not just the final output. Logging only the finished answer doesn't show where the error crept in. Logging every step lets you reconstruct exactly what the agent did, with what information, and fix only the step that failed.
Approved knowledge, with an identifiable source. When an answer rests on a document with an owner and a current version, instead of an assumption the agent made on its own, it's easier to check whether it's right, and harder for an error to pass as true just because it reads well.
Access matched to each person's and each agent's role. An agent only reaches the systems and functions the task requires. When it gets something wrong, the damage is the size of what it could touch, not the size of the whole company.
A named owner per agent, not per department. Every agent has one person accountable for it: who reviews its behavior, who gets notified when something looks off, who decides whether the agent keeps running. Without that name, the question "who saw this first" has no answer.
This is how Skyller was designed: human approval before sensitive actions, a step-by-step audit trail, and knowledge grounded in sources with an owner, so an error surfaces in days, not in a quarter of wrong reports.
From Silent Failure to an Early Alarm
The easiest gain to defend is the obvious one: less risk. But what actually changes day to day for a team is a different, less talked-about effect. When risk-based approval and a step-by-step trail exist, an error stops waiting for a quarterly audit to show up — it surfaces the moment someone reviews the next step, because the previous step is logged and visible.
The difference between reconstructing what happened in minutes and not being able to reconstruct it at all is the distance between an error that costs one correction and an error that costs a quarter of wrong decisions built on top of it. And reconstructing early is exactly the trait that separates the AI projects landing in MIT NANDA's 5% with measurable return from the ones stuck in the 95% that never take off: it isn't the model, it's the process around it.
There's a trust gain for the team, too. When there's a named owner and clear approval for sensitive decisions, whoever uses the agent day to day stops carrying, alone, the doubt over whether something is right. They know exactly where the process intercepts an error before it reaches a customer or a leader, and can trust the agent for what it handles well, without re-checking every line by hand.
Questions to Test Before You Trust It
Before approving the next agent, or before continuing to trust the one already running, it's worth answering these questions with whoever operates it and whoever decides:
- Does someone review the output before it becomes a decision, or only after? If the check only happens after the document was already sent or the record already changed, the checkpoint is in the wrong place.
- Is there a record of every step the agent executed, not just the final output? Without it, an error found late can't be traced back to the step that caused it.
- Who is the person accountable when this agent gets something wrong? If the answer is "the team" or "IT, in general," there isn't an owner yet — there's a gap.
- How often does someone actually compare what the agent said against the correct source? A check that never happens in practice is worth the same as no check at all.
- If this agent got something wrong today, how long would it take someone to notice? If the answer is "I don't know" or "only at the next audit," the agent is already failing in silence — it just hasn't been found yet.
