The reason this matters: teams often treat agents as the "advanced version" of automation and reach for them first. They are a different tool, with a different cost and risk profile.
The core difference: who decides the next step
Anthropic's guide Building effective agents makes the distinction architecturally. Workflows are systems where models and tools are orchestrated through predefined code paths. Agents are systems where the model dynamically directs its own process and tool use.
n8n's documentation frames it similarly from a builder's perspective: an agent is a chain that can make decisions. A chain runs a set sequence. An agent uses the model to decide which actions to take for a given query.
So the question isn't "does it use AI?" A workflow can use AI heavily and still not be an agent. The question is who picks the next step: your design, or the model?
Three options, not two
In practice you are choosing between three designs.
1. Rules-based automation
Every step and condition is written out. No model involved.
For example: a form submission creates a CRM lead, checks for duplicates, assigns it by territory and notifies the rep.
2. Automation with AI steps
The path is fixed, but one or more steps call a model to handle language or ambiguity. The model's output is structured (a label, a score, extracted fields) and the workflow continues with rules.
For example: the same lead flow, plus a model that reads the free-text message and labels it sales, support or spam before routing.
3. AI agent
The model receives a goal and tools and decides the sequence itself, looping until it's done.
For example: "Research this account and prepare a brief for tomorrow's meeting," with access to CRM search, the company website and internal notes. The agent decides what to look up and in what order.
Side by side
| Rules-based automation | Automation with AI steps | AI agent | |
|---|---|---|---|
| Path | Fixed | Fixed | Chosen by the model |
| Handles messy input | No | Yes, at specific steps | Yes |
| Handles unpredictable tasks | No | Partly | Yes |
| Predictability | High | Medium-high | Lower |
| How you test it | Check the logic | Test the AI steps on real examples | Test many full runs and measure outcomes |
| Cost per run | Lowest | Low to medium | Highest (many model calls) |
| Debugging | Easy: see which condition failed | Moderate | Harder: the path differs per run |
| Main risk | Breaks on unexpected data | A wrong label sent down the right path | Compounding errors across steps |
Anthropic's guide notes that agents trade higher cost and the potential for compounding errors for their flexibility, and that they fit open-ended problems where the number of steps is hard to predict. It also points out that many applications do well with a single, well-prepared model call.
Why agents are harder to trust
Rules are deterministic: same input, same result. Models are not. n8n's documentation on testing AI workflows explains that because models behave like black boxes, you can't reason your way to confidence. You build it by running a dataset of test cases through the workflow and measuring the results.
With an AI step inside a workflow, you test one decision. With an agent, you test a whole sequence of decisions that can take a different shape every run. That's a lot more to validate before you let it touch a customer.
Why agents are still worth it
Agents aren't hype when used for the right job. Some tasks can't be flattened into a flowchart: researching an unfamiliar company, answering an open question across many documents, investigating why a number changed.
Andrew Ng's letter on agentic workflows argues that letting a model iterate (plan, use tools, reflect on its own output) can produce much better results than a single pass. That's the real upside: quality on hard, open-ended work.
The MitHub decision grid
Ask three questions about the task.
Q1. Can you write down the steps in advance?
- Yes, always → lean automation.
- Mostly, with a few variations → automation with branches or AI steps.
- No, it depends on what's discovered along the way → candidate for an agent.
Q2. Is the input structured?
- Fields, numbers, statuses → rules.
- Free text, transcripts, documents → AI step.
Q3. What does a mistake cost?
- Cheap and reversible (an internal note, a draft) → more autonomy is acceptable.
- Expensive or irreversible (a customer message, a deleted record, a payment) → fixed path plus human approval, whatever the design.
Put together:
| Steps predictable? | Input structured? | Cost of mistake | Build |
|---|---|---|---|
| Yes | Yes | Any | Rules-based automation |
| Yes | No | Low | Automation with an AI step |
| Yes | No | High | Automation with an AI step + human approval |
| No | Any | Low | Bounded agent (few tools, read-only where possible, step limit) |
| No | Any | High | Agent that prepares, human who acts |
Default rule: start at the simplest row that solves the problem. Move up only when you have evidence the simpler design can't do the job.
The hybrid most teams end up with
In real systems the answer is rarely pure. A robust pattern looks like this:
- Workflow handles the trigger (a webhook or a schedule), fetches data and cleans it.
- Rules handle everything predictable: deduplication, routing, stage changes.
- An AI step or bounded agent handles the one part that needs judgment or research.
- A human approval gates any risky action.
- Workflow records the result and alerts someone if anything fails.
The agent becomes one well-contained component inside a system you can see and test, not the system itself. This is the core of systems thinking for AI automation: design the whole chain, not just the clever part.
A worked example (hypothetical)
Imagine a team handling replies to an outbound email campaign.
- Pure automation can't read the replies, so everything gets dumped on a person.
- An agent that reads each reply, decides what to do and responds on its own is fast to demo and risky in production: one misread and a prospect gets the wrong message.
- The hybrid: a webhook receives the reply; an AI step labels it (
interested,not now,wrong person,unsubscribe) with structured output; rules pause the sequence and update the CRM;unsubscribeis handled immediately by rules;interestedgoes to a rep with a drafted response the rep approves; every label is logged, and someone reviews a weekly sample for accuracy.
The hybrid uses AI exactly where language needs interpreting, and nowhere else.
Common mistakes
- Building an agent for a flowchart problem. If you can draw the steps, the agent is paying model costs to rediscover them every run.
- Letting an AI step return free text. Force a fixed set of labels or fields so the workflow can validate them.
- Skipping the test set. Collect real examples before building, and measure after.
- Giving write access on day one. Start read-only, add actions as evidence builds.
- Confusing a successful run with a correct result. Check the destination record, not just the green checkmark.
Where to go next
If you're new to the concepts, start with What is AI automation? and What is an AI agent?. To see the hybrid pattern built step by step, read n8n for AI automation. And to choose which process to automate first, MitHub's chapter Prove value fast walks through picking a quick win you can measure.