When teams say they want an AI agent, they usually mean one of two things: they want the system to use tools, or they want it to handle a task that spans multiple steps. Neither of those requirements implies an agent.
In production, the safest default is a workflow: explicit steps, explicit branching, bounded cost, and failure modes you can explain.
Why "Agent" Is So Appealing
Agent is a compelling word. It promises a system that can figure things out on its own, handle edge cases gracefully, and improve over time.
It also hides design decisions you have not made yet. When you say "the agent will handle it," you are deferring the question of what exactly the system should do in each situation. That deferred complexity shows up later, in production, in ways that are harder to debug.
What a Workflow Actually Gives You
A workflow is a directed graph. You define the steps, the order, and the branching conditions. The language model executes within each step, but the overall flow is deterministic.
Consider a typical support automation: classify the incoming message, extract the relevant details, look up the customer record, generate a response, apply safety checks, and send. Each step can involve an LLM call, but the sequence is fixed. You know exactly what the system will do, in what order, with what cost.
This gives you several things that agents cannot:
- Predictable cost. Fixed LLM calls per request.
- Debuggable failures. You can point to exactly which step failed and why.
- Testable components. Each step can be tested independently with known inputs and outputs.
- Explainable behavior. You can tell a stakeholder or a customer exactly what happened.
- Maintainable code. A new engineer can understand the system in an afternoon.
What Autonomy Actually Costs
An agent operates as an autonomous loop. It observes the current state, decides what to do next, takes an action, and repeats until it thinks it is done. The model is making routing decisions at every step.
This is powerful when you need it. It is expensive when you do not.
More LLM calls mean higher cost and higher latency, with both being variable and hard to predict. Strange failure modes emerge when the model takes unexpected paths. Debugging becomes archaeology: you need to reconstruct the chain of decisions the model made.
Of the production AI systems I have reviewed, roughly 80% of those built as agents would have been better as workflows.
When an Agent Is Justified
Agents earn their complexity in a narrow set of situations:
- The number of steps cannot be known in advance.
- The task requires genuine exploration, like research across multiple sources.
- Tool selection cannot be enumerated ahead of time.
- Recovery from errors requires on-the-fly adaptation.
Good examples include deep research tasks where the model needs to search, evaluate, and search again. Complex code generation where the model writes, tests, and iterates. Open-ended data analysis where the question itself might change as the model learns more about the data.
If you can draw the flowchart before you start building, you do not need an agent.
The Hybrid Pattern
The best production systems I have seen use a hybrid approach: a workflow as the outer structure with agent-like reasoning inside specific nodes.
For example, a document processing pipeline where most steps are deterministic, but one step involves an agent that researches context from multiple databases before making a classification decision. The workflow provides the guardrails. The agent provides the flexibility where the problem demands it.
This pattern gives you bounded cost, predictable structure, and explainable behavior at the system level, while still allowing the model to reason freely where it matters.
Three Questions Before Building an Agent
Before you reach for an agent architecture, ask yourself:
- Can we enumerate the steps? If you can list what the system should do in order, that is a workflow.
- Can we bound the cost and failure modes? If you need guaranteed latency and spend, that is a workflow.
- Does the system truly need to decide what to do next in an open environment? If yes, and only then, consider an agent.
Start with a workflow. Add agentic reasoning at specific nodes only when you have evidence that the problem requires it. You can always add complexity later; removing it is much harder.