QWE AI Academy You’ve got a form that dumps leads into a sheet, a Slack channel that never stops, and an inbox you half-read. You want n8n AI automation to classify, reply, and act – without hiring another person or pasting every message into ChatGPT. I wanted the same thing. The first agent I shipped looked brilliant in the editor. Then a tool came back empty, the run stayed green, and the bot invented a price a customer almost paid.
Zapier-style “if this then that” falls short the moment the next step isn’t fixed. Pure LLM chats can’t touch your CRM, calendar, or tickets. n8n sits in the middle: visual workflows, optional code, and agents that pick tools – but the failure modes aren’t the ones marketing pages show.
Why most first n8n AI automation attempts go quiet-wrong
I started where every tutorial starts: Chat Trigger, AI Agent node, a chat model, one tool, maybe Simple Memory. It answered. It called tools. Then three things bit me in the same week.
First, a search or sheet lookup returned nothing. The agent still said “done” and filled the gap with fluent nonsense. Community threads describe the same pattern: a green execution means the agent finished talking, not that the tool had real data. Fix at the wire: after any tool that matters, IF/Code on empty or error-shaped payloads and push an explicit “no records – do not guess” string back (or branch to a human) before the model is allowed a final answer.
Second, I asked for strict JSON. Most runs were clean. Every so often the model wrapped the object in a markdown fence. Downstream expressions went undefined; JSON.parse threw; the workflow kept walking on empty fields. A tiny fence-strip Code node between the LLM output and anything that writes is non-negotiable.
Third, memory saved a bad assumption on turn two. Every later reply was polite and wrong. No red node. Just poisoned context. Keep memory short and re-fetch account status, stock, or ticket state from your DB or API on each important turn – chat history is scratch paper, not source of truth.
That’s the gap between a demo and something you can leave running overnight.
The approach that actually holds: constrained agent + verify-then-speak
Open-ended path? Use the AI Agent node. One structured completion only? Skip it – plain OpenAI/Anthropic/Ollama (or Basic LLM Chain) is enough. Official docs: Agent needs a chat model plus at least one tool sub-node; the old “agent type” dropdown is deprecated from 1.82.0 and everything runs as a Tools Agent.
Wire a first production-shaped flow like this:
- Trigger (Chat, Webhook, Gmail, Schedule – whatever starts the work).
- Optional Code/Set that normalizes the payload into a fixed shape.
- AI Agent with a short system prompt: role, hard bans (“never invent IDs or prices”), preferred tools.
- Chat Model sub-node (your key or Gateway credits on Cloud).
- Tools – HTTP Request Tool, Call n8n Workflow Tool, or a specific app tool – with plain, outcome-named descriptions. Use
$fromAI()only where the model must fill parameters (see n8n’s how-tools-work docs). - Empty-check after tools that matter (covered above).
- Fence-stripping parse after final model text, before sheet/email/Slack writes.
Money-moving or customer-facing tools: gate them with human approval when your Agents surface supports it.
Draft vs live publishing – do you trust a canvas edit to hot-swap what customers already hit, or do you want a deliberate promote step? That question alone stops a class of 2 a.m. surprises.
Real run: inbound lead triage that refuses to invent
Here’s the concrete flow I settled on after the price hallucination scare.
Webhook receives a form: name, email, company size, free-text need. A Set node maps fields. The Agent’s instructions: score BANT-ish interest, pick one CRM tag, draft a 3-sentence reply – only via the “lookup pricing tier” workflow tool and the “create draft” tool. No free-form product claims.
// After LLM output - strip fences then parse
const raw = $json.output ?? $json.text ?? '';
const cleaned = String(raw)
.replace(/^```(?:json)?s*/i, '')
.replace(/s*```$/i, '')
.trim();
let parse_ok = true;
let data = {};
try {
data = JSON.parse(cleaned);
} catch (e) {
parse_ok = false;
}
return [{ json: { parse_ok, ...data, _raw: parse_ok ? undefined : cleaned } }];IF parse_ok is false → Slack me the _raw and stop. Pricing tool empty → the earlier “do not guess” path fires; CRM node never runs on invented tiers. One full workflow run still counts as one Cloud execution no matter how many tool loops sat inside – handy until concurrency caps or the Starter 5-minute max duration chew into chatty agents (Pro goes to 40 minutes per the pricing feature table).
Credits, hosting, and the bill you didn’t model
As of late 2026, Cloud Starter is about €20/month billed annually for 2,500 executions; Pro about €50 for 10,000. Unlimited users and workflows; you pay per completed run, not per step. Community self-host stays free on the software side. Numbers move – verify on n8n’s pricing page before you budget.
| Meter | What it pays for | Gotcha |
|---|---|---|
| Workflow executions | Each full run | Chatbots burn one per message; Starter concurrency is 5 parallel runs |
| Assistant credits | n8n Assistant / builder help | Starter allowance 1,600/month from 1 Oct 2026 (was 2,300); each credit fixed at 1 cent after recalibration; top-ups exist |
| Gateway credits | Models/tools without your own keys | Separate balance from Assistant credits; your own API key still works and bills the provider |
| Provider tokens | OpenAI, Anthropic, etc. | Agents can loop – cap max iterations and watch the provider bill |
Data can’t leave the network? The Self-hosted AI Starter Kit spins n8n with Ollama, Qdrant, and PostgreSQL via Docker Compose. Local models kill token bills and leakage; you own hardware and model quality instead.
Standalone Agents – the project-level assistants with channels, schedules, knowledge files, MCP, sub-agents – are a different surface from the workflow AI Agent node. Cloud has them on plans broadly; self-hosted from n8n 2.32.3. Docs still mark the feature preview. Mixing the two while reading tutorials is how people mis-wire human approval and schedules.
When to skip the Agent node entirely
Job is “always extract these five fields and write a row”? One chat-model call with a schema (or structured output) plus a Code guard beats a ReAct loop on predictability and token spend. Reserve the Agent for real tool choice; use a plain model call when the shape is fixed.
Also watch fan-out: Starter’s five concurrent executions and shared credentials mean clever parallel branches can stall each other mid-demo. A boring sequential loop with a short wait is often the run that finishes.
FAQ
Is n8n AI automation free?
Self-hosted Community: free software; you pay the server and model APIs. Cloud: paid from Starter up, with execution quotas. Assistant and Gateway credits are finite even when AI nodes are available.
Do I need my own OpenAI key?
Not always on Cloud. Pick Gateway credits on supported model nodes and n8n draws a prepaid balance (Gateway credits docs). Bring your own key for provider billing, odd models, or self-host. Ollama locally: no cloud key at all.
Why does my agent ignore tools or loop forever?
Vague tool names and a vague system prompt – almost always. Name tools by outcome, spell parameters, ban invention, set a low max iteration count. If the model keeps saying “I’ll call the tool” without calling it, the prompt is negotiating. For refunds, deletes, or sends, require human approval so a bad loop can’t act alone.
Open a free Cloud trial or the self-hosted AI kit, rebuild one painful manual triage with verify-then-speak, and read one full execution log end-to-end before customers ever see it.