"Agentic AI vs RPA: Which Processes to Hand to an Agent"

Emerix's August 2026 field guide opens with the line that defines the buying year: every vendor in your inbox is agentic now. Kognitos and Tungsten Automation published 2026 guides reframing automation around agents, and Appian's October 2026 buyer's guide is about evaluation criteria and warning signs rather than features — the sign of a market that has moved from "does this work?" to "where should it apply?".

That is the gap this post fills: a rule for which processes to hand to an agent, which to leave with the bots you already own, and which to leave alone.

RPA executes a path someone defined in advance. An agent decides which path to take. Almost every practical difference follows from that.

• Input shape. A script needs the same structure every time. An agent accepts variation — but wider variation means relying on judgement rather than rules.
• Exceptions. Automation hands exceptions to a queue. An agent can attempt resolution, but every attempt is a decision, and decisions need evaluation rather than logs.
• Interface. Bots drive the screen because that is what exists; agents prefer a tool or an API. If the only access is a UI that changes quarterly, an agent is a maintenance liability with a language model attached.
• Cost shape. Bots carry a licence, a build, and a maintenance charge every time a screen changes. Agents carry a build, per-task inference, an evaluation set and guardrails. Comparing the two on licence price is the most common error in the category.

None of these is a defect. They are a fit profile.

Score each process from 1 to 5 on five questions, then add them.

• Input variability. Fixed templates score 1; free-text email and scanned documents score 5.
• Exception rate. Under 5% scores 1; above 30% scores 5.
• Interface stability. Stable APIs score 1; a UI refreshed every quarter scores 5.
• Cost of a wrong action. Reversible and cheap scores 1; sending money, filing a document or notifying a regulator scores 5.
• Judgement density. Pure data movement scores 1; multi-source judgement scores 5.

A rough routing rule: 5–12, keep it as a script or bot. 13–19, build a hybrid. 20–25, an agent is the right shape — with the caveat that a high cost-of-wrong-action score should add an approval gate rather than subtract the agent. The value is not the number: it forces the conversation onto the process, not the platform.

• Unstructured input. Claims, invoices in forty layouts, inbound email, PDFs that must be read before anything can be keyed.
• Exception-heavy queues. Where the standard path fails a third of the time, the exception handler is the process.
• Cross-system judgement. The answer needs a lookup in three places and no single system owns the truth.
• Awkward interfaces. Inconsistent schemas and undocumented edge cases are agent territory; a stable API is not.

• High-volume and deterministic. Data sync, report distribution, fixed-format capture, batch updates.
• Regulated steps needing exact replication. If the audit requirement is "show me it did the same thing every time", a deterministic script is easier to defend than a reasoning trace.
• Irreversible actions. Payments, filings and deletions are better served by a hard stop than a probabilistic decision.
• Bots that already work. Replacing a stable bot adds cost, variance and a new failure surface. An agent is a different tool for a different shape of work, not an upgrade to a working script.

The pattern that survives production is simple: the agent decides, the script executes, the trace records both.

The agent reads the request, decides what is needed, and calls a scoped tool — frequently an existing bot or a single endpoint. Execution stays deterministic, judgement sits where variability actually lives, and the blast radius of a bad decision is limited to the tools you granted. Scope each tool to the narrowest action that completes the task, read-only where possible, and log every call with the agent's stated reason.

Appian's October 2026 guide frames the buying conversation around questions rather than features — the difference between a demo and a deployment.

• What happens on the twentieth-percentile case — the exception, not the happy path?
• Which systems does the agent touch, with what credentials, and can that scope be narrowed?
• What does a full trace contain, can we export it, and how is quality evaluated after go-live?
• What is the cost per completed task at our volume, not per seat?
• How do you migrate the bots we already run, and what is the manual fallback on day one?

A vendor that cannot answer the last question is selling a pilot, not a production system. The governance detail sits in securing production AI agents.

Inventory by exception rate, not by bot count.

• Low exceptions: keep. These are the cheapest automation you will ever own.
• Rising exceptions: wrap in an orchestration layer so an agent can handle the cases the bot abandons.
• Brittle and high-maintenance: retire. Every screen change is a recurring bill with no strategic return.

Expect to keep more bots than you retire in year one — which is why the cost case in AI agent development cost looks nothing like a platform licence.

• Week 1: pick two processes at opposite ends of the scorecard and score them with the people who run them.
• Week 2: instrument both — cycle time, exception rate, cost per completed case.
• Week 3: build the agent path only for the high-variability process. Leave the other as a script.
• Week 4: compare cost per completed case, exception handling and rework.

Compare on cost per completed case, including maintenance and human review — the figure finance recognises, and the one that makes the platform debate irrelevant. The measurement model is set out in AI agent ROI.