Robotic Process Automation in 2026: Where Bots Still Win, Where They Break, and How Agentic Automation Changes the Playbook

Robotic Process Automation (RPA) has been written off more than once. In practice, software robots are still doing a great deal of unglamorous, valuable work in finance, HR and operations teams. What has changed is the shape of a good automation programme: bots are now one component in a wider system that also reads documents, makes judgements and hands exceptions to people.

What RPA actually is#

RPA software mimics the actions a person takes on a computer: opening applications, clicking buttons, copying values between screens, reading spreadsheets, sending emails. It works at the user-interface layer, which is both its superpower and its weakness. It can automate a legacy system that has no API, but it is sensitive to anything that changes on screen.

Bots typically run in one of two modes:

• Attended bots run on a user's own desktop, triggered by that person, and help them with part of a task.
• Unattended bots run on their own, usually on dedicated or virtual machines, triggered by a schedule, a queue or an event. Microsoft's documentation for Power Automate, for instance, describes unattended desktop flows running on virtual machines with no user signed in, under a separate licence from attended use.

Where RPA shines and where it fails#

RPA is at its best when the work is repetitive, rule-based and high-volume, and when the systems involved are stable. It is at its worst when you ask it to cope with ambiguity or constant change.

Good fits:

• Moving structured data between systems that do not talk to each other
• Scheduled report generation and distribution
• Rule-based validation and reconciliation
• Bulk updates in legacy or vendor-hosted applications without usable APIs

Poor fits:

• Processes where the steps vary from case to case
• Inputs that are mostly unstructured: free-text emails, scanned letters, handwritten forms
• Applications whose screens are redesigned frequently
• Work that needs judgement a person cannot write down as rules

The classic failure mode is the brittle bot. A vendor portal moves a button, a pop-up appears that nobody planned for, or a field label changes, and the bot either stops or, worse, carries on doing the wrong thing. Most disappointing programmes automated the wrong processes and underinvested in maintenance.

Choosing the right processes: a suitability scorecard#

Before you build anything, score each candidate process. Adapt the weighting below to your organisation.

Criterion	Strong candidate	Weak candidate
Rules	Clear, documented decision rules	Relies on individual judgement
Volume	Frequent, repeated transactions	Occasional, one-off tasks
Input format	Structured or semi-structured	Mostly unstructured or handwritten
UI and system stability	Applications change rarely	Frequent releases or redesigns
Exception rate	Exceptions are rare and well understood	Exceptions are common or unpredictable
API availability	No usable API exists	A stable API is available (integrate instead)
Business impact	Errors or delays are costly	Low cost of the current manual approach

Note the API row. If a system offers a reliable API, an integration is usually more robust than a bot driving its screens.

Fix the process before you automate it#

Automating a bad process gives you a faster bad process. Before a single bot is built, map the process as it actually runs, not as the policy document says it runs.

1. Map the as-is flow. Shadow the people doing the work. Capture every system, every hand-off and every workaround.
2. Measure the baseline. Record volumes, handling time, error and rework rates, and turnaround time. Without a baseline you cannot prove any benefit later.
3. Simplify and standardise. Remove redundant approvals, merge duplicate checks and agree a single way of doing the task across teams.
4. Then decide what to automate. Some steps will need a bot, some an integration, some a document-AI model, and some will simply disappear.

This is the core of our business process consulting work. Our article on procurement digitisation from RFQ to GRN shows the same principle applied to a full purchasing cycle.

From RPA to intelligent and agentic automation#

The biggest shift in the last few years is that RPA no longer works alone. A modern automation typically combines three layers:

• Document AI turns invoices, statements and forms into structured data. Vendors now ship this as part of their platforms; UiPath, for example, offers Document Understanding and its newer IXP extraction capability for unstructured content.
• LLM-based agents handle the steps that need interpretation: classifying an email, drafting a supplier query, deciding which exception queue an item belongs to.
• Bots and integrations execute the deterministic actions: posting entries, updating records, filing outputs.

