An AI Agent Is Not a Chatbot

Everyone wants one, and nobody means the same thing

Over the past year, almost every conversation about a new system reaches the question “and could we put an AI agent in there?”. The answer is nearly always yes. The trouble starts when you ask what exactly this agent is supposed to do — and what gets described is a chat window.

And a chat window is usually the least interesting thing you can build. Not because it isn’t useful, but because in most cases it isn’t what the person asking actually wants.

What a chatbot does

A chatbot waits. Someone asks, it answers, the conversation ends. Its output is words, and its value ends the moment the window is closed. Nothing in any system changed because of it.

That is not a criticism. A good support chatbot that saves an agent thirty calls a day is a real asset. But it is a conversation tool, and it needs a person on the other side to start the conversation. No person, nothing happens.

What an agent does

An agent doesn’t wait to be asked. It starts from an event: an email arriving, a file landing in a folder, an hour coming round, a row changing in a database. Nobody opens it and nobody types into it.

And its output isn’t words, it’s an action: a row written, an invoice created, a message sent, a task opened, a document moved on. When it is done, something in the world looks different — even though nobody watched it work.

But the trigger and the action are not what make it an agent — a simple automation has both. What makes it an agent is that the path is not fixed in advance. In an automation the steps are known before it runs; an agent is given a goal, chooses for itself which tools to use and in what order, reads what comes back, and decides on the next step — until the task is finished. That is the definition the industry works to, and it is worth knowing: it is the one you will hear from the other side of the table.

And note: the very same model can serve both. What separates them isn’t the artificial intelligence but the engineering around it — what triggers it, what it is allowed to touch, and what happens when it isn’t sure.

The rung everyone skips

But between the two sits an entire tier, and it is the one that goes missing from almost every conversation about AI. It is called workflow automation. It isn’t exciting, it has no handsome window, you can’t pose next to it at a conference — and it solves most of the problems that reach me.

It begins exactly as an agent does — the very same triggers I listed a moment ago. The difference opens up at the next step: from there the system advances according to rules written in advance, with not one moment of judgement anywhere in it. There are tools built for precisely this: n8n, Make, Zapier and their kin. I work mostly with n8n.

A chatbot — a person starts it, and words are what remain. Workflow automation — an event starts it, an action remains, and the rules decide. An agent — an event starts it, an action remains, and the system chooses its own path.

An example: a quote that starts from an email

A client emails asking for a shipping quote. The automation starts the moment the mail arrives: it reads the message and checks whether it contains everything needed to price the job — origin and destination, weight, volume, cargo type, dates. If something is missing, a polite reply goes back asking for precisely the missing details. If everything is there, a preliminary quote is drawn up — and it lands on a clerk’s desk for review, not in the client’s inbox.

Notice what is here and what isn’t. The whole spine is ordinary automation: trigger, check, branch, send. In exactly one place is judgement required — reading an email written in free prose and working out what it says and what it lacks. That, and only that, is where the model comes in.

And the last step is the heart of it: the quote is not sent to the client. It is put in front of the clerk. That is the permissions question from earlier, in its practical form — allowed to read, allowed to draft, not allowed to commit the company to anything.

A second example: a recorded lesson that becomes an assignment

A lesson recording is uploaded to a Google Drive folder. That is the trigger. From there: transcription, a summary, and a quiz and assignment built for the students out of what was actually said in the lesson. Nobody presses anything — you upload a file and finished material comes back.

The same shape again: a defined chain, with steps inside it that require understanding content. It isn’t an agent, because it decides nothing beyond what it was told to do — and it isn’t a chatbot, because nobody talks to it.

And that is the thing worth taking from this article: most of what is sold today as an “AI agent” is really this. A model sitting as one node inside a well-defined process — not a process the model runs.

Three things an agent must have, and a chatbot doesn’t

1. A trigger — who starts it

This is the first question, and surprisingly it is the one most projects skip. An agent someone has to launch by hand is a chatbot with extra steps. If the process only begins when a person remembers to begin it, it still depends on exactly the human memory we set out to take out of the equation.

2. Permissions — what it may touch

An agent needs permission to act, otherwise it only recommends. And that is precisely the moment the question stops being technological and becomes a business one: what may it do without asking anyone? Read emails — probably yes. Reply to a client on the company’s behalf — it depends. Move money — almost always no, and certainly not at the start.

The answer to that question isn’t technical and isn’t mine. It belongs to the business owner, and it is what determines how the system gets built.

3. What happens when it isn’t sure

This is the part that falls first in projects that fail. An agent with no defined escalation path does one of two things: it stops quietly — and then someone has to notice that it stopped, which is exactly what won’t happen — or it guesses, which is worse.

Our tradition has a precise image for this: the golem. A creature that carries out exactly what it was told, with no judgement whatsoever about when to stop. The problem with the golem was never that it disobeyed — it is that it obeyed too well. A good agent knows how to say “here I am not sure”, and knows who to hand it to.

The common mistake: letting the agent decide everything

I wrote about this in the previous piece, and I’ll repeat it here, because it is exactly the same mistake one floor up. Except that here it needs stating precisely: the boundaries belong to code — not every decision. The hard business rules, what is never permitted, what requires human approval: those are written in advance and are not open to interpretation. What happens inside the boundaries — which tool to reach for, in what order, when there is finally enough information — is where the agent does its work, and what it is for. An agent without boundaries like those isn’t a more advanced agent; it is only a more dangerous one.

In FreightBridge that is precisely the boundary: the model reads the bill of lading and extracts the fields. What happens next — whether the data is valid, whether it reconciles with what is already in the system, what passes through and what goes up for a human eye — is a system that behaves the same way every time.

FreightBridge — automated bill-of-lading intake→

A useful agent is a narrow one: a single process, clear boundaries, and a defined route for the moment it doesn’t know. An agent meant to “run the office” is a slide, not a system.

On that same boundary, one floor down: Three Minutes, Twelve Times a Day→

So what do you actually need

Three quick tests, before deciding the answer is an agent.

If the work begins because a person decided to begin it — a button is probably enough, not an agent. If the input is structured and the rules are fixed — that is workflow automation, and a model there only adds cost and uncertainty. And only if something unstructured has to be read and judged, over and over, without a person sitting over it — that is where an agent earns its place.

Most of the businesses I meet need the second. Some need the third. Almost nobody needs the chat window they asked for at the start.

In closing

The right question isn’t “do I want an AI agent”. It is: which decision in my business am I willing to let something else make — and what happens when it gets that decision wrong.

Anyone who can answer that has an agent worth building. Anyone who can’t gets a very handsome chat window that nobody opens after two weeks.