RPA and AI: Let the LLM Think, Let the Bot Act (5 Patterns)

An RPA bot can run smoothly for months, then stop because someone renamed a column or a customer wrote an email in a way no rule expected.

That's the weak spot of robotic process automation (RPA). It is fast, cheap and exact, but it can fail as soon as an input looks different from what the bot expects. Large language models (LLMs) are the opposite. They handle messy, unstructured input well, but they are probabilistic, slower per task and harder to audit.

Combine them and you get a workflow that is flexible where the input is unpredictable and strict where the action must be correct.

Here are five ways to combine RPA and AI, when to use each one, and the guardrails that keep the workflow reliable.

Why RPA and AI work better together

RPA works best when a process follows clear, predictable steps. It can update records, move data between systems and repeat the same actions all day. But a renamed column, a changed button or an unfamiliar email format can stop it, and teams end up spending more time repairing bots than building new ones.

An LLM can read an email, understand a request or pull information out of a document even when no two look alike. But its output isn't always correct, so letting it approve payments or change important records on its own is risky.

The idea is simple: AI handles interpretation, RPA handles execution. Running both in one governed workflow is often called intelligent process automation.

UiPath's documentation draws the same line: robots bring stability, compliance and precision, while agents suit exception-heavy work where conditions and outcomes vary.

If your input is completely fixed, such as a scheduled export from an ERP, plain RPA is still the cheaper and more auditable choice. Hybrid automation earns its place when the input is messy.

The 5 hybrid automation patterns

Pattern 1: AI decides, RPA executes

An LLM reads a request and works out what needs to happen. It returns the details in a structured format, and an RPA bot or API call carries out the action.

Example: a customer emails a change-of-address request. The LLM extracts the customer's details and the new address. The workflow checks the extracted details before the bot updates the CRM.

Use it when: understanding the request is the hard part, but the action itself is simple and repeatable.

The model never touches your systems directly. It only produces data, and deterministic code decides whether to act on it.

Pattern 2: RPA calls an LLM for one difficult step

Sometimes a bot works well except for one step, such as classifying emails or extracting fields from documents with different layouts. Instead of rebuilding the workflow, let the bot call an LLM for that step and then carry on with its usual rules.

Here's a simplified Python example:

import json

ALLOWED_LABELS = {"invoice", "support", "other"}

def classify_email(body: str) -> dict:
    # call_llm() is a placeholder for whichever model API you use.
    raw = call_llm(
        "Classify this email as invoice, support or other. "
        'Reply only with JSON: {"label": str, "confidence": float}.\n\n'
        + body
    )

    try:
        data = json.loads(raw)
        label = data["label"]
        confidence = float(data["confidence"])
        if not 0.0 <= confidence <= 1.0:
            raise ValueError("confidence out of range")
    except (json.JSONDecodeError, KeyError, TypeError, ValueError):
        return {"label": "needs_review", "confidence": 0.0}

    if label not in ALLOWED_LABELS or confidence < 0.8:
        return {"label": "needs_review", "confidence": confidence}

    return {"label": label, "confidence": confidence}

Look at the fallback. A malformed response, an unknown label or a low confidence score sends the email to a human review queue instead of being guessed at. That one habit is what separates a demo from a production workflow.

One caution: an LLM's confidence score isn't a reliable measure of its actual accuracy. Test the threshold against real examples before you rely on it.

Use it when: a working bot regularly fails on one step with unpredictable input.

Pattern 3: The agent uses RPA as a tool

An AI agent receives a goal, decides which steps to take and calls RPA bots, APIs or other tools to carry them out. Each bot acts as a tool with defined inputs and outputs. Some automation platforms let agents trigger bots through APIs or protocols such as the Model Context Protocol (MCP).

This is agentic automation. UiPath, for example, describes orchestrating agents, robots and people together in one automation ecosystem. Before you build one, it helps to know how an AI agent differs from an assistant or a chatbot.

Use it when: the next step depends on the situation and the workflow has to choose between systems or actions.

Watch out for: agents are less predictable than plain bots. A 2025 study comparing an LLM agent with UiPath on three standard RPA challenges found UiPath ahead on speed and reliability, while the agent was quicker to set up and coped better with changing interfaces.

Agents need a clear audit trail too. Record the tools they call, the results they get and the decisions they make.

Pattern 4: RPA collects the data, the LLM analyzes it

The bot handles the mechanical work: logging into systems, downloading documents and collecting records. The LLM then analyzes what was gathered, summarizes it or flags patterns that need attention.

Example: in insurance claims, a bot collects the claim documents and related records. An LLM reads the descriptions and correspondence and flags suspicious patterns for a human investigator.

Use it when: getting to the data is the hard part, but analyzing it needs more flexibility than fixed rules allow.

Pattern 5: A human approves the action

Some actions are too important to leave entirely to automation. Before anything consequential or outbound, such as messaging a customer, approving a payment or changing a master record, the workflow pauses and asks a person to review.

The LLM drafts or recommends, the person approves, and RPA carries out the action. Platforms such as UiPath support this kind of human review of agent recommendations and exceptions.

Use it when: a mistake could cause financial loss, create compliance problems or reach a customer.

Once the logs show the model step is reliable, you can review which actions still need approval. High-impact ones may always need it.

Which pattern should you choose?

Patterns combine. Take invoice processing: an LLM extracts the vendor, amounts and line items from different layouts (Pattern 2), a person approves anything unusual (Pattern 5), and a bot posts the approved invoice. Each part has a clear job.

Guardrails for reliable LLM automation

Adding an LLM makes a workflow less predictable. A few basic controls keep it in check.

• Validate the output. Require structured data, such as JSON with a fixed format, and reject anything that doesn't match.
• Restrict acceptable results. Use allow-lists for approved labels and values, and send uncertain results to human review.
• Protect credentials. Keep passwords and API keys out of the model's reach. Let controlled code handle access to systems.
• Plan for failures. Decide what happens when the model returns an invalid response or a bot can't finish an action.
• Keep an audit trail. Record the input, the model output, the decision, the action taken and any human approval.
• Control costs. Set spending and usage limits so a loop or a bad input can't run up a bill.
• Measure performance. Compare accuracy, processing time and cost per task against the original workflow.
• Watch for silent failures. Alert on drops in completed tasks and spikes in review-queue items. It also helps to know how to monitor automations when something breaks.

Common mistakes to avoid

1. Automating a process you don't understand yet. Map the steps and exceptions first. If the process changes too often, it may not be ready to automate.
2. Replacing working bots with agents. If a process already handles predictable input reliably, adding an LLM can raise costs without improving results.
3. Letting the model act without controls. Validate its output, and match permissions and approval rules to the risk of the action.
4. Skipping the baseline. Without before-and-after numbers, you can't tell whether the changes save any time or money.

Frequently asked questions

Where to start

Find one step in an existing RPA workflow that regularly fails because the input varies. Add an LLM to handle that step, validate its output and send uncertain results for review.

Then compare the new workflow with the old one on accuracy, processing time and cost. If the results justify the extra complexity, extend the approach to other steps.

You don't need to rebuild the whole automation to benefit from AI. Start with the one problem your existing rules can't handle.