.svg)
If you can draw the flowchart first, build the flowchart.
If you can draw the whole flowchart before the work starts, you want a workflow, not an agent. Chaining model decisions multiplies their error rate: six steps at 95% each land at 73.5% end to end, while the same job as a workflow with one model step stays at 95%. You pay more per run for the worse number. Most of what gets scoped as agent work is a workflow with a language model doing one classification.
Every company selling AI agents concludes that you need an AI agent. We sell them too, so read this with that in mind.
Here's the version we give on scoping calls anyway. A large share of the work that arrives described as "we need an agent" is a process nobody has ever written down, and once you write it down the branches are obvious. At that point an agent is a more expensive, less reliable way to do something a workflow does properly.
This guide gives you the test we use, the arithmetic behind it, and five job shapes that look like agent work and aren't. It also covers the cases where an agent genuinely is the right call, because those exist and we build them.
Three Ways to Build the Same Automation
Almost everything written about this treats it as a binary: agent, or not an agent. That framing hides the option most teams should take.
Tier two is the answer far more often than the market suggests, and it barely gets written about because it isn't exciting. It's a normal automation with one smart step in it.
The One Question That Settles It
There's a good rule circulating among practitioners and it does most of the work: can you draw the full graph before execution starts? If yes, build the graph. If the path genuinely depends on what the model discovers while running, you need an agent.
That line maps almost exactly onto how Anthropic draws it in their own guidance on building effective agents: a workflow orchestrates models and tools through predefined code paths, while an agent lets the model direct its own process. Their advice is to find the simplest thing that works and only add complexity when it earns its place, which they note may mean not building an agentic system at all.
It's worth pausing on who's saying that. The company selling you the model has every commercial reason to encourage you to make more calls to it, and their engineering guidance still opens by telling you to try one call first. Take that more seriously than anything an agency tells you, including us.
We use four questions underneath the rule, because "can you draw it" is easy to answer wrongly when you haven't tried.
- Draw it for the last twenty real casesNot the imagined onesTake twenty actual inputs from the past month and sketch the path each one took. If they collapse into a handful of branches, you have a workflow. If every one is genuinely different, keep going.
- Count the decisions that need judgementNot the steps, the judgementsReading an email and deciding what it's about is one judgement. Looking up the order, checking the policy, and formatting the reply are not judgements, they're lookups. Most processes have one judgement and ten lookups.
- Ask what happens on the wrong pathBlast radius, not embarrassmentIf a wrong turn sends an email, moves money, or updates a customer record, the non-determinism you're buying has a price attached. Deterministic execution belongs anywhere correctness is binary.
- Try to write the testThe one people skipWrite down what a correct outcome looks like for those twenty cases. If you can enumerate expected outputs, you can build and test a workflow. If you can't, you also can't tell whether your agent is working, which is a separate problem you now own.
If the first two questions point at a workflow and you still want an agent, the reason is usually that an agent sounds better in a board update. That's a real reason. It isn't an engineering one.
Why Agents Multiply Their Mistakes
This is the part that isn't obvious, and it's arithmetic rather than opinion.
A model step is probabilistic. Chain several of them and the success rates multiply, because the task only works if every step works. Code steps don't multiply anything, because code does the same thing every time.
| Per-step accuracy | 2 steps | 4 steps | 6 steps | 8 steps | 10 steps |
|---|---|---|---|---|---|
| 90% | 81.0% | 65.6% | 53.1% | 43.0% | 34.9% |
| 95% | 90.3% | 81.5% | 73.5% | 66.3% | 59.9% |
| 98% | 96.0% | 92.2% | 88.6% | 85.1% | 81.7% |
| 99% | 98.0% | 96.1% | 94.1% | 92.3% | 90.4% |
Now the comparison that matters. Take a task where each model decision is right 95% of the time, which is a respectable number.
As a six-step agent, it completes correctly 73.5% of the time. As a workflow with one model step and five coded steps, it completes correctly 95% of the time. Same model, same task, 21.5 points of extra failure bought with the architecture.
Turn it around and it gets starker. For a six-step agent to match that workflow, every individual step has to hit 99.1%. Nothing in your stack hits 99.1% on messy real input.
What It Costs to Choose Wrong
The reliability gap wouldn't matter much if agents were cheap. They aren't, and the two problems compound.
An agent re-sends its whole conversation on every turn, so a six-turn loop costs roughly seven times what a single call costs. We work through that arithmetic in what an AI agent actually costs to run. Then the lower resolution rate sends more work to a person, and human time is the expensive ledger.
Put both together across the same 100 tasks.
| Agent, 6 chained model steps | Workflow, 1 model step | |
|---|---|---|
| Resolves without help | 73.5% | 95.0% |
| Model cost, 100 runs | $1.70 | $0.44 |
| Escalations to a person | 26.5 | 5.0 |
| Human handling | $58.28 | $11.00 |
| Total per 100 tasks | $59.98 | $11.44 |
The workflow is 5.2 times cheaper end to end, and it gets there mostly by escalating a fifth as often. You aren't choosing between a clever solution and a boring one. You're choosing between two costs, and the boring one is smaller in both ledgers.
There's a second-order effect that shows up a few months in. The agent version doesn't just cost more, it costs more unpredictably, because the turn count varies with how confused the model gets on a given input. A workflow's bill is close to a straight line through your volume. An agent's bill has a tail, and the tail is fattest in exactly the weeks when your volume spikes and the inputs get strange. Finance teams notice that before engineering does.
Agent Washing: Most of What You Are Sold Is Not an Agent
Worth knowing before you evaluate a vendor.
Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. In the same analysis they estimate that only around 130 of the thousands of vendors claiming agentic AI actually offer it, and they name the practice: agent washing, the rebranding of assistants, RPA, and chatbots without substantive agentic capability.
There's an irony in that worth sitting with. A large share of the "agents" on the market are tier-two workflows with good marketing. They often work well, because tier two is the right answer for most of what they do. The problem isn't the product. It's paying agent prices and carrying agent risk to get it.
Not sure which tier your process needs?
Send us the process and twenty real examples of it running. We'll draw the graph, tell you which tier it belongs in, and say so plainly when the answer is a workflow you don't need us to build.
Book a free process review ↗Five Jobs That Look Like Agent Work and Aren't
Patterns we see over and over on scoping calls.
- 1. Inbox triage and routing. "Read every incoming email, work out what it is, send it to the right place." One judgement, then rules. The model classifies, a workflow routes. Adding autonomy here buys you a system that occasionally invents a new department.
- 2. Document data extraction. Invoices, purchase orders, forms, CVs. One model call returning structured fields, then validation code. It feels agentic because the documents vary, but the process never varies: extract, validate, write.
- 3. Report assembly. Pulling numbers from five systems every Monday and producing a summary. The pulls are API calls with no judgement in them. Only the narrative paragraph needs a model, and only at the end.
- 4. Lead qualification and enrichment. Score the lead, look up the company, update the CRM, notify someone. Fixed sequence, one scoring judgement. Teams reach for an agent because the inputs are messy, but messy input is a tier-two problem.
- 5. Scheduled monitoring and alerting. "Watch this and tell me when something's wrong." A schedule, a threshold, and a message. If you want a model to write the alert text, that's one node, not an autonomous system with access to your infrastructure.
Every one of these is a real and valuable automation. Our walkthrough of business processes you can automate with n8n builds several of them as tier-two workflows, and they run without anyone watching.
They share a shape, and it's worth naming so you can spot it yourself. In every case the input is unpredictable and the process isn't. Emails arrive in any format, invoices come from a hundred suppliers, leads describe themselves however they like. That variety is what makes people reach for autonomy. But once the model has turned the messy input into structured data, what happens next is the same every time, and "the same every time" is the definition of a workflow.
Confusing messy input with an undrawable process is the single most common scoping mistake we see. If you catch yourself saying "but every case is different", check whether every case is different or just every email.
When an Agent Genuinely Is the Right Call
There's a real case. It's narrower than the marketing and wider than the sceptics allow.
- The path genuinely depends on what it finds. Research, investigation, and diagnosis, where step three is unknowable until step two returns. This is the honest core of agentic work.
- The tool set is large and the right subset varies per task. If you'd need forty branches to cover the combinations, the branches stop being maintainable and letting the model choose is genuinely simpler.
- The work is open-ended and a human reviews the output anyway. Drafting, synthesis, first-pass analysis. Non-determinism costs little when a person checks before anything happens.
- Retries are cheap and failure is visible. If a wrong path costs a few cents and gets caught immediately, you can afford the variance. That's the opposite of moving money or emailing a customer.
Notice the pattern. Agents earn their price where the shape of the work is unknown in advance and being wrong is cheap. If your process is known and being wrong is expensive, you've inverted both conditions.
The Hybrid Most Teams Actually Need
The end state for most businesses isn't tier two or tier three. It's tier two with one tier-three component, bounded tightly.
Keep the spine deterministic. Trigger, fetch, validate, route, write, notify, all in code you can read and test. Then put the model exactly where judgement is required, make it return structured output, and validate what comes back before anything downstream trusts it.
CollageDepot's support pipeline is built this way. The model classifies the incoming email, scores sentiment and urgency, and drafts a reply in the customer's language. Everything else, the Shopify lookup, the escalation thresholds, the routing to a person, is deterministic. It resolves 65% of tickets in under 60 seconds without anyone touching it, and the parts that could go badly wrong are the parts that can't improvise.
That architecture is also far easier to debug at 2am, because when it breaks you can tell which node broke. Our guide to building production-ready AI agents covers the guardrails for the component that does need runtime judgement.
What to Ask Before You Commission One
If you're briefing an agency or an internal team, these five questions separate a considered recommendation from a default one.
- "Show me the graph you can't draw." Ask them to point at the specific decision whose path is unknowable in advance. If they can't name one, you're being sold tier three for a tier-two job.
- "How many model decisions are chained?" Then multiply. If they say six steps at 95%, ask them to say the end-to-end number out loud.
- "Which steps are code and which are the model?" A good answer is specific and code-heavy. A vague answer means nobody has designed it yet.
- "What does one task cost, and what does one resolved outcome cost?" Different numbers. The second one is the real one.
- "What happens when it takes a wrong path?" You want to hear about validation, limits, and an escalation route, not about how good the model is.
Anyone building custom AI agents properly will welcome all five, because they're the questions that make the resulting system work.
Which Should You Build?
An operations process you already run manually
Almost certainly tier two. You have twenty real examples sitting in your inbox, which means you can draw the graph today. Write it down first. A surprising number of processes get fixed by documentation before any software gets built.
A support or intake workflow
Tier two with one classification step, and design the escalation path before the happy path. The failure that hurts isn't a wrong answer, it's a wrong answer nobody caught.
Research, investigation, or diagnosis
Genuine tier three. The path depends on findings, the tool set is broad, and a human reads the output. Build it as an agent, keep the loop bounded, and log every step.
Anything that moves money or touches a record of account
Deterministic execution for the transaction itself, whatever else you do. The model can decide that a payment should be issued. It shouldn't be the thing that calculates the amount.
Frequently Asked Questions
What is the difference between an AI agent and a workflow?
A workflow follows a path you defined. An agent decides the path while it runs, choosing which tools to call and when to stop. The practical test is whether you can draw the full graph before execution begins. If you can, it's a workflow, and building it as an agent adds cost and variance for nothing.
Are AI agents less reliable than workflows?
For the same task, generally yes, because chained model decisions multiply their error rates. Six steps at 95% each end up at 73.5%. A workflow with one model step and coded steps around it stays at 95%. That gap is structural, not a quality problem with any particular model.
Is an agent ever cheaper than a workflow?
Rarely on the same task. On the worked comparison above the workflow came out 5.2 times cheaper end to end, mostly because it escalated to a person a fifth as often. An agent wins on cost only where the alternative is forty hand-written branches nobody will maintain.
How do I know if a vendor is selling me a real agent?
Ask which decision has an undrawable path. Gartner estimates only around 130 vendors genuinely offer agentic AI and calls the rest agent washing. A vendor selling a tier-two workflow honestly is fine, and often the right choice. One selling it as an agent is telling you something about how they'll handle the rest of the project.
Can I start with a workflow and move to an agent later?
Yes, and it's the order we recommend. Build the deterministic spine, put the model in the node that needs judgement, and run it. If you hit a genuine ceiling where the branches multiply beyond maintenance, you'll have real data and a working system to extend rather than a rewrite.
Does this mean agentic AI is overhyped?
The technique isn't. The default application of it is. Agents solve a specific problem, which is work whose shape is unknown until it runs, and they solve it well. The overhype is in applying that expensive, variable solution to processes that were always going to be a flowchart.
