AI agents vs. chatbots vs. RPA

Picture a service leader with three problems on her desk: password resets are drowning tier one, someone keys 400 invoices a week into an ERP that has no API, and refund disputes need a human to read four emails and make a call. Three very different problems. In 2026, all three attract the same pitch — “you need an AI agent.”

Usually she doesn’t. Gartner predicts that more than 40% of agentic AI projects will be cancelled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls — and, in the same research, estimates that only about 130 of the thousands of vendors claiming agentic capability actually offer it. The rest are “agent washing”: chatbots, RPA, and assistants rebadged to match the moment. The problem isn’t that agents don’t work. It’s that agents are one class of automation among four, and each class wins on a different kind of task.

This post defines the four classes — scripted chatbot, RPA bot, copilot, autonomous agent — compares them on variability, integration surface, failure modes, cost, and governance, and gives you a decision table that maps task characteristics to the right one.

Four classes of automation, and what each one actually is

The labels get blurred in vendor material, so it’s worth pinning down what each class does mechanically. The differences are architectural, not cosmetic.

Scripted chatbots: a decision tree with a chat window

A scripted chatbot is deterministic conversation. Intents are recognised (with some lightweight NLP), and each intent triggers a pre-authored dialogue: buttons, slot-filling questions, a lookup, an answer. In the Salesforce world this is Einstein Bots territory. The bot never decides anything — its authors decided everything in advance, and it replays their decisions at scale. That rigidity is the point. A scripted bot will read your data-privacy disclosure verbatim, every time, in the legally approved wording.

RPA bots: muscle memory for other people’s software

Robotic process automation drives applications the way a human operator would — clicking, typing, copying between screens — usually because the system underneath has no API worth calling. An RPA bot executes a recorded, rule-based procedure with perfect fidelity as long as the screens and the input format don’t change. It handles structured data through unstructured interfaces. That’s a niche, but in enterprises full of legacy ERPs, green-screen terminals, and portals nobody will ever rebuild, it’s a big niche.

Copilots: judgment on tap, a human on the hook

A copilot (or assistant) wraps an LLM around a person’s work. Microsoft’s own framing is useful here: a copilot is an AI-powered assistant that supports tasks and boosts productivity, while agents are the specialised tools it can hand work to. The copilot drafts, summarises, suggests, retrieves — and then hands the output back. The human remains the actuator. Every consequential step passes through a person who can veto it, which is precisely why copilots are the low-drama entry point for generative AI: the error-handling system is the employee.

Autonomous agents: goal in, actions out

An agent takes a goal, plans steps, calls tools, observes results, and re-plans until it’s done — without a person approving each move. Salesforce’s Atlas Reasoning Engine describes this loop well: state, flow, and side effects, with the engine decomposing a request into smaller tasks and evaluating at each step how to proceed. The defining property is that the execution path is chosen at runtime by a probabilistic model, not at design time by an author. That’s what lets agents handle messy work, and it’s also the root of every governance question that follows.

Five dimensions where the four classes genuinely differ

Feature checklists make these tools look interchangeable. They aren’t. Five dimensions do most of the separating work.

Variability of input. Scripted bots and RPA require the world to arrive in expected shapes — a recognised intent, a consistent screen layout. Deviation means failure. Copilots and agents absorb variability natively because a language model interprets meaning rather than matching structure. If your inputs are genuinely unstructured — free-text emails, mixed-format documents, ambiguous requests — the deterministic classes were never candidates.
Integration surface. A chatbot touches a handful of read-mostly endpoints. An RPA bot touches one application, deeply and fragilely, through its UI. An agent needs broad, credentialed, write-capable access to act — and the Cloud Security Alliance notes that agents operate through non-human identities whose privileges can chain and escalate in ways security teams can’t predict. Every system an agent can write to is now part of your attack surface.
Failure modes. This one is underrated. Deterministic automation fails loudly: the selector broke, the bot stopped, the queue backed up. You find out. A probabilistic system fails quietly — it returns a fluent, confident, semantically wrong answer, and nothing crashes. Loud failures cost you throughput. Quiet failures cost you trust, and you often discover them weeks later in an audit.
Cost profile. Scripted bots and RPA are mostly fixed cost: build once, license the runtime, pay near-zero per transaction. Copilots are per-seat. Agents are consumption-priced — every reasoning step and action burns inference, which is why Salesforce’s own architecture guidance for hybrid deployments talks about reserving generative capability for non-deterministic work to reduce consumption costs. Running an LLM loop on a task a decision tree could handle is paying reasoning prices for lookup work, at volume, forever.
Governance burden. A scripted bot is governed by reviewing its script. An RPA bot, by reviewing its procedure. A copilot inherits a human approval on every output. An agent needs guardrails, action-level permissions, test suites for behaviour that isn’t deterministic, monitoring for drift, and an audit story for decisions no human made. That burden is real ongoing work — and “inadequate risk controls” is one of the three reasons Gartner gives for agentic project cancellations.

