n8n AI Agent Nodes Explained: Every Node Type and When to Use Them

You’re staring at the n8n node panel, and the AI section alone has more options than most workflow builders have in total. Model nodes, Agent nodes, Chain nodes, Memory nodes, Vector Store nodes, Embedding nodes, Output Parser nodes — it’s a lot. And here’s the thing: picking the wrong node doesn’t just slow you down. It burns tokens, creates debugging nightmares, and turns a simple automation into something that loops endlessly for no reason.

Here’s what most builders miss: n8n’s AI nodes aren’t a grab bag. They’re an organized system — seven categories, each with a specific job. Once you understand the categories and the decision rules for picking between them, building AI workflows becomes predictable instead of experimental.

By the end of this guide, you’ll know every AI node category in n8n, which specific nodes matter most in each, and — critically — when to use an AI Agent versus a Basic LLM Chain so you stop overpaying for simple tasks.

The Seven Categories of n8n AI Nodes

n8n has over 70 specialized AI nodes, all built on LangChain. They fall into seven categories. Think of these as the layers of an AI stack — you don’t need every layer for every workflow, but understanding what each one does tells you exactly what to reach for.

Let’s go through each category in detail.

1. Model Nodes: Your LLM Connection Layer

Model nodes are non-negotiable. Every AI workflow needs at least one. They connect n8n to the LLM provider that does the actual thinking.

Key model nodes:

• OpenAI Chat Model — The default for most builders. Supports GPT-4o, GPT-4.1, and the full O-series. If you’re prototyping, start here.
• Anthropic Chat Model — Claude 4 Opus and Claude 4 Sonnet. Stronger at long-form reasoning and code generation. Many builders prefer Claude for complex agent tasks.
• Google Gemini Chat Model — Gemini 2.5 Pro and Flash. Excellent at large-context tasks and multimodal inputs.
• Ollama Chat Model — Run models locally. Llama 4, Mistral, Qwen — fully private, zero API costs. The go-to for sensitive data or offline workflows.

All model nodes share a consistent interface: model selection, temperature, max tokens, and streaming support. This means you can swap providers without rebuilding your workflow. Start with OpenAI for speed, switch to Ollama for privacy, or use Anthropic for reasoning-heavy tasks — the rest of your node chain stays the same.

When you need this: Always. No model node, no AI.

2. Agent Nodes: The Brain of Your AI Workflow

Agent nodes are where n8n’s AI capabilities get interesting. These nodes don’t just process text — they reason, decide, and act.

AI Agent Node

This is the flagship. The AI Agent node implements LangChain’s agent patterns (ReAct and OpenAI Functions calling), giving an LLM the ability to decide which tools to call, in what order, and with what parameters.

Here’s how it works:

1. Receive input — A user query or trigger event arrives
2. Think — The LLM evaluates: “What do I need to do?”
3. Decide — It selects a tool and determines the parameters
4. Act — The tool executes (search, database query, API call, code execution)
5. Observe — The agent reviews the tool’s output
6. Repeat or respond — If more is needed, loop back to step 2. Otherwise, generate the final answer

Critical configuration notes:

• Requires at least one tool sub-node. As of n8n v1.82+, the agent type selector has been removed — all AI Agents are now Tools Agents. If your workflow doesn’t need tools, use a Basic LLM Chain instead.
• Performance degrades beyond 10–15 tools. More isn’t better. Scope tightly.
• Set a maximum iterations limit. Without one, an agent can loop indefinitely, burning tokens with each cycle.
• Human-in-the-loop approval (added in v2.6, January 2026) lets you require human sign-off before the agent executes sensitive tools — think sending emails, processing payments, or posting to social media.

AI Agent Tool Node

Added in 2026, the AI Agent Tool node enables single-canvas multi-agent orchestration. One primary AI Agent supervises and delegates tasks to specialized sub-agents, each with its own tools and instructions. This is n8n’s answer to complex workflows where one agent can’t do everything well — instead, you have a dispatcher agent that routes work to specialist agents.

When you need Agent nodes: Any task requiring dynamic decision-making, external tool calls, multi-step reasoning, or conversation memory. If the AI needs to figure out the path rather than follow a predetermined one, you need an Agent.

3. Chain Nodes: Single-Pass Processing

Chain nodes are the workhorses of AI automation. Unlike agents, chains follow a fixed path: Input → Prompt Template → LLM → Output. One pass. No loops. No tool selection. No memory.

Basic LLM Chain

The most underrated node in n8n. For any well-defined text transformation — sentiment analysis, summarization, classification, translation, data extraction — a Basic LLM Chain is faster, cheaper, and more reliable than an AI Agent.

