Over the past two years, most companies have experienced AI as a text box: you type something in, get something out, copy it into another program. That was useful. It was also the least interesting part of the story. What's happening now doesn't change the quality of the answers – it changes who actually does the work.
The difference in one sentence
A chatbot answers. An agent acts. A chatbot receives a question and returns text. An agent receives a goal, breaks it into steps, calls tools, checks intermediate results, and only reports back once the task is done or stuck.
That sounds like a gradual improvement, but it's actually a break in kind. A chatbot is a tool inside one person's workflow. An agent is a participant in the process itself. The moment something executes steps on its own, you need things nobody cared about when it was just a text box: permissions, logs, stopping criteria, ownership.
| Dimension | Chatbot | Agent |
|---|---|---|
| Input | A question | A goal plus context |
| Duration | Seconds | Minutes to hours |
| Tools | None | CRM, calendar, files, APIs |
| Failure mode | Wrong text | Wrong action inside a system |
| Control needed | Proofreading | Approvals, limits, audit log |
| Value delivered | Time saved per task | Whole steps removed entirely |
Why most agent pilots fail
In the projects we see, it's almost never the model's fault. It's that companies point an agent at a process nobody had ever cleanly described. Automation is merciless: it exposes the fact that the "standard process" is actually fourteen exceptions held together by three experienced colleagues' tribal knowledge.
An agent can't fix a process nobody understands. It can only execute it wrong, faster.
The second pattern: teams build the agent for the rarest, most exciting case instead of the most common, most boring one. The exciting case is the one you show on stage. The boring one is the one that saves money.
A maturity model that actually helps
Instead of "let's do agents now," a staged approach helps. Each stage delivers its own value and carries its own risk – and you shouldn't skip any of them.
- 01Assisted: the human does the work, the model suggests. Value immediately, risk minimal.
- 02Drafting: the model produces the first result, the human edits and approves.
- 03Executing with approval: the agent carries out steps but pauses before every write action.
- 04Executing within bounds: the agent acts independently inside defined limits – amount, recipient set, system access.
- 05Supervised autonomy: the agent runs in the background, a human spot-checks samples and outliers.
What this means for your organization
The interesting effect isn't the headcount debate everyone's having – it's the shift in what people actually do. Whoever processes tasks today will define tasks tomorrow, review outputs, and decide edge cases. That's more demanding, not easier – and it's exactly the kind of competence you can't hand out in a slide-deck workshop.
- Every automated chain needs a named owner, not a department.
- Write access gets limits before it goes live – not afterward.
- Logging belongs in the operating model: who triggered what, and why?
- The manual fallback path must work at all times.
Where you should start
Pick a process that runs frequently, is clearly bounded, and won't ruin anyone if it goes wrong: proposal drafts, ticket triage, research briefings, report commentary. Build it at stage two or three, measure for four weeks, and only then discuss autonomy.
The fastest way there isn't a strategy deck – it's a day where the team actually builds the process. After that, the conversation about agents suddenly becomes very concrete – and much shorter.