From RPA to Agentic Automation: When to Graduate, When to Stay

Every major RPA vendor, UiPath, Automation Anywhere, Blue Prism, is repositioning around agentic AI. Their message: deterministic RPA is yesterday; LLM-driven agents are the future. The reality on the ground is more nuanced. Plenty of workflows still belong on RPA, plenty have already outgrown it, and the hard work is knowing which is which.

The market data tells part of the story. Gartner forecasts worldwide RPA software revenue will reach $3.6 billion in 2024, with growth slowing to single digits as buyers reassess where deterministic automation actually fits. Meanwhile vendor marketing has shifted almost entirely to "agents," "copilots," and "autonomous workflows." The mismatch between where revenue lives and where messaging points should make any senior practitioner cautious. We've seen too many programs lurch toward agentic platforms before they've finished extracting value from the RPA they already own.

What changes with agentic automation

Traditional RPA executes a deterministic sequence of UI or API actions encoded by a developer. Agentic automation gives an LLM-driven agent a goal and a toolkit and lets it decide the sequence dynamically. The two have different strengths:

• RPA is fast, cheap to run, deterministic, and auditable. It is brittle to UI change and incapable of handling unstructured inputs.
• Agentic automation handles unstructured inputs, reasons over exceptions, and adapts to interface change. It is slower, more expensive per execution, less deterministic, and harder to audit.

Choosing between them is a workload-fit question, not an ideology question. The cost gap is larger than most slide decks acknowledge. An RPA bot execution typically costs fractions of a cent in compute; an agentic run with a frontier model can run anywhere from a few cents to several dollars depending on context length and tool-call depth. OpenAI's published pricing for GPT-4o sits at $2.50 per million input tokens and $10.00 per million output tokens, and a multi-step agent can easily consume 50,000 to 200,000 tokens across a single complex task. At a million executions per year, the difference between substrates is not marginal, it is a budget line item.

The four-quadrant framework

We assess automation candidates on two axes: input structure (structured vs unstructured) and decision complexity (rule-based vs judgment-based).

• Structured input, rule-based decisions. RPA's home turf. Invoice posting, order entry, employee onboarding via clean systems. Stay on RPA. Agentic automation here adds cost and reduces auditability for no benefit.
• Structured input, judgment-based decisions. Hybrid territory. RPA for the orchestration, an LLM call for the judgment step, with explicit fallback to human review when the LLM's confidence is low. Common in claims triage and credit decisioning.
• Unstructured input, rule-based decisions. RPA cannot handle this without OCR/IDP layers; agentic automation handles it natively. Invoice extraction from emails, document classification, customer correspondence routing. This is where most "graduation" projects pay off.
• Unstructured input, judgment-based decisions. Agentic automation's strongest fit. Complaint resolution, contract review, exception handling. Also the area with the highest governance burden, treat with the controls described in our earlier governance papers.

A useful corollary: if your candidate workflow has well-defined APIs on both ends and the decision logic fits in a flowchart, neither RPA nor agents are the right answer. Direct integration is. We routinely find that 15 to 25 percent of an existing RPA estate is actually a backlog of API integrations that were deferred because RPA was faster to build. Those should be retired, not migrated.

The migration trap

The most common mistake is wholesale migration of an existing RPA estate to agentic automation. Most RPA processes run in the lower-left quadrant; moving them to agents adds cost, reduces determinism, and creates auditing headaches without delivering meaningful benefit. The right strategy is to keep stable RPA where it works, retire RPA that has been replaced by direct API integration (often a better answer than either RPA or agentic), and reserve agentic spend for the upper quadrants where unstructured inputs or judgment are the bottleneck.

A counter-take worth stating plainly. The prevailing industry view, pushed by vendors and echoed by most analyst commentary, is that agentic automation will subsume RPA within three to five years. We disagree. Deterministic automation is not a transitional technology waiting to be replaced; it is a different category with structural advantages that LLM-based agents cannot match for a large class of workloads. Auditability, predictable cost, sub-second latency, and the ability to certify that a process behaves identically across millions of runs are not nice-to-haves in regulated industries, they are mandatory. Until agent frameworks deliver formal guarantees on output behavior (and current architectures fundamentally cannot), RPA will remain the correct substrate for the majority of back-office automation. The agent-everything narrative is a vendor preference, not an engineering conclusion.

Operational considerations that surprise teams

Several operational realities catch agentic-automation programs off-guard:

