RPA Is Fading—Agentic AI Is Taking Over Automation

South African e-commerce and digital services teams are hiring more customer support agents, adding more ops staff, and still falling behind on basics like refunds, stock updates, onboarding, and compliance checks. The common excuse is “we need more people.” Most of the time, the real issue is the automation stack.

Here’s the stance I’ll defend: RPA isn’t the automation strategy you build the next three years on. It still has its place, but the centre of gravity has shifted to agentic AI—systems that can interpret intent, handle messy inputs (emails, PDFs, WhatsApps), and coordinate actions across tools with governance.

This post is part of our series on how AI is powering e-commerce and digital services in South Africa. If you’re responsible for growth, ops, customer experience, or IT, the RPA-to-agents shift is not an abstract “enterprise trend”. It’s the difference between scaling profitably and drowning in exceptions.

Why RPA stopped being “strategic” (and what replaced it)

RPA works when the world stays still; digital business doesn’t. Classic RPA automates by following scripted steps—click this button, copy that value, paste it there. That’s fine for stable, repetitive tasks. But as soon as the UI changes, a field moves, or a workflow adds an extra approval, bots break and you’re back to manual work.

In the ITWeb piece, Deon van Niekerk (CTO at Ovations Technologies) calls it plainly: RPA as a strategic paradigm is dead. Not because it never delivered value, but because organisations have outgrown what deterministic bots can do.

What replaced it is an AI-first automation model:

• Agentic AI for goal-driven work (agents plan steps, handle exceptions, interpret content)
• Standardised tool connectivity (the article highlights Model Context Protocol, or MCP)
• Governed orchestration (headless BPM/workflow engines for audit trails, state, routing)

If RPA is “automation that follows,” agentic AI is automation that can reason inside guardrails.

From bots to agents: what “agentic AI” actually means in operations

Agentic AI is outcome-based automation. Instead of scripting every step, you define the goal (and constraints), and the agent figures out the path—calling tools, validating data, requesting human approval when required, and logging what it did.

That sounds lofty until you map it to everyday e-commerce and digital services work.

What agents do better than RPA in real workflows

Agents handle unstructured inputs. Think:

• A customer emails a proof of payment as a PDF
• A courier sends a delivery exception note
• A merchant submits onboarding docs with missing fields
• A chargeback arrives with narrative text and attachments

RPA doesn’t “understand” any of that. Agents can extract meaning, classify intent, and decide what to do next.

Agents manage exceptions without collapsing. Most teams underestimate how many edge cases exist:

• Partial refunds
• Split shipments
• Out-of-stock substitutions
• Duplicate customer profiles
• Disputed deliveries

A scripted bot hits an exception and stops. A governed agent can:

1. Detect the exception
2. Pull policy rules
3. Propose a resolution
4. Route to a human if the confidence is low or policy requires approval

Agents can coordinate across systems. Modern digital businesses operate across a sprawl: e-commerce platform, OMS, CRM, payments, courier portals, accounting, helpdesk, and marketing automation. Agents can orchestrate end-to-end flows across these tools—if you connect them safely.

Snippet-worthy: RPA automates tasks. Agentic AI automates outcomes—especially when the inputs are messy and the process isn’t perfectly predictable.

The hidden cost of RPA in South African e-commerce and services

The biggest RPA bill isn’t the licence; it’s the maintenance tax. In fast-changing environments—promotions, UX tweaks, new payment methods, new courier integrations—RPA breaks often. That creates a cycle:

• Bot fails
• Ops team patches manually
• RPA team updates scripts
• New exception appears
• More scripts, more monitoring, more overhead

Van Niekerk describes this as RPA scaling linearly: every new bot becomes another thing to babysit.

In South Africa, that pain is amplified by common realities:

• Multiple channels (web, app, marketplace, WhatsApp)
• Identity and address variance (formatting differences, missing data)
• Network and service variability (timeouts, intermittent integrations)
• Complex payments (EFT proofs, instant EFT providers, card, wallets)

Those are exactly the conditions where brittle UI-mimicking automation performs worst.

“But we can’t rewrite our legacy systems”

You don’t need a big-bang rebuild. The practical move is shifting from UI automation to tool-based automation (APIs, events, integration layers) and using agents on top to handle the messy reasoning.

If you’re stuck with a legacy admin interface and no APIs, RPA can still be useful as a stopgap. But it shouldn’t be your long-term centrepiece.

MCP, governance, and why “agent washing” is a real risk

Agents are only as safe as their guardrails. The Gartner point in the source is worth repeating: AI agents are in the hype phase, and “agent washing” is real—vendors rebranding chatbots or simple workflows as agents.

A useful litmus test: if the system can’t reliably do structured actions, keep state across long-running workflows, and produce an audit trail, it’s not ready for regulated, high-volume operations.

MCP in plain terms

