Almost every company selling software into the back office has rewritten its homepage in the last two years. The new favorite word is "autonomous." Agents that run your process. AI that does the work for you. Walk a conference floor and you'll see it on dozens of booths. Scroll LinkedIn and you'll find hundreds of posts saying the same thing.
Most of the products using the phrase don't do what it says.
It helps to be clear about why this is a big deal. For decades, "software" has meant a person sitting at a screen, clicking through apps to get the work done. The software waited. The human did the work. Agentic AI is a real break from that pattern. When it works, the system does the work, and a person steps in only for the rare case that needs a human. That's a genuine shift in what software is for, and it's why the label is worth fighting over.
It's an easy label to grab, because the promise behind it is real. A system that runs a process on its own, with people stepping in only for the genuinely odd case, would change the economics of every back-office function it touched. That's exactly why everyone wants to claim it.
This isn't a fringe complaint. Gartner has a name for the practice: "agent washing," the rebranding of old chatbots, RPA scripts, and assistants as agents without any real autonomy underneath. Gartner estimates that of the thousands of vendors now claiming agentic AI, only about 130 are the real thing. It also expects more than 40% of agentic AI projects to be scrapped by the end of 2027, often because the business value never showed up.
A lot of that gap traces back to one distinction almost nobody defines clearly: the difference between a copilot and a truly autonomous system.
The car industry already drew the line
The cleanest way to see it comes from a different field. SAE International's J3016 standard sorts driving automation into six levels. The bottom three are "driver support." The top three are "automated driving." The line between them is blunt. At Level 2, a human is still driving. The car can steer and hold its speed in a lane, but you keep your hands on the wheel, your eyes on the road, and you own whatever happens next. Every consumer car on the road today is Level 2, no matter what the marketing suggests.
A copilot is a Level 2 system. It makes the human faster. It doesn't remove the human.
Picture what that looks like in an accounts payable queue. An invoice comes in with a quantity that doesn't match the PO. A copilot flags it, suggests a GL code, maybe drafts a note to the buyer. Useful. But someone still has to read the suggestion, judge whether it's right, and click approve. The work still happens at human speed, and it still takes human headcount. Double the invoice volume and you still need close to double the people to clear it. And probably the single-most important point is that there’s little guarantee as to the accuracy of the copilot. The easy trick with a copilot product is that you don’t have to own oversight of the actual business outcome. It’s left up to the human end-user to “figure it out”.
Real autonomy breaks the link between volume and headcount
True autonomy is Level 4. Inside its domain, the system handles the whole task and only escalates the case that genuinely needs a person. The same mismatched invoice arrives. The system reads everything it already knows about that vendor, that project, that tolerance, lands on the answer, posts it, and moves on. Nobody gets pinged at 5pm on a Friday. The queue doesn't form in the first place.
That is the thing companies think they're buying when they buy "autonomous" software. Right now, headcount is just a scale factor of volume. More invoices, more people. The whole point of autonomy is to cut that cord, so you can grow 40% in a year without growing the AP team to match.
A copilot never cuts it. It makes each person in the queue a little quicker, and that's where it stops. You still staff to volume. You still add the seats, the offshore center, the contractor brought in for close. The queue is still there. It just moves faster.
The numbers bear this out. According to Ardent Partners, the average invoice exception rate has hovered around 22% for years, with best-in-class teams near 9%, and more than 60% of invoices still pass through human hands. Two decades of automation software, and the exception rate has barely moved. Copilots are part of the reason. They speed up the human touch. They don't end it.
This is also why so many of these projects quietly die. A company buys "autonomous," builds the business case on headcount that finally stops scaling with volume, rolls the thing out, and a year later the AP team is the same size. The exceptions are moving faster, sure. The savings the budget was built on never arrived, because the work never actually left the building. That's a large share of Gartner's projected cancellations in one sentence. The tool did what a copilot does, sold as something it wasn't.
A copilot escalates because it doesn't know enough
When a tool bounces the hard case back to a person, the reason is usually simple. It doesn't know enough to make the call itself.
It can read that the invoice says 100 units and the PO says 90. What it can't do is know that this supplier always ships heavy on copper and bills the overage separately, that "Houston Yard 4" and "HOU-Y4-001" are the same site in two different systems, that the Dallas plant clears commodity variances at 2% while Phoenix holds the line at half a percent. None of that is in the ERP. It lives in the head of one analyst who has been at the company longer than the CFO, and in a spreadsheet she keeps because nothing else captures the shortcuts.
A system without that context has no way to resolve the exception, so it routes it to a person, calls the handoff "human in the loop," and keeps the word "autonomous" on the website. The escalation is the tell.
Which means autonomy comes down to one thing that has nothing to do with model size or interface polish: how much of your actual operation the system understands. You can't resolve what you don't know.
It’s easy to identify “agent washing”
So how do you spot the difference before you've signed anything? Start with how the vendor charges. If they price by the seat, by the number of people logging in to use the tool, then they make more money when more of your people spend more time in the software. That's a copilot's incentive, not an autonomous one.
Look at the demo, too. If the pitch is built around a slick screen your team will live in all day, the human is still the engine doing the work. A system that's actually autonomous doesn't have much of a screen to show off, because the point is that nobody needs to sit in front of it.
Then run the real test. Give the system a month and look at your exception queue. Is it smaller, or is it just moving faster? A copilot makes the queue faster. A truly autonomous system makes the queue go away. Those are different products, and only one of them changes your cost structure.
That's what we built Fragment to do. If you're weighing this decision right now, we'll show you what autonomous exception resolution looks like on your actual data.