• Cost variability. Agentic execution costs vary by 5 to 20x depending on conversation length and tool-call depth. Unit economics that worked in pilot can fail at scale if not modeled with worst-case path costs. We recommend building a cost model that includes the 95th-percentile path, not just the mean. A workflow that averages $0.12 per run but has a long tail at $2.40 will blow its budget on a bad input distribution.
• Latency. Agent runs of 10 to 60 seconds are common. RPA runs of 2 to 10 seconds are typical. The user experience implications differ substantially, some workflows tolerate the change; some do not. Synchronous customer-facing flows usually do not. Asynchronous batch processes usually do.
• Audit and explainability. Agentic decisions need richer audit logs than RPA: the prompt, the tools called, the intermediate reasoning, and the final action. Compliance and audit teams almost always want more than the agent framework provides by default. For regulated workloads, the NIST AI Risk Management Framework provides a useful baseline for the controls auditors will eventually ask about, particularly the MEASURE and MANAGE functions, which map directly to the logging and oversight gaps we see in early agentic deployments.
• Non-determinism in regression testing. RPA programs build regression test suites that compare expected outputs to actual outputs byte-for-byte. That technique fails on agents. Test design has to shift toward distributional checks, does the agent produce acceptable output across a sample of 500 inputs at an acceptable rate?, and that requires statistical literacy most automation teams do not have on staff.
• Tool-call failure modes. When an RPA bot encounters an error, it stops. When an agent encounters a tool-call error, it often retries, reformulates, or hallucinates an alternative path. We've seen agents quietly succeed on a wrong sub-task and report success, a failure mode that does not exist in deterministic systems. This is an argument for tight tool definitions and aggressive output validation, not for trusting the agent to recover gracefully.

Governance and regulatory pressure

The governance overhead is rising independently of the technology choice. The EU AI Act, which entered into force on 1 August 2024, classifies a number of common back-office use cases, credit scoring, employment decisions, insurance pricing, as high-risk, with documentation, human-oversight, and post-market monitoring obligations that apply whether the underlying engine is a rule-based bot or a frontier model. The compliance question is not "agentic or not" but "is the workload high-risk or not." A team that migrates a credit-decisioning RPA process to an agent and assumes its existing model-risk-management documentation still applies is in for an unpleasant audit.

In our work with financial-services clients, the practical effect is that agentic deployments require roughly 2 to 3 times the documentation effort of equivalent RPA deployments before go-live. That cost is rarely included in the business case. It should be.

Build, buy, and the platform question

The vendor landscape is consolidating around three patterns: incumbent RPA platforms bolting on agent capabilities (UiPath Autopilot, Automation Anywhere AI Agent Studio); cloud hyperscalers offering agent frameworks (AWS Bedrock Agents, Azure AI Foundry, Google Vertex AI Agent Builder); and open-source frameworks (LangGraph, CrewAI, Microsoft AutoGen). Each has trade-offs.

Incumbent RPA platforms offer the smoothest migration path for existing customers but tend to lag the frontier on model selection and orchestration sophistication. Hyperscaler offerings give you direct access to the best models and the deepest tool ecosystems but require more in-house engineering capability. Open-source frameworks offer maximum control and minimum lock-in but shift the operational burden onto your team.

For most enterprises, we recommend a split: keep RPA on the incumbent platform for stable lower-quadrant work, and build new agentic workloads on a hyperscaler framework where the model and tool flexibility matter. Avoid the temptation to consolidate everything onto a single vendor's "unified" stack, those promises tend to age poorly, and the switching costs of agentic systems are higher than RPA's because the prompts and tool definitions are tightly coupled to the framework.

What to do this quarter

If you have an active RPA estate and are evaluating agentic automation, three exercises deliver the most signal:

1. Map every existing RPA process onto the four-quadrant framework. Expect 60 to 80 percent to remain best served by RPA, 15 to 25 percent to be candidates for direct API replacement, and only 5 to 15 percent to be genuine agentic candidates. If your numbers come out wildly different, your classification is probably wrong.
2. Pick one or two upper-quadrant processes, ideally ones where unstructured input is the current pain, for an agentic pilot, with explicit unit-economic modeling, audit requirements, and worst-case latency budgets defined upfront. Build the cost model before you build the agent.
3. Stand up agentic-specific observability before the second pilot, not after. Prompt logging, tool-call traces, output-validation pipelines, and a sampling-based human review queue. Retrofitting these is more expensive than building them in.

Resist the vendor pressure to declare a wholesale platform transition. The vendors selling that transition have their own incentives, and those incentives are not aligned with the operational reality of your estate.

The bottom line

Agentic automation is a powerful addition to the automation toolkit, not a replacement for everything that came before. The teams getting the most value are running both, with clear criteria for which workflow belongs on which substrate, and with governance frameworks that scale with the risk of the workload rather than the novelty of the technology. The teams getting the least value are migrating for migration's sake, chasing a vendor narrative that mistakes new capability for universal applicability.

The right framing for the next 18 months is portfolio thinking. RPA, direct integration, and agentic automation are three tools, each with a defensible niche. Senior practitioners build a portfolio that uses all three deliberately. Programs that pick one and try to apply it everywhere will spend more, audit worse, and ship slower than the ones that match substrate to workload.