n8n AI Agent vs Chain: Which Should You Use? (2026)

You built one AI Agent in n8n, it worked beautifully, and now every new workflow you sketch starts with an AI Agent node. The n8n AI Agent vs Chain decision comes down to one mechanical fact: a Basic LLM Chain makes a single model call and returns, while an AI Agent runs a reasoning loop that calls the model several times per run.

That distinction sounds minor until you see the token bill at scale. A Chain costs about $1.75 per 1,000 runs on Claude Haiku 4.5. An Agent on the same model costs about $8.80 per 1,000 runs. Multiply that across a workflow firing hundreds of times a day and you are paying for reasoning cycles your task never needed.

What Is the Difference Between an n8n AI Agent and a Chain?#

The whole difference comes down to call count. A Chain calls the model once and stops. An Agent calls the model, reads the result, decides whether to invoke a connected tool, calls that tool, feeds the output back, and calls the model again, looping until it reaches a final answer. Same model, several calls instead of one.

That loop is the feature. It is also the cost. Every pass through the reasoning cycle is a billable model call, and later passes re-send the growing transcript plus tool output, so input tokens compound. You only want that loop when the task genuinely requires it.

I default to a Chain for routing, classification, and rewriting tasks and only promote to an Agent when the workflow genuinely needs to decide which tool to call at runtime. Most tasks never reach that bar.

One mechanical fact drives every row: call count.

How Does a Chain Work in n8n? (One Model Call)#

The Basic LLM Chain node makes a single call to a language model with a prompt, no tools, no loop (n8n docs). You attach a Chat Model sub-node (Claude Haiku 4.5 works well here), write your Prompt, and optionally configure the Chat Messages section with a System and User message. One prompt in, one structured response out.

Because the node runs once and returns, its output is deterministic in structure. Give it the same input twice and the response shape will match both times. That predictability is a feature for field extraction, sentiment classification, or copy rewrites.

Key parameters worth knowing:

• Prompt: the main instruction sent to the model.
• Chat Messages (System / User / AI): adds a persona or prior context.
• Require Specific Output Format: forces the model to return structured JSON.

No Tool sub-nodes. No memory. No loop. For a large slice of automation tasks, that simplicity is exactly right.

How Does an AI Agent Work in n8n? (A Reasoning Loop)#

The AI Agent node (Tools Agent) uses a language model to reason and determine which connected tools to invoke based on the given prompt (n8n docs). It requires the same Chat Model sub-node as a Chain, but also accepts Tool sub-nodes (HTTP Request, Code, custom actions) and an optional Memory sub-node to retain context across runs.

The loop works like this: the model reasons about the task, calls a connected tool, receives the result, reasons again with the new information, and repeats. Each pass is a separate model call. The agent stops when the model decides the task is complete or the Max Iterations cap is reached.

Key parameters:

• System Message: standing instructions for the model (persona, constraints, output rules).
• Max Iterations: caps the number of reasoning and tool-calling cycles. Always set this.
• Require Specific Output Format: same as on the Chain node.
• Return Intermediate Steps: exposes each reasoning and tool call in the output for debugging.

The non-determinism here is by design. Two runs on the same input can follow different tool-calling paths. For tasks where you need an identical result every time, that variability is a liability.

How Much More Does an Agent Cost Than a Chain?#

On Claude Haiku 4.5 (as of mid-2026), a Chain costs about $1.75 per 1,000 runs and an Agent costs about $8.80 per 1,000 runs, roughly 5x more. The difference is call count, not model quality. Both nodes use the same model; the Agent just calls it several times per run.

The token math is transparent. A Chain assumes roughly 500 input tokens and 250 output tokens per run. An Agent running 4 model passes assumes roughly 4,800 input tokens and 800 output tokens per run (later passes re-send the growing transcript, so input compounds). Here is what that looks like across models, using Claude's published pricing (prices in USD per 1M tokens, as of mid-2026):