The article calls MCP “USB‑C for AI,” and that analogy holds: MCP is a standard way for an agent to discover tools and execute actions without you building brittle glue code for each system.

For e-commerce and digital services, that matters because it reduces the “integration penalty” of automation. Instead of creating a custom connector for every tool and bot, you aim for a consistent interface layer.

Why headless workflow matters (especially for compliance)

If agentic AI is making decisions and taking actions, you need governance that’s not optional:

• State management: track where every order/refund/onboarding case is
• Auditability: who/what did what, when, and why
• Exception routing: escalate to humans with context
• Policy enforcement: apply limits (refund thresholds, fraud checks, approval rules)

In practice, that “nervous system” is often a headless BPM/workflow engine that orchestrates humans + systems + agents.

Snippet-worthy: Agents without workflow governance create faster chaos. Agents with governance create scalable operations.

Practical agentic AI use cases for e-commerce and digital services (SA-ready)

Start where the volume is high and the exceptions are painful. Here are use cases I’ve seen produce real wins because they combine reasoning + automation.

1) Refunds and returns that don’t spiral

A governed agent can:

• Read the ticket/email/WhatsApp message
• Verify order status, delivery proof, and payment method
• Apply your returns policy (time windows, item categories)
• Decide: auto-refund, request more info, or escalate
• Trigger the refund in payments/ERP and notify the customer

Where RPA fails is the “in-between”: mismatched order IDs, partial returns, damaged items, or missing documents.

2) Customer support deflection that actually resolves issues

A basic chatbot deflects. An agent resolves.

An agent can:

• Identify the intent (delivery delay, address change, invoice request)
• Pull real-time order data
• Take actions (update address within policy, rebook delivery, generate invoice)
• Summarise the outcome back to the customer and to the ticket

This reduces handle time and improves first-contact resolution—two metrics that directly affect margin.

3) Merchant or user onboarding with document intelligence

South African onboarding often involves:

• IDs and proof of address
• Company registration docs
• Bank confirmation letters
• Contract acceptance and risk checks

Agents can extract fields, validate completeness, flag risk signals, and route edge cases to compliance teams.

4) “Ops copilot” for daily exceptions

Think of a queue where weird stuff lands: failed payments, stuck orders, pricing mismatches, courier exceptions.

A useful agent doesn’t just describe the problem—it proposes the fix, with a buttoned-up action plan:

• Root cause hypothesis
• Systems checked
• Recommended action (and the exact transaction)
• Confidence score
• Audit log entry

A simple migration plan: from RPA dependency to agent-first automation

You don’t rip out every bot. You reduce your reliance on bots for anything that changes weekly. Here’s a pragmatic sequence for teams that need results in Q1/Q2 2026.

Step 1: Classify your processes (keep, replace, redesign)

Use three buckets:

• Keep in RPA: stable UI, deterministic steps, low change rate (e.g., a monthly report export)
• Replace with agents: unstructured inputs + frequent exceptions (support, refunds, onboarding)
• Redesign around APIs/events: core order and payment flows that should never depend on UI clicks

Step 2: Write “outcome specs” instead of bot scripts

For each candidate process, define:

• Goal (e.g., “resolve refund request within 2 hours”)
• Allowed actions (payments, OMS, CRM)
• Constraints (policy rules, approval thresholds)
• Required logging fields

This becomes the contract for agent + workflow.

Step 3: Put governance in place before you scale

Minimum governance for production:

• Role-based tool permissions
• Human approval gates for high-risk actions
• Full audit trail
• Monitoring (cost, latency, error rates, override rates)
• Red-team testing for prompt injection and data leakage

Step 4: Measure what the CFO actually cares about

Pick metrics that tie to margin and customer experience:

• Cost per resolved ticket
• Refund cycle time
• % cases auto-resolved vs escalated
• Ops hours saved per 1,000 orders
• Error rate and rework rate

If you can’t measure it, you’ll argue about it forever.

Where this is heading in 2026 (and the competitive risk of waiting)

The ITWeb article references Gartner’s expectation that by 2028, a meaningful share of enterprise decisions will be made autonomously by agents. Whether the exact percentage lands or not, the direction is clear: automation is moving from “do these steps” to “achieve this outcome under policy.”

For South African e-commerce and digital services, the competitive pressure is immediate:

• Customer expectations are set by instant, always-on experiences
• Margins are tight; headcount-heavy ops models don’t scale
• Complexity is rising (more channels, more fraud, more compliance)

If your automation strategy is still “add more bots,” you’ll ship more patches than improvements.

The better target is an AI-first automation layer: agents for reasoning, standardised tool connectivity, and a workflow engine that keeps everything governed.

If you’re mapping your 2026 roadmap right now, here’s the question to end on: Which parts of your operation are still designed around scripts—when they should be designed around outcomes?