← All articlesAI and agents

AI agent vs workflow automation: how to choose

The real question is not which tech, but who knows the rule. If you can write it down, you don't need an agent.

Julien Mauclair · ~7 min · intermediate
Stackn8nClaude APILangGraph

If you can write the decision rule in advance ("when stock drops below 200, order 500 units from this supplier"), classic workflow automation is enough: it is cheaper, predictable and easy to debug. An AI agent only makes sense when the path depends on what the model discovers along the way.

That is exactly the line Anthropic draws in Building effective agents: a workflow orchestrates the model and tools through predefined code paths, while an agent directs its own process and tool usage.

There is a middle level that often gets skipped: a fixed workflow with a single model call for the fuzzy part (reading an email, classifying a request, extracting a field). It is frequently the right answer. This article gives you a five-question decision tree, then a cost calculation so you can see the gap in dollars.

01Three levels, not two

The choice is usually framed as binary. In practice there are three levels, and you only move up when the level below fails.

LevelWhat decides the next step
1. Automation without AIYour code or rules, always
2. Workflow with a model callYour code; the model turns fuzzy input into structured data
3. AgentThe model, on every loop, based on tool results

Level 1 is a cron job, a webhook, an n8n or Make scenario, a few conditions. Level 2 keeps a fixed path but hands the model one step rules can't handle: understanding free text. Level 3 lets the model pick which tool to call, when to loop and when to stop.

Anthropic recommends finding the simplest solution possible and only adding complexity when it demonstrably improves outcomes, noting that agentic systems trade latency and cost for better task performance. For many applications, a well-built single model call with retrieval and examples is enough.

To see what the jump from level 2 to level 3 looks like inside a real product, the pillar article From a prompt to agentic AI walks through a graph where only one node is truly agentic.

02The five-question decision tree

Ask these in order. As soon as an answer stops you, you have your level.

decision-tree.txtTEXTCopy
Q1. Can you write the decision rule today, on one page?
yes -> Q2
no -> Q3
Q2. Is the input already structured (fields, numbers, statuses)?
yes -> LEVEL 1: automation without AI
no -> LEVEL 2: workflow + one model call to structure the input
Q3. Does the number of steps change based on what you find along the way?
no -> LEVEL 2: workflow (chaining, routing) with model calls
yes -> Q4
Q4. Can the model check its progress at every step
(tool result, test, API response)?
no -> stay at LEVEL 2 and let a human decide
yes -> Q5
Q5. Is a mistake reversible, or blocked before the action runs?
no -> LEVEL 3 with human approval before any write
yes -> LEVEL 3: agent, with an iteration cap

A few notes on each question.

Q1 matters most. Many agent requests are about decisions that were settled months ago: you always reorder the same quantity from the same supplier, you always follow up after seven days. A known rule has nothing to reason about. A popular thread on r/AI_Agents describes a restocking case where a simple daily rule replaced the planned agent, and contrasts it with messy tenant messages that did need real interpretation (Reddit thread). It is a testimony, not a statistic, but the distinction is the right one.

Q2 separates levels 1 and 2. A supplier email whose format changes every time, a free-text form, a PDF: the model turns that into clean fields, then your code takes over. Several comments in the same thread sum it up as "the model reads, the script acts".

Q3 spots a genuine agent use case: an open-ended task where you can't predict the number of steps. Anthropic's example is a coding agent that edits many files from a plain task description.

Q4 checks that the agent has solid ground. Without verifiable feedback at each step, it moves blind and errors compound. Anthropic stresses that an agent needs ground truth from its environment at every step.

Q5 sets the level of control. Irreversible actions (payments, customer emails, deletions) go behind human approval. Human-in-the-loop, for real shows where to put that checkpoint without stalling the whole flow.

03What it costs: the calculation

Cost is often what settles it, and its nature changes between levels. Automation has a mostly fixed cost; an agent has a variable cost per run that grows with the number of turns.

Take 1,000 runs a month. Prices below were checked in November 2026 on the official pages, and token volumes are assumptions you should replace with your own.

