You have a task worth automating. The instinct now is to hand the whole thing to something clever. That instinct is the most expensive one in this field and it is the reason so many pilots quietly die around month four.
Before anything else, get the vocabulary straight, because these three words get used interchangeably by vendors and they describe systems with completely different risk profiles.
- A chatbot is a conversation. You ask, it answers, and nothing happens in the world unless you go do it. If you close the window and nothing was changed, moved, sent, or written, it was a conversation.
- A workflow is a sequence somebody designed. It might call a model six times and still be entirely fixed in shape. Run the same input twice and you get the same behavior.
- An agent receives a goal rather than a procedure and decides its own steps. Nobody wrote the sequence in advance. Two runs of the same task can take different routes and both be correct.
That last property is the source of every hard problem in this guide. It is also the property people accidentally buy when they did not need it.
The ladder
Go down this list in order and stop at the first level that genuinely handles the task. Do not skip to the bottom because the bottom is more interesting.
- Delete it. Does anyone read the output? Automating a report nobody opens produces the same report faster.
- Ordinary code, no model. Fixed rules on structured data. Cheaper, testable, and it does not surprise you at midnight.
- One model call. Messy input in, structured output out. Reading an invoice, classifying a ticket, summarizing a thread. Enormous value, almost no risk, and this covers more real cases than anything else on the ladder.
- A fixed workflow with model calls in it. The sequence is yours, the judgment inside two or three steps is the model's. Predictable, debuggable, and this is where most durable production systems actually live.
- An agent with tools, inside a fence. The route is genuinely unknowable in advance. Now you need everything in the rest of this book.
The rule
Stop at the first honest yes. Every step further down costs more money, more debugging, and more of the trust you will need for the next project.
What sends you down a rung
Three conditions, and you need at least one of them to justify an agent:
- The path is not knowable in advance. The answer might be in an email, a contract, a chat message, or nowhere. If you can draw the flowchart, build the flowchart.
- The environment changes faster than you can maintain rules. Vendors change formats, systems change shape, and a brittle script becomes a weekly chore.
- Failure is genuinely recoverable. The system can try, notice that it did not work, and try differently, without that first attempt having consequences.
That third one does most of the work and gets the least attention. An agent's core move is trying something and adjusting. If the first attempt sends an email to a customer, there is nothing to adjust. You cannot retry a sent message. Which does not mean the task is off limits, it means the irreversible step comes out of the agent's hands and goes behind a person.
The costs nobody prices
When you go down a rung, the bill arrives in four places and only one of them is on the invoice.
Tokens. An agent that explores uses several times the model calls of a fixed workflow doing the same job, because trying and backtracking is the entire point. This is real but it is usually the smallest of the four.
Debugging. When a fixed workflow breaks, you look at step four. When an agent produces a wrong result, you read a transcript of decisions trying to find the wrong turn. The run is not reproducible. Budget several times the investigation time.
Review. Every output a person has to check is a cost you moved rather than removed. Forty drafts a day requiring careful review may be worse than the manual process it replaced. Nobody wants to say so once the thing has been announced.
Trust. The scarcest resource. One confident wrong result in front of the wrong person costs you the next three projects. This is why the first thing you ship should be boring and low stakes, and why the ladder matters more than the tooling.
When the answer is genuinely yes
Real agent-shaped work exists and it is worth doing. Chasing a discrepancy through wherever the answer happens to live. Triaging an incident by pulling logs and forming a hypothesis. Researching something across sources nobody enumerated. What these share is an unknowable route and a cheap wrong answer. The output is a draft, handed to a person who was going to do the work anyway.
Say it out loud before you build
Whatever rung you land on, write one sentence and get agreement on it: this system takes X, does Y, and a person does Z before anything leaves the building. If nobody can say that sentence, the scope is not settled, and the version of it that emerges after launch will be settled by whoever is loudest.
Tell a team that four of their five steps belong in ordinary code and the fifth needs a person to sign off. It will not make you popular in the meeting. It saves them a quarter of engineering time and a system nobody trusts. They will thank you in March when the thing is still running.
Revision trail