Why cheaper? An AI Agent enters a reasoning loop that may call the LLM multiple times per execution. A simple agent task might use 2–3x the tokens of a chain. A complex one? 5–10x or more. The Basic LLM Chain makes exactly one LLM call per execution. You can calculate costs precisely.

Other Chain Nodes

• Summarization Chain — Pre-built for condensing long documents. Handles chunking automatically for documents that exceed context windows.
• Question & Answer Chain — The core RAG pattern. Connects to a retriever (vector store) to answer questions from your documents. This is what powers “chat with your PDF” workflows.
• Information Extractor — Pulls structured data from unstructured text. Extract names, dates, amounts, and categories from emails, invoices, or meeting notes.
• Text Classifier — Routes content into predefined categories. Support ticket routing, content tagging, spam detection.
• Sentiment Analysis — Pre-built sentiment classification. Positive, negative, neutral — no prompt engineering needed.

When you need Chain nodes: The task is well-defined, the input-output relationship is clear, and you don’t need tools or memory. If you can write the rules in 10 minutes, it’s a chain job.

4. Memory Nodes: Conversation Context

Memory nodes give AI Agents persistent context across multiple turns. Without memory, every user message is treated like the first one.

Memory node types:

• Window Buffer Memory — Remembers the last N messages. Simple, fast, good for prototypes. The limitation: old context falls off the window.
• Token Buffer Memory — Remembers messages up to a token limit rather than a message count. More predictable for cost management.
• Postgres Chat Memory — Persistent memory backed by PostgreSQL. Survives workflow restarts and server reboots. For production chatbots where losing conversation history is unacceptable.
• Redis Chat Memory — Similar to Postgres but backed by Redis for low-latency retrieval. Better for high-throughput conversational applications.
• Motorhead Memory — External memory server designed specifically for AI agent conversations. Handles memory management, session isolation, and retrieval optimization.

Decision rule: Window Buffer Memory for prototypes. Postgres Chat Memory for production. Pinecone doesn’t apply here — that’s vector store territory.

When you need Memory nodes: Any conversational AI where the agent needs to reference previous messages. Customer support chatbots, multi-turn research assistants, interactive tutorials.

5. Vector Store Nodes: Knowledge Retrieval

Vector store nodes are the backbone of RAG pipelines. They store document embeddings and retrieve relevant chunks when queried.

Key vector store nodes:

• Pinecone — Managed, serverless, purpose-built for vector search. The best choice when you want zero infrastructure management and predictable performance at scale.
• Qdrant — Open-source vector database with a managed cloud option. Strong performance, flexible deployment.
• Supabase pgvector — PostgreSQL extension for vector search. Ideal if you’re already on Supabase and want vector search alongside your relational data.
• In-Memory Vector Store — Stores vectors in RAM. Fastest option but data disappears on restart. Use for testing and prototyping only.

Vector store nodes operate in two modes: Insert (load documents into the store) and Retrieve (search for relevant documents by query). A typical RAG workflow uses both — insert documents once, then retrieve for every query.

When you need Vector Store nodes: Your AI needs to answer questions from your own documents, knowledge base, or data. “Chat with my company wiki,” “search our product documentation,” “find relevant past support tickets.”

6. Embedding Nodes: The Vector Generators

Before you can store or search vectors, you need to generate them. Embedding nodes convert text into numerical representations (vectors) that capture semantic meaning.

Key embedding nodes:

• OpenAI Embeddings — text-embedding-3-small and text-embedding-3-large. Industry standard, strong performance, reasonable cost.
• Cohere Embeddings — Specialized embedding models. Strong for multilingual use cases.
• Ollama Embeddings — Run embedding models locally with nomic-embed-text or similar. Completely free, completely private. The best option when data can’t leave your infrastructure.
• HuggingFace Embeddings — Access hundreds of open-source embedding models. Maximum flexibility for specialized domains.

When you need Embedding nodes: Any RAG workflow. Embedding nodes feed vector store nodes. They always work as a pair.

7. Output Parser Nodes: Structured Responses

LLMs produce text. Your workflow needs structured data. Output parser nodes bridge that gap.

Key output parser nodes:

• Structured Output Parser — Forces the LLM to respond in a specific JSON schema. Define your fields, data types, and descriptions, and the parser ensures compliance. Essential when downstream nodes expect structured data.
• Auto-fixing Output Parser — Same as Structured, but with a retry mechanism. If the LLM’s output doesn’t match the schema, the parser feeds the error back to the LLM and asks it to fix the formatting. More reliable, slightly more expensive.
• List Output Parser — Forces output as a JSON array. Useful for extraction tasks where you expect multiple items.