The major platforms now market themselves around this combination. UiPath positions Maestro as an orchestration layer for agents, robots and people. Automation Anywhere describes "agentic process automation" as process orchestration with AI agents embedded for particular sub-steps or decisions, with human-in-the-loop checkpoints. Microsoft builds on Power Automate's cloud and desktop flows alongside its AI tooling.

The practical lesson is to keep the deterministic and probabilistic parts separate. Let the agent interpret and recommend; let the rule-based bot act; and route low-confidence decisions to a person. Our AI and LLM engineering team designs these boundaries explicitly.

The tooling landscape#

There is no single right platform. A quick orientation:

• UiPath: a broad enterprise platform covering bots, orchestration, document processing and agentic orchestration via Maestro, available as cloud or self-hosted.
• Microsoft Power Automate: cloud flows plus Power Automate for desktop for UI automation, attractive if you already run on Microsoft 365 and Azure.
• Automation Anywhere: the Automation 360 platform, now centred on AI agents combined with bots, APIs and document workflows.
• Open source: Robot Framework with the RPA Framework libraries (Apache 2.0 licensed) lets teams build automation as code in Python. Robocorp, which sponsored those libraries, was acquired by Sema4.ai in 2024, so check the current roadmap before committing.

Choose on your existing stack, data-residency needs, licensing and team skills, not a vendor demo.

Governance: what keeps automation safe#

Bots are digital workers with access to sensitive systems. Treat them accordingly.

• Centre of Excellence (CoE): a small central team that owns standards, the process pipeline, reusable components and platform administration, while business units suggest and prioritise candidates.
• Bot credentials: store them in a vault, give each bot its own identity with least-privilege access, and rotate passwords on schedule. Never let a bot borrow a human's login.
• Audit trails: log every action a bot or agent takes, with inputs and outputs, so finance and compliance teams can trace any transaction.
• Change management and testing: when an upstream application is updated, regression-test the bots that depend on it. Our quality engineering practice treats bots as production software, with test suites and release gates.
• Exception ownership: every automated process needs a named human owner for the items the bot cannot handle.

Framing ROI honestly#

Ignore headline ROI figures; your own baseline is the only number that matters. Build the case on:

• Hours of manual effort saved, measured against your baseline
• Error and rework reduction, and the cost of those errors
• Faster cycle times, such as quicker month-end close or onboarding
• Compliance benefits: consistent controls and complete audit trails
• Total cost: licences, infrastructure, build effort and, crucially, ongoing maintenance

If a case only works on the assumption that bots never need fixing, it does not work.

Indian examples that suit automation well#

• GST reconciliation: match the monthly GSTR-2B statement against the purchase register invoice by invoice, flag mismatches and draft supplier follow-ups. Since input tax credit generally depends on invoices appearing in GSTR-2B, this is high-value, rule-heavy work.
• Invoice processing: document AI extracts GSTIN, invoice number, HSN/SAC codes and tax amounts; rules validate them; a bot performs three-way matching against purchase orders and goods receipts before posting.
• HR onboarding: create accounts across HRMS, email and payroll, generate offer and joining documents, and track document collection.
• Bank statement reconciliation: pull statements from multiple banks in their varied formats, normalise them and match against the ledger, leaving only unmatched items for the accounts team.

Each of these improves further when requirements are captured clearly at the start; tools such as Reqvise help teams document process rules before they are encoded in bots.

FAQs#

Is RPA still relevant now that AI agents exist?#

Yes. Agents interpret well, but many steps still need deterministic, auditable execution in systems without APIs.

What is the difference between attended and unattended bots?#

Attended bots run on a user's desktop and are triggered by that person. Unattended bots run independently on dedicated or virtual machines, triggered by schedules or queues.

Should we use RPA or an API integration?#

Use an API whenever a stable one exists; it is more robust. Use RPA for legacy or third-party systems that offer no practical integration route.

How do we start without a large investment?#

Map and measure two or three candidate processes, pick the one with the clearest rules and highest volume, and run a time-boxed pilot with a proper baseline.

Ready to find out which of your processes are worth automating? Talk to our team.