RPA Isn't Dead—It's the Agent's Hands. Here's How to Buy the Right Stack

What should you actually build with AI automation in 2025?

Here's a number that should reframe your next automation roadmap discussion: the global RPA market is estimated at $4.68 billion in 2025 (Grand View Research). That's not a dying category—it's a growing one, projected to hit $35.84 billion by 2033. Yet every week I talk to teams who think RPA is legacy and that agentic AI is the only thing worth investing in. That's a false choice. The dominant emerging architecture layers AI agents for reasoning over an RPA execution layer, so agents drive RPA rather than replace it (Robotic process automation, Wikipedia). If you're planning your automation stack for the next 18 months, the real question isn't "RPA or agents?"—it's "how do I combine deterministic execution with adaptive reasoning in a way that's actually maintainable?" Let's reason through that.

What's the difference between RPA and agentic AI?

RPA follows predefined, rule-based scripts—think copying data between applications, filling forms, and moving files. It's deterministic and brittle. Agentic AI, on the other hand, uses large language models to understand natural language, reason, plan tasks, call tools, and make context-based decisions (Intelligent agent, Wikipedia). Agents can handle variability and ambiguity, but they introduce uncertainty—you don't always know exactly what they'll do. AWS puts it clearly: traditional software follows pre-defined rules, traditional AI requires prompting and step-by-step guidance, but agentic AI acts independently in a goal-driven manner (AWS, What is Agentic AI?). That independence is powerful, but it's also why you can't just let an agent loose on your production systems without guardrails.

RPA is like a reliable factory worker who does the same task perfectly every time. Agentic AI is like a smart project manager who can adapt to unexpected events—but might occasionally take a wrong turn. You need both. The factory worker executes the plan; the project manager decides what to do next.

Why the hybrid architecture wins

UiPath describes three phases of RPA evolution: Task Automation (2010s), AI Automation (2018-2022), and Agentic Automation (2023-present) (UiPath, RPA). In the current phase, RPA serves as the execution layer that turns the plans and reasoning of AI agents into tangible actions (UiPath). That's the key: agents are great at deciding, but they're not great at reliably clicking through a legacy system or filling out a form in a virtual desktop. RPA is. So instead of replacing RPA with agents, you end up with agents that orchestrate RPA bots—and that's what the market is actually doing.

Consider an insurance provider using intelligent automation to calculate payments, estimate rates, and address compliance needs (IBM, intelligent automation). If you tried to do that with a pure agent, you'd have to trust the model to perform calculations exactly right every time—risky. If you used pure RPA, you'd have to hard-code every possible scenario—impossible. The hybrid approach lets the agent decide which policy documents to pull and which rates to apply, then hands off to an RPA bot to execute the actual data entry in the core system.

Here's a concrete example from IBM's research: a multi-agent legal research assistant routed queries through a low-cost classifier first, escalating only complex cases—cutting contract review time from 90 minutes to 45 minutes (IBM, AI agents). That's a 50% reduction, not because an agent did everything, but because an agent decided what needed deep attention and what could be handled quickly.

How to decide: a practical framework

When you're evaluating a new automation project, you need to assess two things: the complexity of the task and the tolerance for error. Let's break it down.

If your task is a stable, high-volume process like invoice processing, RPA is your workhorse. If it's a task that involves judgment, like triaging customer inquiries, you need an agent. But the sweet spot is often a blend: an agent classifies the inquiry, then an RPA bot updates the CRM.

One thing to keep in mind: agentic AI can also decide when to escalate to a human. The ReAct paradigm (Reasoning and Acting) generates reasoning traces and task-specific actions interleaved, which helps overcome hallucination issues (ReAct paper, arXiv). That's a sign of a well-designed agent—it knows when it doesn't know.

What about the orchestration layer?

