Workflow automation runs a fixed sequence of steps that you designed in advance; an AI agent is given a goal and a set of tools and decides its own steps while it runs. Most business processes are better served by a workflow with a language model inside one or two steps, and you only need an agent when the path cannot be written down ahead of time. That is not a contrarian position: it is what both Anthropic and OpenAI tell their own customers in their published guides.
What is the difference between an AI agent and a workflow?
Anthropic's engineering guide draws the line precisely. Workflows are "systems where LLMs and tools are orchestrated through predefined code paths", and agents are "systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks". The difference is who owns the control flow: your code or the model.
OpenAI's guide for product teams says the same thing from the product side. It defines agents as "systems that independently accomplish tasks on your behalf" and rules out the rest: applications that integrate LLMs but do not use them to control workflow execution, such as "simple chatbots, single-turn LLMs, or sentiment classifiers, are not agents". An agent in that guide has three parts: a model for reasoning, tools it can call, and instructions that define how it behaves.
So a flow that receives an email, asks a model to classify it, and routes it to a mailbox is workflow automation with an LLM step. The model makes one decision inside a path you drew. An agent would be handed the inbox and the goal "resolve what you can" and would decide for itself what to open, look up and send.
When is workflow automation the right answer?
Whenever you can enumerate the steps. Anthropic's advice for teams building with models is to find "the simplest solution possible, and only increasing complexity when needed", which can mean not building an agentic system at all. OpenAI closes its own checklist the same way: "Before committing to building an agent, validate that your use case can meet these criteria clearly. Otherwise, a deterministic solution may suffice."
Workflows with model steps cover far more ground than people expect. Anthropic names five patterns, and each maps onto an everyday business process:
| Pattern | What it does | Business example |
|---|---|---|
| Prompt chaining | Runs steps in sequence with programmatic checks between them | Draft a quote, validate the numbers, format the PDF |
| Routing | Classifies input and sends it to a specialized handler | Sort inbound leads by size, region and intent |
| Parallelization | Splits a task into independent subtasks run at once | Score 200 CVs against the same rubric |
| Orchestrator-workers | A central model breaks a task up and delegates to workers | Research a company across ten sources and merge the notes |
| Evaluator-optimizer | One model generates, another critiques, in a loop | Rewrite a landing page until it passes a checklist |
Notice that even the two loop-shaped patterns keep the loop in your code. You decide the maximum iterations, the exit condition and what gets logged. That is why workflows are auditable: every run follows the same shape, and a failure points at a step.
When do you actually need an agent?
When the number and order of steps depend on what the model finds along the way. Anthropic reserves agents for "open-ended problems where it's difficult or impossible to predict the required number of steps" and where you cannot hardcode a fixed path. Its two reference examples are customer support that combines conversation with tool access, and coding agents that solve a task by iterative testing and verification.
OpenAI gives three concrete signals. Build an agent for complex, context-sensitive decisions, with refund approval in customer service as the example; for rulesets that have become so extensive that updates are costly or error-prone, with vendor security reviews as the example; and for work that leans heavily on unstructured data, with processing a home insurance claim as the example. Each of those shares a property: a human doing the job would open files, ask follow-up questions and change course, and no flowchart survives contact with the real cases.
If your process has none of those three properties, an agent is an expensive way to do what a workflow already does deterministically.
What does each one cost to run?
Agents cost more, and the reason is structural. Every iteration of the loop resends the whole context so far: Anthropic's documentation notes that each turn's input contains all previous conversation history plus the current message, so an agent that takes fifteen tool calls to finish pays for its own transcript fifteen times over. Anthropic says outright that "agentic systems often trade latency and cost for better task performance".
The pricing pages show the scale. Anthropic's worked example for a one hour agent session on Claude Opus 5 using 50,000 input and 15,000 output tokens comes to $0.705 including an $0.08 session runtime charge, falling to $0.525 when 40,000 of the input tokens are cache reads. Its estimate for a plain support workflow on Claude Haiku 4.5 is about $37 per 10,000 tickets at roughly 3,700 tokens each. Both are cheap compared with a person, but one is a thousand times the other per task, and only one of them has a predictable ceiling.
A workflow's cost is bounded by design: a fixed number of calls with a known prompt size. An agent's cost is bounded only by whatever limits you impose, which is why prompt caching, iteration caps and token budgets are not optimizations for agents but requirements.
How do you keep an agent from doing damage?
By deciding in advance where a human steps in. OpenAI's guide names two triggers: exceeding failure thresholds, such as retry limits, and high-risk actions that are sensitive, irreversible or high stakes, with canceling orders, authorizing large refunds and making payments as the examples. The guide adds that human intervention is especially important early in deployment, when you are still learning where the agent fails.
In practice this means the agent proposes and a checkpoint disposes: it can draft the refund, but a rule or a person approves it. That hybrid, an agent inside a workflow, is what most production systems look like. At Qubba the majority of systems we ship are workflows with two or three model steps, and the agentic parts sit behind approval gates where the loop earns its cost.
How do you decide, in one table?
| Signal in your process | Build |
|---|---|
| The same steps happen in the same order every time | Workflow |
| One step needs judgment on messy input (classify, extract, summarize) | Workflow with an LLM step |
| The next step depends on what was found in the last one | Agent |
| The rulebook changes monthly and nobody can maintain it | Agent, per OpenAI's second criterion |
| Every run must be auditable step by step | Workflow, or an agent with full tool logging |
| An action is irreversible (payment, deletion, sending) | Either, but always behind an approval gate |
Run the table honestly. If most rows point at workflow, you will ship faster, spend less and sleep better, and you can promote a single step to an agent later without rebuilding the rest.
Frequently asked questions
Is a chatbot an AI agent?
Usually not.
OpenAI's guide explicitly classes "simple chatbots, single-turn LLMs, or sentiment classifiers" as not agents, because the model answers but does not control a workflow.
A chatbot becomes an agent when it can call tools, decide the order of its own actions and finish a task without a human scripting each step.
Can I turn an existing automation into an agent later?
Yes, and that is the recommended direction.
Keep the workflow as the skeleton, then replace the one step that keeps breaking on edge cases with an agent that has a bounded set of tools and an iteration cap.
Anthropic's guidance to increase complexity only when needed applies step by step, not all at once.
Do agents replace workflow automation tools?
No.
Agents need something to call, and workflow tools and internal APIs are what they call.
OpenAI describes agents as composed of a model, tools and instructions; the tools are your existing automations.
The two layers stack rather than compete.
How do I know whether an agent is actually working?
Measure it the way you would measure a new hire: task completion rate, cost per completed task, and how often it escalated.
Because agents trade cost and latency for performance, compare those numbers against the workflow version on the same cases before you commit, and keep the escalation path open.