What is the difference between an AI agent and an automation?
The words get used interchangeably in sales copy, and the difference matters because it changes what you have to test and what can go wrong. There are three things people mean, and only the third is an agent.
None of the three is better than the others. They are answers to different questions, and the cheapest one that does the job is the right one.
| What it is | Who decides the next step | A job it fits | What can go wrong |
|---|---|---|---|
| An automation | You, in advance, as a drawn path | An order arrives, an invoice is created, a message is sent | A step fails, or the path no longer matches the process |
| An automation with an AI step | You, still: the model reads or drafts inside one fixed step | Read a messy enquiry, sort it, draft the reply for a person to approve | The model reads it wrong, so the wrong branch runs |
| An agent | The model, at run time, from a list of tools you allowed | Investigate why a payment failed, then choose which system to check next | It chooses a wrong path, loops, or acts outside what you meant |
How do you tell which one your process needs?
One question decides most of it: does the next step depend on what the last one found? If you can answer that by drawing the branches on a page, draw them. A drawn path is cheaper to build, far cheaper to test, and you can explain it to whoever inherits it.
If you genuinely cannot draw the branches, because the next action depends on reading something unstructured and deciding what it means, that is where an agent earns its place. Anthropic's own guidance on building effective agents makes the same point: use the simplest thing that works, and add autonomy only when the task needs it.
- Write the process as a list of steps. If the list is stable and the order never changes, it is an automation.
- Mark the steps where a person currently reads something and makes a judgement. One or two of those is an AI step inside an automation, not an agent.
- Ask whether the number of possible paths is small enough to write down. Five paths you can name is a flowchart. Fifty you cannot is an agent.
- Ask what happens if it chooses wrong. If a wrong choice sends a customer the wrong price, you want a drawn path with a human approval, not autonomy.
- Ask who will debug it at nine in the evening. A drawn path can be read. An agent's reasoning has to be logged well enough to replay, which is work somebody has to do.
What does an agent need that an automation does not?
This is the part that gets left out of a demo, and it is most of the difference in effort. An automation needs an error path. An agent needs all of that plus a boundary, because it is choosing actions rather than following them.
- A short list of tools it may use, and nothing else. An agent that can reach every system you own is a liability, not a feature.
- A stop condition: a maximum number of steps, a time limit, and a rule for when it must hand back to a person.
- A log of what it decided and why, in enough detail to replay a bad run. Without this you cannot tell a wrong answer from a wrong tool.
- A human approval on anything irreversible: sending money, deleting a record, replying to a customer in your name.
- A set of real past cases that runs again whenever you change it, so you find out whether the change made it better or only different.
- A cost ceiling, because an agent that loops is also an agent that bills. The arithmetic for the running bill is in the AI agent development cost guide.
What goes wrong with each one?
The failure modes are different, which is why the testing is different. Knowing which one you are buying tells you what to ask for before launch.
- An automation fails at a step: a changed interface, an expired credential, a field that moved. It usually fails loudly, and the fix is local. The dangerous version is the one that keeps running and quietly does nothing.
- An AI step fails by reading something wrong, and then the automation confidently continues down the wrong branch. The fix is a confidence rule and a hand-off, not a bigger model.
- An agent fails by choosing a path you did not intend, repeating itself, or stopping halfway with the job half done. The fix is bounds and logs, and it has to be designed in rather than added after the first incident.
- All three fail the same way when nobody owns them. An automation nobody watches is a subscription to a problem you have not noticed yet.
When should you hire someone, and when should you not?
The honest answer depends on which of the three you actually need.
- Do it yourself when it is two systems with clean connectors and a path you can draw. That is an afternoon, and doing it teaches you what the process really is.
- Hire someone when a failure costs you a customer or a payment, when the path crosses systems that do not talk cleanly, or when a model has to read something unstructured and the result matters.
- Hire someone for an agent only when you can name the tools it may use and the point at which it must stop. If you cannot, buy the automation first and let the real cases tell you where the deciding step belongs.
- Do not buy an agent because the word sounds more advanced. I build all three, and I will tell you plainly when the cheaper one does the job, because the expensive one you did not need is the fastest way to lose trust in the whole idea.
Can you start with an automation and add an agent later?
Yes, and it is the order I recommend. The decisions that make it cheap are made on day one, not at the upgrade.
- Keep the process in your own account, with steps named for what they do, so a deciding step can replace a fixed one without a rewrite.
- Log what went in and what came out from the start. That log is the evidence you will need to decide where autonomy actually helps.
- Keep credentials and permissions as data rather than hard-coded, so the tool list an agent may use is a change to a list, not a change to the build.
- Collect the cases where a person had to intervene. Those are the exact places an agent would earn its cost, and they are free to gather while the automation runs.
What to remember
- An automation follows a path you drew; an agent chooses its next step from what it found. One AI step inside a fixed path is still an automation.
- Draw the branches if you can. Autonomy is worth paying for only when the next action genuinely depends on the answer and the paths cannot be written down.
- An agent needs a tool allowlist, a stop condition, a replayable log, human approval on irreversible actions and a cost ceiling. Those are build decisions, not settings.
- Both start at $499, because the price follows the work rather than the label.
Sources
Primary documentation, for anyone who wants to check the details.