Every automation conversation eventually hits the same question: "should this be a bot or an agent?" The honest answer is that RPA and agentic AI sit at opposite ends of a spectrum, and picking the wrong one costs you either reliability or flexibility.
What RPA is actually good at
RPA (robotic process automation) shines when a process is stable, rules-based, and UI-bound — the kind of work where a human follows the same fifteen clicks every time because there's no API to call. Think: copying data from a legacy mainframe screen into a modern system, reconciling two spreadsheets by exact-match rules, or filling out a vendor portal that will never get an integration.
The strength of RPA is determinism. A well-built bot does exactly the same thing every run, which makes it auditable and easy to reason about when something breaks — you look at the step it failed on, not a black box.
The weakness is brittleness. Change a button's position, add a new field to a form, or introduce an exception the bot wasn't scripted for, and it stops cold.
What agentic AI is actually good at
Agentic AI — an LLM that plans, calls tools, and adapts based on what it observes — is good at the opposite: judgment-heavy, variable work where the steps depend on the input. Triaging a support ticket, drafting a first-pass response to an ambiguous request, or deciding which of five systems to check based on what a document says.
The strength is flexibility. The agent doesn't need every case pre-scripted; it reasons about novel situations using the tools you've given it.
The weakness is exactly that flexibility — it's probabilistic, not deterministic. Two runs of the same input can take different paths, which makes it harder to guarantee (and audit) than a bot that never deviates from its script.
The practical rule of thumb
If you can write the process as a flowchart with no judgment calls, use RPA — you'll get more reliability for less cost. If the process requires reading unstructured input and deciding what to do next, you need an agent. And for most real enterprise workflows, the answer is both: an agent decides what needs to happen, and calls RPA bots (or direct APIs) as tools to actually do it deterministically.
That's the pattern I keep coming back to: agentic AI for the reasoning layer, RPA for the execution layer where a screen-scrape is genuinely the only integration option available.
# comments
loading comments...