Level 1: on n8n Cloud, the Starter plan costs $20 per month billed annually for 2,500 workflow executions, regardless of the number of steps. Your 1,000 runs fit. Self-hosted, the n8n Community edition is free; you only pay for the server.

Level 2: you add a call to Claude Haiku 5.5 to classify each input, billed at $0.10 per million input tokens and $0.50 per million output tokens for prompts under 100,000 tokens. With 2,000 input tokens and 200 output tokens per call:

cost-level-2.txtTEXTCopy
input: 2,000 x 1,000 = 2,000,000 tokens x $0.10/M = $0.20
output: 200 x 1,000 = 200,000 tokens x $0.50/M = $0.10
model total: $0.30 per month

Level 3: an agent on Claude Sonnet 5.5, billed at $2 per million input tokens and $10 per million output tokens. An agent loop resends the whole context on every turn. Assumption: 6 turns, 6,000 input tokens per turn on average (the context grows with tool results) and 400 output tokens per turn.

cost-level-3.txtTEXTCopy
per run:
input: 6 turns x 6,000 = 36,000 tokens x $2/M = $0.072
output: 6 turns x 400 = 2,400 tokens x $10/M = $0.024
total: $0.096
for 1,000 runs: $96 per month

In short, for 1,000 runs the model costs nothing at level 1, about $0.30 at level 2 and about $96 at level 3, based on Claude API pricing and the assumptions above. The gap between levels 2 and 3 is a factor of several hundred, before counting any tuning time. Prompt caching lowers the agent bill (the docs state a cache read costs a fraction of the normal input price), but it doesn't change the order of magnitude. The hidden cost isn't on the invoice either: an agent needs traces, scores and someone checking what it did. Trace and score an agent with Langfuse covers that part.

Worth noting

Redo the math with your own numbers: run count, real tokens measured over ten typical runs, and average number of turns. The turn count is the variable that decides whether an agent bill stays sane.

04Signs you picked the wrong level

You picked an agent when a workflow would have done if:

·in practice the agent always follows the same path, in the same order;
·you keep adding instructions like "always call tool A, then tool B";
·you spend more time reviewing its output than doing the job by hand.

In that case, freeze the path in code and keep the model for the fuzzy step. A second r/AI_Agents thread points the same way: its author describes production agents that are deliberately simple, one trigger, one solid prompt with examples, and no agent-to-agent orchestration (Reddit thread). Some commenters rightly push back that agentic coding or multi-step research earn their complexity. Both views fit together: complexity should come from the task, not from the appeal of the tech.

The other way round, you picked a workflow when you needed an agent if:

·your condition tree doubles with every new customer case;
·half the runs end up in an "other, handle manually" branch;
·the next step genuinely depends on the content of a result you can't predict.

If you do move to level 3, start with the tools you give it: their descriptions and parameters matter as much as the prompt. Give an agent tools without it hallucinating covers that step.

05FAQ

Is an n8n workflow with an AI node an agent?

Not necessarily. If the path is fixed in the workflow and the model only transforms data, it is a workflow in Anthropic's sense (level 2). It becomes an agent when the model picks which tools to call and decides whether to continue or stop.

Where should I start if I'm not sure?

At level 2: a fixed path and one model call for the fuzzy step. Measure the share of mishandled cases over a hundred real runs. If it stays high because the steps genuinely vary, you have a concrete argument for moving to an agent.

Can one agent replace several automations?

It can, but it is rarely a good deal. Every deterministic automation you swap for an agent becomes slower, more expensive and less predictable. Keep known rules in workflows and save the agent for the part that truly needs interpretation.

In short

Start with the simplest level that holds up, measure it, and only move up when the level below fails in a visible way. An agent has to earn its place.

Talk about your project ↗
Julien MauclairJulien Mauclair is the co-founder and CTO of Klickbee, where he builds the agency’s websites, tracking and AI automations, and develops Klickbee Tracking. He also runs Stralya, which designs and runs AWS infrastructure for scale-ups. Before that, he built the entire AWS infrastructure of an e-commerce business, since sold.

Read next