Robotic process automation was supposed to be the digital workforce. A decade and several billion dollars of licences later, the honest scorecard reads differently: 30–50% of enterprise RPA projects are abandoned within two years, roughly half stall the moment process variability exceeds what was scripted, and maintenance, the work of keeping yesterday's bots alive, has grown to consume around 60% of total RPA cost.
Even the vendors have conceded the point. Gartner called 2024 an inflection point for the RPA market, with growth slowing as computer-use AI and agentic automation arrived; UiPath, the category's seven-time Magic Quadrant leader, now describes itself as an agentic automation company.
Why RPA breaks
RPA is a script wearing a trench coat. It clicks pixel positions and selectors in a fixed order, which means it inherits every brittleness of the screens it runs on:
- The screen changes, the bot dies. A vendor ships a redesign, a field moves, and the bot clicks into nothing. Every UI update is an unplanned maintenance ticket.
- It only knows the happy path. The order that arrives in a slightly different format, the portal that throws an extra dialog: anything unscripted is an exception, and exceptions pile up in a queue a human still works.
- The knowledge lives in the script, not the work. The people who understood the process wrote requirements; a developer translated them; the truth got lost twice.
None of this is a moral failing of RPA. It's what you get when automation can execute but cannot read the screen and decide.
What actually changed
Computer-use AI agents, models that look at a screen the way a person does and act through the same mouse and keyboard, went from research demo to production tool in about two years. On OSWorld, the standard benchmark for real computer work, agents went from ~12% success in April 2024 to crossing the ~72% human baseline in late 2025, with top models in the mid-80s by mid-2026.
The practical difference is not that agents click better. It's what happens when the screen surprises them:
- A moved button is something to find, not a crash
- An unusual order is something to reason about, or escalate, not an exception code
- A correction from a human becomes part of how the work is done next time
RPA encodes a process. An agent learns a job. The difference shows up the first week something changes, which in a real back office is every week.
The honest caveats
Agents are not a magic upgrade, and the analyst community is right to be cold-eyed about the hype. Gartner projects that over 40% of agentic AI projects will be canceled by end of 2027, mostly for unclear business value; MIT's 2025 study found 95% of enterprise GenAI pilots produced no measurable P&L impact, though externally built tools succeeded about twice as often as internal ones.
The pattern in the failures is consistent: agents deployed as open-ended magic, pointed at vague goals, with no human in the loop and no way to learn the organisation's actual rules. The successes look the opposite: narrow, well-defined workflows, taught from how the work is really done, with checkpoints where judgment matters.
Where we land
That's the design AltOps runs. An employee records a real workflow once, narrating the exceptions out loud. The agent learns the job, not a script of it, and runs it on its own cloud computer, in the same ERPs and portals, with stop points wherever you want sign-off. When the screen changes, it adapts; when it's unsure, it asks; when it's corrected, it remembers.
If you've been burned by RPA, the scar tissue is useful. Point it at the same question you should have asked then: not "can this be automated?" but "when this changes, and it will, who fixes it?" With a script, the answer was a change request. With an agent, it's the same as with a person: you tell it once.
Written by Kavish Soningra, teaching agents to run the back office at AltOps.