The decision table: match the task, not the trend

We find four questions settle most arguments. Is the input structured or unstructured? Are the steps deterministic, or is there judgment in the middle? What’s the error tolerance — can a wrong output be caught cheaply, or is it expensive and silent? And what’s the volume, since per-transaction economics diverge hard at scale.

Put those together and the mapping falls out:

Input	Steps	Error tolerance	Volume	Right class
Structured, bounded set of intents	Deterministic (lookup, status, FAQ, guided form)	Low — answers must be exact and repeatable	High	Scripted chatbot
Structured data, no API available	Deterministic (copy, key, reconcile, file)	Low — a wrong entry is a defect, not a judgment call	High	RPA bot
Unstructured (documents, threads, code)	Judgment required, human makes the final call	Moderate — a person reviews every output	Low–medium per person	Copilot
Unstructured or ambiguous	Judgment plus multi-step action across systems	Managed — guardrails, scoped permissions, escalation paths	Medium, growing	Autonomous agent
Mixed — messy front door, exact back office	Judgment to classify and triage; deterministic to execute	Low at the execution step	High	Agent orchestrating bots, RPA, and APIs

Two things about this table tend to surprise people. First, how few rows end in “autonomous agent.” Most enterprise task volume is structured input plus deterministic steps — the top two rows — which is exactly why chatbots and RPA got deployed everywhere over the last decade. Second, the last row is where mature implementations converge: the agent isn’t a replacement for the deterministic classes, it’s a router in front of them.

The same logic applies one level down inside a Salesforce org, where the choice is Flow versus Apex versus Agentforce — we’ve written a separate decision guide for Salesforce automation that walks through it.

Three tasks from the same help desk, three different answers

Go back to the service leader from the opening. Her three problems land in three different rows of the table.

Password resets and order status. Bounded intents, deterministic resolution, zero tolerance for creative answers, huge volume. This is scripted-chatbot work, and putting an LLM on it adds cost and a new failure mode while removing nothing. Salesforce’s own guidance on when to script and when to set agents free puts compliance-sensitive, high-consistency interactions explicitly on the deterministic end of the spectrum.
Invoice keying into the API-less ERP. Structured data, fixed procedure, exactness required, 400 a week. RPA. An agent could do this through computer use, slowly and expensively, with a nonzero chance of hallucinating a cost centre. The bot does it at machine speed for pennies. If the invoice formats vary wildly, add an extraction model in front — that’s the hybrid row, not a reason to abandon the bot.
Refund disputes. Unstructured email threads, judgment about intent and fairness, actions across billing and CRM. Here an agent — or a copilot, if you want a human approving each resolution while you build confidence — earns its consumption bill. This class of work was simply unautomatable before LLMs.

Note what changed between rows: not the sophistication of the technology you deserve, but the shape of the task. Salesforce runs this mix itself — it reports that Agentforce on its own help site resolves more than 84% of incoming customer questions, and its published architecture for that kind of deployment still routes high-volume transactional traffic through deterministic bots first.

Chatbots and RPA aren’t dead — they’re the substrate agents stand on

The lazy reading of the agent era is that the old tools are obsolete. The evidence points the other way: the deterministic classes are becoming the execution layer that agents call.

You can see this in how the platform vendors are actually building. UiPath — the company with the most to lose if RPA dies — describes its agentic platform as orchestration of agents, robots, and people, with agents handling the judgment steps and robots executing the structured, repeatable interactions they’ve always been better at. Salesforce’s developer guidance says the same thing at the code level: put deterministic business rules inside the Apex or Flow action itself, not in the agent’s natural-language instructions, and compose actions when a sequence must run exactly in order. And its bot-plus-agent reference pattern uses an Einstein Bot as the deterministic front door, handing off to the agent only when the request needs reasoning.

