The 4 Levels of automation & how to tell them apart

We talk to dozens of supply chain and procurement leaders every month, and the same reservation about "AI for enterprise" comes up constantly. It mostly traces back to mislabeling: a lot of what gets sold as AI is plain automation, RPA with a new coat of paint. Vendors selling it, and there are a lot, call it an AI solution whether it is one or not, and buyers who get burned by that stop believing anyone's pitch, including the vendors doing something real.

This isn't the first time a label has done this. A few years ago, every solution had blockchain functionality. Before that, every solution was a control tower, or a digital twin. AI is just the current one.

That matters beyond semantics. If you can't tell which level of automation you're buying, you can't tell what it will do when something unexpected happens, and unexpected is most of what supply chain and back-office work is.

Here's a quick side-by-side look at all four, then the full explanation below.

Level 1: Legacy RPA

This is the oldest form of automation and it's still running in most of the world's back offices. Blue Prism, founded in 2001, effectively created the category of software, and the term "robotic process automation" itself wasn't coined until 2012. The pattern is simple: chain together fixed steps, triggered by structured input, executed the same way every time, whether that's moving data between systems or pulling fields off a scanned document with OCR.

Legacy RPA is excellent where incoming information rarely changes and the edge cases are already accounted for: every step follows the norm, and exceptions are rare. But when an exception does come in, the only fix is alerting (if that's been set up) and rebuilding the RPA to handle the new case, a slow, expensive option. Over time, the flow turns into a multi-branch, fragile mess that's hard to maintain.

The fragility is also due to the fact that legacy RPA mostly lives in IT's hands. Business users can spot the repeatable task, but someone with access to the underlying configuration has to wire it up. That's a real bottleneck, and it's the one modern RPA tried to solve.

Level 2: Modern RPA

UiPath and what's now Microsoft Power Automate moved workflow-building out of a pure IT backlog. Once the platform is provisioned, a business user can chain the steps together directly, no developer needed for each new workflow. It's a real improvement, but it's still the same underlying idea as Level 1: a fixed path someone designed in advance for a case they already knew about. That means the moment a case falls outside that path, there's nobody home to handle it, the same limitation as Level 1, just with a friendlier interface on top.

But now, instead of an IT queue, the business user has to negotiate access requests, licensing tiers, and admin approval for every new connector. And structurally, nothing has changed: if a situation shows up that nobody anticipated, the workflow doesn't handle it. It breaks, or it silently fails, and stays a missed opportunity until someone notices. That's where copilots come in.

Level 3: AI Copilot

Copilots changed automation: they could cut the work several times over via plain text chat, with no training on new tools. But there's one catch: they perform perfectly only when prompted well, and a bad prompt gets you a bad answer just as fast as a good prompt gets you a good one. So the Level 2 problem of silent failures is covered now, because you decide when to act, not some pre-scripted workflow.

That's the real difference from Levels 1 and 2: those need every case written out in advance as a rule, if this happens, then do that. A copilot like this is a generalist instead, it reasons over a new case without needing to be trained for that exact situation first. What it can't get around is the data it's given: feed it a half-complete record or a messy input, and the output reflects that. A copilot reasons over the data faster than a person could, but it can't fix bad data on its own. Even though the underlying AI models have gotten a lot better, prompt quality is still critical to getting a clear, natural output.

Microsoft 365 Copilot drafting a reply from an Outlook thread, SAP Joule answering why a purchase order is still open inside S/4HANA, or an assistant bolted onto a decade-old ERP screen to answer questions on demand, it's the same pattern in every case. A copilot can read a supplier's email, check the delivery history, and draft a reply, but only because you opened it and told it to. It still has to be prompted, and you still have to check its work before anything goes out.

That's a real productivity gain. Compressing a 30-minute lookup-and-draft task into a couple of minutes of review is not nothing. But it's not autonomy. The system doesn't act until you ask, and it doesn't know a new case has happened until you show it one.

Level 4: Agentic AI

This is the level everyone claims and almost nobody is selling. The distinguishing feature is initiative: rather than just chatting to assist with your analysis and drafting, the system acts on its own, and only comes to you when it's genuinely unsure, not on a fixed schedule and not because a rule told it to check in. It's almost like an eager intern who's memorized all your company's best practices and how to react in different situations, and acts on that proactively. And it's not running amok without reason: it can be programmed to check in internally and ask for help when a curveball comes up, or when the question touches financial decision-making, a clear no-go zone.

This wouldn't have been possible in 2023. It took a few more years for the underlying AI models to get better at using tools the way a person would, including filling out forms and clicking through an ERP interface. Instead of just reading and inferring from text, modern models understand screens, interfaces, and documents visually, and they carry a lot more background knowledge: how a finance team works, how a supply chain team works. By 2026, the shift underneath Level 4 is that the system doesn't need someone to have already anticipated the case and written the rule for it. It reasons from context, existing documents, and past resolutions, and it acts, only escalating when it's stuck.

Gartner frames agent autonomy the same way: from observe-only agents with read access, up through agents that act with a human co-signing, up to agents that execute independently within a defined scope. A separate framework, "Levels of Autonomy for AI Agents," lays out a similar ladder and lands on the same point: autonomy is a design choice, separate from how capable the underlying model is.

The right mix, not the highest level

None of this means every process should run at Level 4. A step that runs the same way every time, matching a PO line to a goods receipt, checking a date against a promised delivery window, doesn't need reasoning. It needs to happen the same way every time, and an RPA-style step does that more reliably and more cheaply than asking a model to reason its way there. The real question is which parts of a process need judgment and which parts just need to run, not how to get everything to Level 4.

This is the mix we've built into Glacis. The steps that always run the same way execute RPA-style, fixed and repeatable, no ambiguity involved. Everything else, the exception, defaults to agentic reasoning, because that's where judgment matters. What makes the agentic side work is Resources: the SOPs, escalation rules, and writing conventions your team already has, that most tools never bother to use. That's the operating knowledge that was already sitting in a shared drive, now available to the part of the system that reasons.

Closing thoughts

Gartner's prediction that 40% of enterprises will demote or decommission autonomous agents by 2027 due to governance gaps points at the same failure mode from the other direction: teams granting full autonomy everywhere, without matching it to what each process needs. The fix is knowing which parts should behave like Level 1 and which should reason like Level 4, and building both into the same system instead of picking one architecture for the whole thing.

That's the whole exercise: what mix of levels a system runs, and whether that mix fits what you're asking it to do.

If you want a system built on that mix, reasoning where judgment is the point, fixed execution where it isn't, get in touch. Not another RPA tool wearing an agentic label.