In 2023 the question was: «what can the model say?». In 2026 it became: «what can the model do — and who carries responsibility for what it did?». That move from answering to acting is what we call an agent, and it changes the shape of the engineering far more than it changes the shape of the interface.
The difference is not intelligence, it is responsibility
A chatbot suggests text and you decide what to do with it. An agent changes state inside your system: it creates an entry, sends an email, edits a record. The difference is not in the model's capability — the same model may run in both cases — but in the fact that the next step became its decision rather than yours.
Which means everything we learned about permissions, logs and rollback in enterprise systems comes suddenly back to the interface: who is allowed to do what, what gets recorded, and how we undo a wrong step.
Three things break once the system is the one deciding
- The permission boundary: the model does not know what it «must not» do unless you write it down. A tool handed to an agent should carry the narrowest permission that completes the task — exactly like a service account in a production system.
- Explainability: when an agent takes a decision with a financial effect, you must be able to know why a month later. A decision log is not an optional feature; it is what makes the system auditable.
- The human in the loop: not every decision deserves a human stop, but every decision with a financial or legal effect does. Designing those stopping points is half the work.
What changes in the team
A team building agents needs a skill that a team building interfaces never required: evaluation. You cannot test an agent with a classic unit test, because its output is not deterministic. You need a set of real cases, a criterion for success, and a measurement before every launch — otherwise you are shipping a guess.
An agent whose accuracy you cannot measure before release is not a product — it is an experiment run on your users.
When you do not need an agent
Most tasks we are asked to build «an agent» for are really conventional automation with clear rules. If the path is fully determined — if this, then that — an agent adds cost and non-determinism for nothing. An agent earns its place when the inputs are unstructured, or when the path requires a judgement about context.
We open every discovery session with that question: is this an agent task at all? And in roughly half the cases the answer is no — and we say so.
In short
The agent revolution is not a revolution in models; it is a revolution in responsibility. Whoever builds an agent is building a system that takes decisions — and must engineer it the way any decision-taking system is engineered: narrow permissions, a full log, measured evaluation, and a human at every effect that cannot be undone.