The principle underneath all of this: probabilistic systems should decide; deterministic systems should execute. An LLM is the right tool for “what does this customer want and which process applies?” It is the wrong tool for “compute the refund amount” — that’s arithmetic with a legally correct answer, and it belongs in code the agent invokes. Every deterministic step you delegate to a bot, a Flow, or an API is a step that can’t hallucinate, costs nothing to reason about, and produces an audit trail a regulator will accept.

In practice this means your existing chatbot scripts and RPA procedures are assets, not embarrassments. They’re pre-built, pre-tested deterministic tools waiting for an agent to call them. Ripping them out to “go agentic” is throwing away exactly the components the agent needs most.

Where agent projects actually die: cost curves and governance debt

Since agents are the most capable class, why would 40% of those projects get cancelled? Because capability was never the constraint — economics and governance were.

The cost failure is gradual. A pilot handling 50 conversations a day looks cheap. At 5,000 a day, the consumption meter becomes a budget line, and finance starts asking why the reasoning engine is being paid to answer “where’s my order” eight hundred times before lunch. Teams that didn’t segment traffic by task class discover they’ve bought a Ferrari for the school run — the fix is the routing pattern above, applied retroactively and under pressure.

The governance failure is quieter. An agent with write access to your CRM, billing, and email is a new privileged identity that acts at machine speed. Who reviews its permission set? Who tests behaviour that changes when the underlying model is upgraded? Who explains, twelve months later, why it granted a specific customer a specific exception? Deterministic automation has boring, well-understood answers to those questions. Agents have emerging ones, and Gartner’s cancellation drivers — cost, unclear value, inadequate risk controls — are what it looks like when organisations discover the answers late.

None of this argues against agents. It argues for entering the agent tier deliberately: with traffic segmented by task class, deterministic substrate in place, escalation paths defined, and someone owning the risk register before the first goal is handed over. That scoping exercise — which tasks, which class, in what order — is the core of the data and AI strategy work we do before anyone builds anything.

The dumbest machine that works is the right machine

The four classes aren’t rungs on a ladder where everyone climbs toward agents. They’re a portfolio, and the skill is allocation. Gartner’s same research that predicts the cancellations also predicts that 15% of day-to-day work decisions will be made autonomously by agentic AI in 2028, up from essentially zero in 2024. Both predictions are coherent: agents are becoming genuinely important on the minority of work that needs them, while the majority of automated volume stays deterministic — and the organisations that fail are the ones that can’t tell the two apart.

So run the four questions against each task on your backlog. Structured or unstructured. Deterministic or judgment. Cheap errors or expensive ones. Trickle or flood. Buy the dumbest class that clears the bar, and reserve agent spend for the rows where nothing dumber works. You’ll ship faster, your unit costs will survive contact with real volume, and when you do deploy an agent it will arrive to find a floor of tested, deterministic tools already built — which is the difference between an agent that reasons its way to calling proven automation and one that improvises in production. The teams getting durable value from agents in 2026 aren’t the ones who bet everything on the newest class. They’re the ones who could name, for every task, exactly why it needed the class it got.

Understanding the basics

What is the difference between a chatbot and an AI agent?

A chatbot follows scripts its authors wrote in advance: it matches a user’s request to a known intent and replays a fixed dialogue. An AI agent uses a large language model to choose its own execution path at runtime — planning steps, calling tools, and acting across systems to reach a goal. Chatbots are predictable and cheap per conversation; agents handle ambiguity but cost more and need stronger guardrails.

When should you use RPA instead of an AI agent?

Use RPA when the task is rule-based, the input is structured, the steps never require judgment, and the target system lacks a usable API — classic examples are keying invoices, reconciling records, and moving data between legacy applications. RPA executes identically every run at near-zero marginal cost. An AI agent doing the same work is slower, consumption-priced, and introduces a small but real chance of a confidently wrong output.

What is the difference between a copilot and an autonomous agent?

Autonomy. A copilot assists a person — drafting, summarising, suggesting — and hands every output back for human review, so the person remains the safety mechanism. An autonomous agent owns a goal end to end: it plans, takes actions across systems, and escalates only by exception. Copilots suit judgment work where a human must approve each result; agents suit multi-step work you’re prepared to govern with guardrails instead of per-step approval.

Trying to work out which of these four classes your backlog actually needs? Talk to us — matching tasks to the right machinery is what we do.

AI agents vs. chatbots vs. RPA: which class of automation does the job need?