Arithmetic check: Chain on Haiku = (0.5 x $1) + (0.25 x $5) = $1.75. Agent on Haiku = (4.8 x $1) + (0.8 x $5) = $8.80. Agent / Chain = 8.80 / 1.75 = roughly 5x.

The n8n platform itself adds nothing to this bill. Self-hosted n8n runs under the fair-code license at $0. n8n Cloud Starter is €20 per month. The Agent-vs-Chain choice changes your model spend, not your n8n spend.

All figures based on Claude Haiku 4.5 at mid-2026 list prices.

Use a Chain unless the task needs tools, memory, or runtime decisions.

When Should You Use an Agent Instead of a Chain?#

Use an Agent when the task cannot complete without calling an external tool, querying a database, or deciding between actions at runtime. Use a Chain for everything else: field extraction, text classification, rewrites, translations, and any transform where the logic is fixed and the output structure should be consistent every run.

Three honest reasons to reach for an Agent:

1. The task calls a live tool or API. A Chain literally cannot do this. If your workflow must hit a search API, read from a database, or trigger a downstream service based on what the model decides, you need an Agent with connected Tool sub-nodes. Read more about what those tools actually are.
2. The task requires multi-step reasoning that changes with the input. If the model needs to examine a result before deciding what to do next, the loop is the point.
3. The task needs memory across sessions. Attach a Memory sub-node to the Agent to persist context. A Chain has no memory mechanism.

A fixed sequence is never a reason to use an Agent. If you always call tool A, then tool B, then tool C in the same order, wire those nodes together directly. Letting an Agent rediscover that fixed sequence on every run means paying for reasoning that produces no new value.

If no pro applies to your task, use a Chain.

Where Do Builders Waste Money on Agents?#

Builders waste money by running an Agent for a task a Chain would handle, then adding a flagship model on top. In my own workflows a routing step that picks a category from an email subject ran as an Agent, calling the model four times for one word. Swapping it to a Chain cut $8.80 to $1.75 on Haiku.

Four specific patterns that waste money:

1. Agent for a fixed single transform. Classifying, extracting, rewriting, or translating with an Agent instead of a Chain pays the ~5x premium for a reasoning loop that never calls a tool.
2. Agent for a fixed sequence. If the node order never changes, wire the nodes. The Agent's reasoning loop wastes calls rediscovering the same path every time.
3. Flagship model behind a router. Putting Sonnet 4.6 or Opus 4.8 behind a routing Agent multiplies an already-multiplied bill. A router does not need Opus-level reasoning. See the cost breakdown across models.
4. No Max Iterations cap on a production Agent. Without a cap, a confused Agent keeps calling the model. Each extra loop pass adds to the bill. Cap the loop; tune the cap based on your task's actual complexity.

Most routing and extraction tasks stop at the Chain branch.

What Should You Switch to a Chain This Weekend?#

Audit your active n8n workflows for AI Agent nodes with no Tool sub-nodes attached. An Agent connected to zero tools is almost certainly doing a Chain's job at five times the cost. Open the workflow, swap the AI Agent for a Basic LLM Chain, move the System Message into the Chat Messages System field, and run it on real inputs.

Then check any Agent node where tools are connected but the execution log shows the tools were never actually invoked. That Agent reasoned its way to a final answer without using the tools, which means the task did not need the loop. Replace it with a Chain.

For the Agents that genuinely do call tools, confirm that the tool setup is clean and that Max Iterations is set. A well-configured Agent calling real tools is worth every penny of the ~5x premium. An Agent doing a Chain's job is not.

Pick one active workflow with an AI Agent node, check whether any tools were invoked in the last 10 executions, and swap it to a Basic LLM Chain if none were. That one swap on a workflow firing 500 times per day moves you from about $4.40/day to about $0.88/day on Haiku 4.5. Then set Max Iterations on every Agent you keep.