GuideIntermediate
AI Chatbots and Agents with n8n
Build AI chatbots and agent systems that converse, remember, take action on real systems, and delegate tasks to each other, using n8n 2.0's native AI Agent nodes visually — no code frameworks required. The guide covers the full agentic loop: choosing a model and writing the system prompt, giving the agent persistent memory, connecting it to tools on real systems (Gmail, Sheets, databases, MCP), designing multi-agent systems with the orchestrator-worker pattern, and shipping it to real channels like web chat, WhatsApp, Telegram, and voice. It closes with agent security (prompt injection, trust boundaries, human-in-the-loop) and a multichannel customer support project, defendable in an interview and portfolio.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Tell agents, chatbots, and procedural AI apart, and understand the agentic loop (reason, act, observe) of the native AI Agent node
- Choose a current model and provider (Anthropic, OpenAI, Google, or local Ollama), and write a system prompt with a clear role and limits
- Give the agent memory: window buffer memory, persistent memory by session ID, and handling context drift in long conversations
- Connect tools on real systems (tool calling): Gmail, Sheets, databases, and HTTP, with contracts and trust boundaries
- Design multi-agent systems with the orchestrator-worker pattern, native delegation between agents, and cost/latency control
- Bring the agent to real channels: Chat Trigger and web widget, WhatsApp Business API, Telegram, and voice agents
- Protect the agent against prompt injection (direct and through tools), define trust boundaries, and require human approval before sensitive actions
- Debug agents with execution replay and tool call tracing
- Bring it all together in a multichannel, multi-agent customer support system with persistent memory and guardrails
Before you start
What you need to bring
It's for you if...
- People who already completed AI automation basics in n8n and want to move from fixed chains to autonomous agents
- Automation builders who need agents that take action on real systems (CRM, email, calendar), not just respond with text
- Support or sales teams looking for a multichannel agent (web, WhatsApp, voice) with per-customer persistent memory
- Anyone preparing for roles that ask for experience with agents in production, not just proofs of concept
Requirements and materials
- AI automation basics in n8n completed (what an LLM is, prompting, connecting models, structured outputs)
- An n8n instance (self-hosted Community at $0 by default; Cloud is optional)
- Access to at least one current AI model: an Anthropic, OpenAI, or Google API key, or a local model with Ollama
- No programming required: the Code node is used sparingly and is not taught from scratch
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Introduction: what you'll build in this guide
- 2. Agent, chatbot, and procedural AI: three different things
- 3. What is an agentic loop: reason, act, observe
- 4. The native AI Agent node in n8n 2.0
- 5. The four pieces: model, prompt, tools, and memory
- 6. When to use an agent and when not to
- 7. Where you'll run your agents: self-hosted Community vs Cloud
- 8. Mini-project: your first agent that responds
- 1. Introduction: the agent's brain
- 2. Choosing the model: current families in 2026 (and which to avoid)
- 3. Connecting AI providers: Anthropic, OpenAI, and Google credentials
- 4. Local models with Ollama: a $0 agent (Llama 3, Mistral)
- 5. The system prompt: role, boundaries, and response format
- 6. Model parameters and structured output
- 7. Testing and replaying executions with the debugging engine
- 8. Mini-project: an advisor agent with personality and boundaries
- 1. Introduction: the agent that remembers
- 2. Why memory changes everything
- 3. Window Buffer Memory: the context window
- 4. Persistent memory: session ID and storage
- 5. Multi-turn conversations: holding the thread
- 6. When memory degrades: context drift in long conversations
- 7. When to forget: summarizing and resetting the context
- 8. Mini-project: conversational agent with persistent per-user memory
- 1. Introduction: the agent that acts
- 2. What a tool is and how the agent decides to use it (tool calling)
- 3. Native n8n tools: search, create, send
- 4. Connecting real systems: Gmail, Sheets, a database, and HTTP
- 5. Tool contracts and trust boundaries
- 6. Sub-workflows as tools: encapsulating reusable logic
- 7. MCP in n8n: consuming external tools and the instance MCP server
- 8. Mini-project: an agent that executes 3 actions on real systems
- 1. Introduction: agents that delegate
- 2. Why one agent isn't enough: separating responsibilities
- 3. The orchestrator-worker pattern
- 4. An agent as another agent's tool: native delegation
- 5. Designing the team: roles, handoffs, and contracts between agents
- 6. Agentic loops between agents: stopping conditions
- 7. Cost and latency of a multi-agent system
- 8. Mini-project: triage → specialist system (2-3 agents)
- 1. Introduction: bringing the agent to real channels
- 2. Chat Trigger and embedded web widget
- 3. WhatsApp Business API: the agent where the customer is
- 4. Telegram bots
- 5. Voice agents: Vapi, Retell, and ElevenLabs
- 6. Conversational UX per channel: asynchrony, limits, and buttons
- 7. One agent, several channels: reusable architecture
- 8. Mini-project: the same agent on web and WhatsApp
- 1. Introduction: secure and reliable agents
- 2. Prompt injection: when the user's input hijacks the agent
- 3. Injection through tools: Gmail and Calendar as a vector
- 4. Trust boundaries: what the agent can do without permission
- 5. Human-in-the-loop: approval before sensitive actions
- 6. Hallucination and output verification
- 7. Debugging agents: replay and tool-call tracing
- 8. Mini-project: hardening an agent with guardrails, HITL, and validation
- 1. Project introduction: what you're going to deliver and how it's evaluated
- 2. Designing the system: agents, tools, memory, channels, and guardrails
- 3. The triage agent and specialists (multi-agent)
- 4. Tools: querying CRM and knowledge, creating tickets, and escalating
- 5. Persistent memory per customer + web and WhatsApp
- 6. Guardrails and human handoff for sensitive actions
- 7. Debugging, basic monitoring, and cost control
- 8. Delivery: demo, defense, and how to present it in your portfolio
Common questions
What people usually ask
No limit. It's a free guide: come in whenever you like, as often as you like.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Yes. It's issued automatically once you finish every lesson, with a verifiable code you can share on LinkedIn.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!