These three solve different problems and cost very different amounts. They get sold interchangeably because “AI agent” is what people want to buy right now.
Paying agent prices for an automation problem is the commonest way money gets wasted in this category. The distinction is not academic.
The one-line version
| What it does | |
|---|---|
| Automation | Follows a fixed script you defined. Same input, same output, every time. |
| Chatbot / assistant | Responds to a person in conversation. Answers; does not act. |
| Agentic system | Given a goal, decides its own steps, uses tools, acts without approval per step. |
Full comparison
| Automation (incl. RPA) | Chatbot / assistant | Agentic system | |
|---|---|---|---|
| Given | Instructions | A question | A goal |
| Decides its own steps | No | No | Yes |
| Uses tools and APIs | Only those you wired | Rarely, narrowly | Yes — chooses which |
| Handles unexpected input | Breaks, or silently misreads | “I can’t help with that” | Adapts or escalates |
| Deterministic | Yes | No | No |
| Needs supervision | Minimal | Per conversation | Boundaries + audit + owner |
| Running cost | Very low | Low | Scales with every step |
| Typical build cost | £3k – £20k | £5k – £25k | £18k – £120k |
| Fails by | Stopping | Being unhelpful | Acting wrongly |
That last row matters more than any other. Automation fails loudly. Chatbots fail politely. Agents fail quietly and confidently — which is why they need audit logs and escalation paths that the other two do not.
The flowchart test
The single most useful question:
Can you draw this process as a flowchart that does not change?
Yes → build the flowchart. Automation will be cheaper, faster, more reliable and easier to debug. You do not need AI.
No, because the inputs vary → you probably want an agent. Different document layouts, different exception types, different routes to the same outcome.
No, because a human needs to decide → you want a chatbot or an assistant that surfaces information to that human, not an agent that decides for them.
Most people underestimate how much their process actually varies — which is precisely why their existing automation keeps breaking on the exceptions. That is the signal an agent is justified.
Which one your supplier is probably proposing
A rough guide to reading a proposal, since the labels are unreliable.
“AI-powered automation” — usually automation with one model call doing extraction or classification. Often exactly right, and should be priced as automation.
“Intelligent document processing” — typically a specialised extraction product plus rules. Mature, reliable, cheaper than a custom agent. Worth evaluating before commissioning anything.
“AI assistant” — a chatbot. Answers questions, does not act on systems.
“Autonomous agent” / “agentic workflow” — should mean a genuine agent with tools and a loop. Verify by asking how many model calls one task makes and whether it can act without per-step approval.
“Multi-agent system” — several specialised agents with a supervisor. Rarely necessary, two to three times the cost, and worth challenging before accepting.
“Copilot” — a human stays in the loop for every action. Frequently the right choice in regulated work, and it should not be priced as autonomous.
Worked example: three versions of the same job
The job: a customer emails asking where their order is.
Automation
Watches the inbox. If the subject contains “order status” and the body contains a number matching an order ID pattern, look it up and send the template reply.
Works when the email is well formed. Breaks when the customer writes “hi, any update on the thing I ordered last Tuesday?”
Cost: low to build, almost nothing to run.
Chatbot
Customer visits the site, a widget asks for an order number, looks it up and displays the status.
Works when the customer visits the site and has the number. Does not help the ones who email instead, which is most of them.
Cost: low to moderate.
Agent
Reads the email in any phrasing. Works out which customer it is from the email address. Finds their recent orders. Identifies which one “last Tuesday” means. Checks the courier’s tracking API. Notices the delivery is two days late. Drafts a reply with the actual status and an apology, and either sends it or queues it for approval depending on the boundaries you set.
Works across the messy reality of how customers write. Costs meaningfully more to build and has a per-email running cost.
Which is right? Depends entirely on volume and how much of your inbox is the messy version. At 40 emails a week, automation plus a human. At 400, the agent pays for itself. Work out the number first.
Cost over three years, compared
The same job — processing 2,000 documents a month — built three ways.
| Automation | Agent | Hybrid | |
|---|---|---|---|
| Build | £14,000 | £32,000 | £24,000 |
| Monthly running | £40 | £620 | £180 |
| Handles unexpected formats | No — fails | Yes | Yes |
| Exception rate requiring a human | ~35% | ~15% | ~15% |
| 3-year total | £15,440 | £54,320 | £30,480 |
| Plus human exception handling | ~£18,000 | ~£7,700 | ~£7,700 |
| Real 3-year cost | £33,440 | £62,020 | £38,180 |
Indicative. Exception handling costed at 4 minutes each at £19/hour fully loaded.
What this shows: pure automation looks cheapest until you count the humans still handling a third of the volume. The pure agent handles the most and costs the most to run. The hybrid gets the agent’s exception rate at roughly half the running cost, because only the judgement step uses model calls.
Change the volume and it moves. At 300 documents a month, automation plus a human wins easily. At 10,000, the hybrid wins by a wide margin.
Where RPA sits
Robotic Process Automation — tools like UiPath, Blue Prism, Power Automate — is automation that works by driving the user interface. It clicks buttons and types into fields as a person would.
Useful when a system has no API and cannot be integrated any other way. Genuinely valuable for legacy systems.
Fragile because it depends on the screen staying the same. A vendor update that moves a button breaks the process.
Increasingly blended with AI. Many RPA vendors now add AI components for reading documents. That is often the right hybrid: AI reads the unstructured input, RPA performs the deterministic clicking.
Reliability, compared honestly
The trade nobody states plainly: you give up determinism to gain adaptability.
Automation is deterministic. Same input, same output, every time, for ever. You can reason about it completely. When it breaks, it breaks visibly and in the same place.
Agents are not deterministic. The same document processed twice can produce slightly different reasoning, and occasionally a different decision. Modern models are consistent enough for most business tasks, but “consistent enough” is not “identical”.
What follows practically:
| Automation | Agent | |
|---|---|---|
| Reproducible | Always | Usually |
| Testable | Fully | Statistically |
| Explainable | Read the code | Read the log, trust the reasoning |
| Fails | Loudly, in one place | Quietly, in varied ways |
| Auditable | Trivially | Only if you built logging |
Where this matters most: anything where the same input must produce the same output as a matter of policy or law — statutory calculations, regulated pricing, safety thresholds. Write those as rules in code and let an agent handle everything around them.
Where it matters least: classification, extraction, triage and routing, where a small variance in borderline cases has no consequence and a human reviews the uncertain ones anyway.
The hybrid that usually wins
Most real systems are not one of the three. They are a sequence.
Example — invoice processing:
- Automation watches the inbox and files attachments (deterministic, cheap)
- Agent reads the document, extracts the fields, matches to a PO, decides whether it is in tolerance (varies, needs judgement)
- Automation posts approved invoices into the accounting system (deterministic, cheap)
- Human handles the exceptions the agent escalated
The agent is used only for the step that genuinely requires judgement. Everything else is cheap, reliable and deterministic.
This is almost always the right architecture, and it is rarely what gets proposed — because “we’ll build you an AI agent” sells better than “we’ll build you three small things, one of which uses AI.”
How to tell which you are being sold
Ask these:
“How many model calls does one task take?” Zero means automation, whatever the sales deck says. That is fine — but you should not be paying agent prices for it.
“What happens if the input is in an unexpected format?” “It handles it” means agent. “It would need configuring” means automation.
“What is the monthly running cost at our volume?” Agents have one that scales. Automation effectively does not.
“Can it take actions without a human approving each one?” That is the actual definition of agentic.
Auditing what you are being sold
Four checks you can run on any proposal, whatever it is called.
1. Count the model calls per task. Zero means automation. Exactly one means a classifier or an extraction step — useful, and not an agent. Several, varying by input, means an agent.
2. Ask what happens with input nobody anticipated. “It handles it” or “it escalates with a reason” indicates an agent. “It would need configuring” indicates automation. “It would error” indicates automation without error handling.
3. Ask for the monthly running cost at your volume. Automation has effectively none. An agent has one that scales with every task. A supplier who has not calculated it has not finished designing the system.
4. Ask who approves each action. If a human approves every step, you have an assistant rather than an agent — which may be exactly right, particularly in regulated work, but it should be priced as one.
Building the hybrid properly
The sequence architecture — automation for the deterministic steps, an agent only for the judgement step — is usually right and rarely proposed. Here is how it is actually assembled.
Stage 1 — deterministic trigger and preparation. Watch the inbox or the folder, validate the file is readable, store it, record that it arrived. Plain code. Near-zero cost. Fails loudly, which is what you want at the front of a pipeline.
Stage 2 — the judgement step. The agent. Given a narrow data view, a small tool set, a step limit and a spend cap. Returns a structured decision with a confidence score and its reasoning.
Stage 3 — deterministic routing. Plain code again. Above the confidence threshold, proceed. Below it, escalate to a human queue with the agent’s reasoning attached.
Stage 4 — deterministic action. Post to the accounting system, update the record, send the notification. Code, not an agent, because this step must be exactly right every time.
Stage 5 — logging. Every stage writes what it did. This is what makes the system explainable when something unexpected happens.
Why this shape wins: the agent is used for the 20% of the work that genuinely needs judgement, and the other 80% runs on cheap, reliable, debuggable code. Running cost drops substantially, and when something breaks you can tell which stage broke.
Why it is rarely proposed: “we will build you an AI agent” sells more easily than “we will build you five small things, one of which uses AI”.
Picking the right one, in order
A decision sequence rather than a comparison table.
1. Can you draw the process as a flowchart that never changes? Yes → automation. Stop here. It is cheaper, faster, more reliable and easier to debug.
2. Does a human need to make the decision? Yes → build something that surfaces the right information to them. An assistant or a well-designed screen, not an agent.
3. Does an existing product already do this? Document extraction, invoice processing and meeting notes all have mature products. Trial two before commissioning anything.
4. Is the volume above roughly 200 occurrences a month? No → the arithmetic will not work on a five-figure build. Automate the deterministic parts and leave the rest with a person.
5. Which single step genuinely requires judgement? Name it. That step gets an agent. Everything before and after it is code.
6. Does any part need different authority or audit treatment? Yes → that is the case for splitting into separate agents. No → one agent, with sub-tasks if the instruction set is large.
Most businesses that start at step one end at step five with a hybrid, which is both the cheapest workable answer and the one least often proposed.
Frequently asked questions
What is the difference between an AI agent and a chatbot?
A chatbot responds to a person with text. An agent acts on systems — reading databases, calling APIs, sending messages, updating records — without a human approving each step. A chatbot that is wrong gives a bad answer you can see. An agent that is wrong takes an action you may not.
Is agentic AI just automation with extra steps?
No. Automation follows a script and breaks when reality differs from it. An agent decides its own route and adapts. The practical difference shows up on unexpected input: automation fails or silently misreads, an agent adapts or escalates.
What is the difference between RPA and agentic AI?
RPA drives user interfaces, clicking and typing as a human would, following a fixed script. It is useful for systems with no API and fragile when screens change. Agentic AI decides what to do rather than replaying recorded steps. They combine well — AI for reading unstructured input, RPA for deterministic clicking.
Which is cheapest?
Automation, by a wide margin, both to build and to run. Agents cost more to build and carry a per-task model cost that scales with volume. If automation solves your problem, use it.
Can I start with automation and move to an agent later?
Yes, and it is often sensible. Automate the deterministic parts first, measure which exceptions a human still handles, and only then decide whether an agent is justified for those.
How do I know which one I need?
Apply the flowchart test. If the process can be drawn as a flowchart that never changes, use automation. If the route genuinely varies, consider an agent. If a human must make the decision, build something that informs them instead.
Written by Jas Singh, Founder. Last updated 8 October 2026.
