I think we need to be a bit more careful with the word agent.

We have already had this problem with AI. AI became the container word for everything: chatbots, image generators, fraud models, legal drafting tools, self-driving cars, coding harnesses, and the little thing that summarises your meeting.

That is too broad to be useful.

Now I think the same thing is starting to happen with agents.

People are using the word agent for anything that runs a sequence of tasks. It takes something in at one end, follows a few steps, calls a model once or twice, maybe checks a condition, maybe sends an email, and then it finishes.

That can be useful.

It can be very useful.

But I am not sure I would call it properly agentic.

I would call it a workflow. Or a smart task list. Or a smart standard operating procedure. If we have to use the word agent, maybe it is a task-list agent.

The distinction matters because the expectations are different.

The smart task list

In the old computer world, a lot of this would have looked like a cron job.

At 7am, run this.

Check the folder.

Pull the file.

Transform it.

Send the report.

If something goes wrong, fail and log an error.

Modern AI workflows can look more impressive because they include model calls. They might summarise the file, classify an email, draft a reply, route a ticket, or decide between two predefined branches.

But the shape is still mostly fixed.

Input. Steps. Branches. Output.

That is not a criticism. A fixed workflow is often exactly what you want. It is predictable. It is easier to test. It can be cheaper. It can be safer. It can be a brilliant way to remove dull work from a team.

But if it gets outside its known path, it usually stops. It does not really understand the wider goal. It does not decide to gather new context, try a different tool, review its own failure, update its working state, and continue.

It says, in effect: I have failed.

That is a workflow with AI inside it.

It is not the same thing as an agentic system.

The agentic loop

For me, the thing that starts to make something agentic is the loop.

Not just a loop in the programming sense. A judgement loop.

The system has a goal. It has context. It can plan. It can act. It can observe what happened. It can compare the result with the goal. It can correct itself. It can update its working state. It can decide what to do next.

That is a different shape.

It is no longer just:

Do step one, then step two, then step three.

It is closer to:

Here is the outcome. Here are the boundaries. Here are the tools. Here is the evidence standard. Work toward the goal, check yourself, ask when you hit a threshold, and keep going until the job is done or you reach a stop-line.

That is why systems such as Codex and Cowork-style coding harnesses feel agentic to me. You can give them a messy goal and, if they are configured properly, they can inspect the repo, decide what context matters, use tools, run tests, adjust the plan, spawn focused work, ask for clarification, and keep moving toward completion.

They are not magic.

They still need boundaries.

They still need review.

They still need a human who knows what good looks like.

But the shape of the work is different from a smart checklist.

Infographic comparing a fixed smart workflow with an agentic loop that plans, acts, observes, evaluates, corrects, and continues toward a goal.

Workflows are not bad

I want to be clear about this because it is easy for this argument to sound like snobbery.

I am not saying workflows are bad.

I am saying they are different.

Anthropic makes a useful distinction in its writing on building effective agents. In their framing, workflows are systems where the path is largely predefined in code. Agents are systems where the model dynamically directs its own process and tool use.

That is a helpful distinction.

If you know exactly what should happen, use a workflow.

If you need reliability, repeatability, auditability, and a narrow path, use a workflow.

If the work is deterministic, use code.

If the work needs judgement, recovery, adaptation, tool choice, state, and goal-directed continuation, then you may be moving into agentic work.

The danger is not that people build workflows.

The danger is that people call a workflow an agent and then expect it to behave like one.

Task-based versus goal-based

A task-based system says:

Follow these steps.

A goal-based agentic system says:

Achieve this outcome within these boundaries.

That difference sounds small, but it changes almost everything.

A task-based system needs you to have already done most of the thinking. You have decomposed the work. You have chosen the route. You have written the steps. You have defined the branches. The system is there to execute the pattern.

A goal-based system asks for a different human contribution. You need to define the goal well. You need to provide the right context. You need to explain what good looks like. You need to name the tools that are allowed. You need to set the evidence standard. You need to create stop-lines.

Then you let the system work the loop.

This is why I keep coming back to the idea that the goal is becoming the interface.

The better the goal contract, the more room the agent has to be useful without becoming unsafe.

The worse the goal contract, the faster the system can drift.

Why the words matter

This is not just naming for the sake of naming.

If we call a cron job an agent, we may overestimate its ability to recover.

If we call a workflow an agent, we may forget that the path is still mostly predetermined.

If we call a tool-using loop a workflow, we may underestimate the need for governance, audit, cost control, escalation and human review.

The words change what we test.

They change what we supervise.

They change what we promise.

They change what we allow the system to touch.

OpenAI's agent materials talk about tools, handoffs, guardrails, state and tracing. LangGraph talks about durable, long-running, stateful workflows with persistence and human-in-the-loop control. IBM describes agentic AI in terms of systems that can pursue goals and act with a degree of autonomy.

Those ideas all point to the same practical question:

Is this thing just following a route, or can it navigate?

A practical test

If someone tells me they have built an agent, I would ask a few questions.

Question Why it matters
Does it have a goal, or only a task list? A goal lets it choose a route. A task list mostly executes a route.
Can it observe what happened and change its next step? That is the beginning of an agentic loop.
Can it choose between tools or routes? Tool choice is different from calling one fixed function.
Can it recover from an unexpected state? A brittle workflow usually stops; an agentic system should reason about recovery.
Does it preserve state, evidence, or a receipt? Longer-running work needs memory, audit, and review.
Does it know when to ask, escalate, or stop? Autonomy without stop-lines is not maturity.

If the answer to most of those questions is no, that does not mean the system is useless.

It may be a perfectly good workflow.

It may be exactly what you need.

But calling it an agent may create the wrong expectations.

The language I would use

I think I would split the language like this.

A fixed automation is a script, cron job, scheduled task, or deterministic workflow.

A smart workflow is a fixed process with AI calls inside it.

A task-list agent is a system that follows a bounded checklist, maybe with branches and model calls, but with limited self-direction.

An agentic system is something with a goal-directed loop: context, plan, action, observation, evaluation, correction, state, escalation and continuation.

A full agentic worker is a governed agentic system with a role, tools, memory, permissions, receipts, stop-lines, human review, and a clear definition of done.

That is not the final taxonomy. It is a working language.

But I think we need working language now.

Otherwise the word agent will become another container word. It will mean everything and therefore almost nothing.

And that will make it harder to build good systems, harder to govern them, and harder to explain what we actually need.

Sources and notes