As you move toward agentic automation, the platform you use matters more than the individual bots. UiPath emphasizes that platforms must intelligently orchestrate the work of thousands of robots, AI agents, and people within long-running workflows across mixed ecosystems (UiPath). This isn't just about running a bot—it's about dynamically assigning tasks, managing context, escalating exceptions, and ensuring alignment to business outcomes in real time.

That's where standards like the Model Context Protocol (MCP) come in. MCP is an open-source standard for connecting AI applications to external systems—data sources, tools, and workflows (Model Context Protocol docs). Think of it as a "USB-C port for AI applications" (MCP docs). Instead of building custom integrations for every tool, you build once and integrate everywhere. Microsoft Foundry Agent Service supports remote MCP servers, and its Toolbox exposes a curated set of tools through a single MCP-compatible endpoint (Microsoft Foundry Agent Service docs). This is the kind of infrastructure that makes hybrid automation practical.

If you're starting from scratch, look for a platform that supports MCP out of the box, plus low-code tools for citizen developers (UiPath). You don't want your automation stack to be a science project that only your AI PhDs can maintain.

What about governance and risk?

Here's the uncomfortable truth: organizational change and human oversight, not technology, are the biggest barriers to AI automation adoption (Robotic process automation, Wikipedia). That's from the fact base, and it matches what I see in practice. The EU AI Act is coming into force, with risk-based rules for AI systems (European Commission). High-risk systems will face strict obligations starting December 2027, including risk assessment, high-quality datasets, activity logging, and human oversight (European Commission). NIST's AI Risk Management Framework provides a voluntary framework for trustworthiness considerations (NIST).

If you're deploying agents that make decisions affecting customers or employees, you need to plan for governance from day one. That means:

• Defining clear goals and boundaries for each agent.
• Implementing human-in-the-loop checkpoints for high-stakes actions.
• Logging every decision and tool call for audit trails.

This isn't just about compliance—it's about making sure you can trust your automation. When SWE-bench was introduced, the best-performing model solved only 1.96% of real-world software engineering issues (SWE-bench paper). We're still early. You can't assume your agent will get it right every time.

My recommendation

Stop thinking about RPA vs. agentic AI. Start thinking about your automation portfolio. For each process, ask: "What's the execution layer? What's the decision layer?" Use RPA for the heavy lifting—the deterministic, high-volume tasks that need to be exact. Use agents for the judgment calls—the tasks that require reasoning, planning, and tool use. And build an orchestration layer that can manage both, using standards like MCP to avoid vendor lock-in.

The market is already moving this way. The autonomous enterprise market is projected to reach $114 billion by 2029 (MarketsandMarkets). That's not either/or—it's both. The teams that get this right will be the ones that treat automation as a system, not a single tool. They'll design for hybrid workflows, invest in governance, and keep humans in the loop where it matters. That's how you build automation that lasts.

Sources

• Robotic process automation (Wikipedia) - https://en.wikipedia.org/wiki/Robotic_process_automation
• Grand View Research (RPA market) - https://www.grandviewresearch.com/industry-analysis/robotic-process-automation-rpa-market
• UiPath (RPA) - https://www.uipath.com/rpa/robotic-process-automation
• IBM (AI agents) - https://www.ibm.com/think/topics/ai-agents
• AWS (What is Agentic AI?) - https://aws.amazon.com/what-is/agentic-ai/
• Model Context Protocol (official docs) - https://modelcontextprotocol.io/introduction
• Microsoft Foundry Agent Service (docs) - https://learn.microsoft.com/en-us/azure/ai-services/agents/overview
• ReAct paper (arXiv, ICLR) - https://arxiv.org/abs/2210.03629
• SWE-bench paper (arXiv, ICLR) - https://arxiv.org/abs/2310.06770
• NIST AI Risk Management Framework - https://www.nist.gov/itl/ai-risk-management-framework
• European Commission (EU AI Act) - https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai
• MarketsandMarkets (RPA market) - https://www.marketsandmarkets.com/Market-Reports/robotic-process-automation-market-104435980.html