RPA vendors adding AI agents: UiPath and Automation Anywhere

The wave of RPA vendors adding AI agents is reshaping procurement conversations in enterprises that already run thousands of brittle automation scripts. UiPath and Automation Anywhere now package LLM-powered “agents” alongside their traditional record-and-replay bots, promising cognitive capability without ripping out existing infrastructure. The thesis here is blunt: these additions are pragmatic bridges for legacy automation, but they inherit an orchestration model that fights the nondeterminism agents require.

The RPA mental model

RPA succeeded by simulating human keystrokes and screen scrapes with deterministic flows. A bot clicks fixed coordinates, reads a grid, writes to a form. Failure is an exception, not a branch. That mental model shaped the entire platform: centralized control rooms, queue-based transaction processing, and strict variable typing.

Determinism vs. probabilistic control flow

An LLM agent thrives on ambiguity. It plans, calls tools, observes results, and replans. The loop is stochastic. RPA platforms wrap model calls in the same try-catch, retry, and schema-validation scaffolding they use for SAP GUIs. The result is a constrained agent that must justify every step to a central orchestrator before it acts.

Why UiPath and Automation Anywhere built agents this way

Both vendors bolt agents onto their existing runtimes. UiPath’s agent features plug into Orchestrator queues and use activities that mirror HTTP or Excel tasks. Automation Anywhere’s Co-Pilot and autonomous agents execute within the Bot Agent runtime, where every action is logged for compliance. This design protects their install base but caps autonomy at the edges of pre-drawn workflows.

What “AI agents” look like in UiPath

UiPath lets you drop a “Call LLM” activity into a workflow. You pass prompts and receive structured output validated by a JSON schema. For document processing, they offer ML extractors, but the agentic part is a state machine you draw in Studio.

A typical pattern (simplified XAML):

<Sequence>
  <CallLLM Prompt="Extract invoice fields" ResponseSchema="InvoiceSchema" />
  <If Condition="InvoiceSchema.Confidence > 0.9">
    <WriteToQueue Item="InvoiceSchema" />
  </If>
</Sequence>

The agent cannot freely decide to open a new browser tab or query a vector store unless you pre-built those activities. That is fine for bounded tasks like triage, but it is not open-ended reasoning.

What “AI agents” look like in Automation Anywhere

Automation Anywhere exposes generative steps through its Control Room. You configure a bot that includes an AI action, often backed by a model fine-tuned for a process. The runtime still enforces variable typing and step limits.

Conceptual bot definition:

{
  "task": "process_email",
  "steps": [
    {"action": "get_mail", "folder": "inbox"},
    {"action": "genai", "prompt": "summarize", "model": "gpt-4o"},
    {"action": "write_excel", "file": "summary.xlsx"}
  ]
}

Again, the LLM is a node, not the conductor. The workflow author decides when it runs.

The architectural mismatch

Control inversion

In a native agent loop, the model decides the next tool. In RPA, the workflow author decides, and the model fills slots. This inverts the hierarchy. When you need multi-step reasoning across systems, you end up drawing enormous state diagrams instead of writing a few lines of Python.

Model access and routing

RPA vendors typically partner with one or two model providers. Swapping models or using a local model for cost means filing a support ticket. By contrast, an OpenAI-compatible gateway gives you direct routing.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.n4n.ai/v1",
    api_key="sk-...",
)
# n4n.ai forwards cache-control hints and fails over automatically
resp = client.chat.completions.create(
    model="anthropic/claude-3.5-sonnet",
    messages=[{"role": "user", "content": "Plan a refund flow"}],
    extra_headers={"x-cache": "read"},
)

The gateway addresses 240+ models and handles provider degradation without code changes. RPA platforms rarely expose that flexibility; you are locked to their curated list.

State and memory

True agents maintain episodic memory and retrieve across sessions semantically. UiPath and Automation Anywhere store state in queues or Excel files. That works for transactional loads but breaks when the agent needs to reflect on past interactions beyond a correlation ID.

Error handling and retries

RPA retries on exception. An agent that gets a bad tool result should reason about it, not blindly retry. In UiPath, a failed LLM call often triggers a catch block that halts the transaction. In Automation Anywhere, step limits can kill a long agent loop. The platform’s resilience patterns are tuned for UI flakiness, not model hallucination.

Where RPA agents win

Legacy UI and desktop control

No LLM stack can reliably click a 1998 green-screen terminal field. UiPath’s UI Automation and Automation Anywhere’s Universal Recorder still beat vision models for pixel-dense enterprise apps. If your agent must bridge a mainframe and a cloud API, the RPA layer is the only pragmatic path.

Governance and audit

Enterprises trust RPA control rooms for role-based access, credential vaults, and session recordings. A custom Python agent calling an LLM lacks that out of the box. For regulated workflows, the vendor’s agent wrapper provides an audit trail that satisfies compliance officers.

Tradeoffs for engineers

A pragmatic stack

Build the reasoning core as a lightweight agent service. Use the RPA vendor for the last mile: scraping a portal, pressing buttons. Call the RPA bot via its REST API when the agent decides a UI action is needed.

def agent_step(ctx):
    plan = llm_plan(ctx)  # calls gateway with fallback
    if plan.needs_ui:
        requests.post(
            "https://rpa-controlroom/api/run",
            json={"bot": "sap_login", "args": plan.ui_args},
            auth=("client", "secret"),
        )
    return execute_tools(plan)

# Loop with simple reflection
for _ in range(5):
    out = agent_step(ctx)
    if out.done:
        break
    ctx = out.observation

This hybrid uses each tool for its strength. The cognitive loop stays in code you control; the robotic arms stay in the RPA control room.

Takeaway

RPA vendors adding AI agents are solving a real integration problem, not inventing a new agent paradigm. If you are automating a legacy desktop app with occasional judgment calls, UiPath or Automation Anywhere will get you to production fastest. If you are building open-ended agents that reason across many models and data sources, build on LLM-native infrastructure and treat RPA as a peripheral driver. The decisive move: keep the cognitive loop in code you control, rent the UI robotic arms where needed.