Agentic Automation vs RPA: What to Replace First

A decade of RPA left mid-size companies with hundreds of brittle bots clicking through interfaces, each one a small hostage to the next UI update. Agentic automation — LLM-driven systems that pursue goals through tools — is genuinely different, but "rip out the bots" is bad advice. Here is the migration logic we use.

Why they fail differently

RPA fails on variation. It replays recorded steps. Invoice layout changes, portal adds a cookie banner, date field moves — the bot breaks silently or, worse, keys the wrong data confidently. Maintenance eats the ROI: industry folklore says one maintainer per 15–20 bots, and our client audits agree.

Agents fail on ambiguity. They handle variation well — a differently formatted invoice is just Tuesday — but given a vague goal and sharp tools they will do something, and without evaluation you will not love what. Agents need typed tools, approval gates on consequential actions, and logged reasoning. Different discipline, different failure surface.

What to migrate first

1. Document-heavy intake. Invoices, POs, supplier onboarding, claims. Extraction plus validation against your systems is where agents most embarrass legacy OCR-plus-rules stacks — the variation that killed RPA is exactly what models handle.
2. Cross-system reconciliation. Marketplace settlements vs bank deposits vs order records. Agents compare, explain discrepancies in plain language, and draft the correction for a human to approve.
3. Triage of anything. Support tickets, supplier emails, returns reasons. Classification with context beats keyword rules by margins that show up in headcount plans.

What to leave alone

• Stable, high-volume, structured flows. An RPA bot moving data between two unchanging systems at 99.9% is fine. Migrating it buys risk, not value. Schedule it for when an API replaces the UI.
• Anything with a real API path. The honest fix for many bots is neither RPA nor agents — it is the integration someone deferred in 2019. Agents clicking through UIs inherit RPA's fragility with extra steps.
• Hard-deadline compliance jobs where a deterministic script is auditable by reading it. Determinism is a feature; keep it.

The pattern that works

Run agents as the reasoning layer over your existing rails: agent decides, deterministic integrations execute, humans approve above thresholds. You get judgement where judgement helps and repeatability where regulators like it. Start with one process whose failure cost you can state in euros, instrument it, and let the logs argue for the next one.

We build these with approval gates by default and hand over the evaluation harness with the code — the automation practice is here. The first process usually pays for the second.