When you need Output Parser nodes: Your AI output feeds into other workflow steps that expect structured data — HTTP requests, database inserts, conditional routing, or data transformation nodes.

The Decision That Saves You Money: Agent vs. Chain

The single most expensive mistake n8n builders make is using an AI Agent for tasks a Basic LLM Chain handles better. Here’s the decision framework, based on the architecture of each node type:

Use a Basic LLM Chain when:

• No memory needed. Each execution is independent.
• No tools needed. Pure text-in, text-out processing.
• The transformation is well-defined. You know exactly what input goes in and what output should come out.
• Cost predictability matters. One LLM call per execution. You can calculate costs precisely.
• Structured output is critical. Chains with output parsers produce formatted JSON more reliably than agents, whose reasoning loop can interfere with formatting.

Use an AI Agent when:

• Memory is required. Multi-turn conversations where the AI references previous exchanges.
• Tools are required. The AI needs to search the web, query a database, call an API, or execute code as part of its reasoning.
• The path is unknown. You can’t predetermine every step — the AI needs to figure out the approach.
• Flexibility beats predictability. The task requires adapting to variable inputs and situations.

The litmus test

Christopher Alarcon, an n8n practitioner who builds production AI workflows, puts it bluntly: “If I can write the rules in 10 minutes, it’s a workflow. If I’d need 50 if-statements and still miss cases, it’s an agent.”

That’s the bar. Sentiment analysis? You can write those rules. Use a chain. Customer support bot that handles refunds, product questions, and account issues with different tools for each? You’d need 50 if-statements and you’d still miss edge cases. Use an agent.

Real-World Node Combinations

Here’s what these categories look like when combined into actual workflows:

Pattern 1: The Smart Classifier

Nodes: Basic LLM Chain + Structured Output Parser
Use case: Route incoming support emails to the right department based on content.
Why it works: Well-defined transformation, no tools or memory needed, structured output for routing logic.

Pattern 2: The Document Q&A Bot

Nodes: Q&A Chain + OpenAI Embeddings + Pinecone Vector Store
Use case: Let users ask questions about your company handbook.
Why it works: RAG pattern — embed documents once, retrieve relevant chunks per query, generate answers grounded in your data.

Pattern 3: The Research Assistant

Nodes: AI Agent + Web Search Tool + Window Buffer Memory + Structured Output Parser
Use case: “Research competitor X and give me a structured brief.”
Why it works: Dynamic tool use for web searching, memory for multi-turn refinement, structured output for downstream consumption.

Pattern 4: Multi-Agent Content Pipeline

Nodes: AI Agent (dispatcher) + AI Agent Tool (researcher) + AI Agent Tool (writer) + Human-in-the-Loop
Use case: Research a topic, draft content, hold for human approval before publishing.
Why it works: Single-canvas orchestration with specialist agents and a safety gate for sensitive actions.

The 2026 Updates You Need to Know

n8n’s AI capabilities have evolved significantly. If you’re working from older tutorials or documentation, here’s what changed:

• v1.82+: The agent type selector is gone. All AI Agents are now Tools Agents. If your workflow doesn’t need tool calling, use Basic LLM Chain.
• v2.6 (January 2026): Human-in-the-loop approval. Require human sign-off before an agent executes specific tools.
• v2.22 (May 2026): One-click MCP connections. Connect to Apify, Linear, Notion, monday.com, and PostHog by signing in — no manual API configuration.
• v2.25 (June 2026): Native web search toggle in the AI Agent’s Advanced panel. No more setting up a separate web search tool for basic research tasks.

Build With Intention

n8n’s AI node ecosystem gives you everything you need to build sophisticated AI workflows — but only if you use the right node for the right job. The categories aren’t arbitrary. They’re a stack: Model nodes provide intelligence, Agent or Chain nodes provide orchestration, Memory nodes provide context, Vector Store and Embedding nodes provide knowledge, and Output Parser nodes provide structure.

Before you drag an AI Agent onto the canvas, ask yourself: does this task need tools? Does it need memory? Does the AI need to figure out the path, or is the path already clear?

Answer those three questions, and you’ll know exactly which nodes to use — and which ones to leave in the panel.

Want to go deeper? I’m building a complete system for deploying AI agents in production — join the waitlist at aitokenlabs.com/ai-agent-builders/waitlist

About the Author

Anthony Odole is a former IBM Senior Managing Consultant, where he served as Enterprise Architect on Fortune 500 engagements, and the founder of AIToken Labs. He helps business owners cut through AI hype by focusing on practical systems that solve real operational problems.

His flagship platform, EmployAIQ, is an AI Workforce platform that enables businesses to design, train, and deploy AI Employees — AI agents that function as digital workforce members — that perform real work without adding headcount.