n8n AI Agent vs LLM Chain: How to Choose the Right Node

You’re probably using the wrong AI node for your workflow. Most n8n builders default to AI Agents for every task involving an LLM, not realizing that a Basic LLM Chain would deliver better results at a fraction of the cost.

The n8n community sees this confusion constantly. Reddit threads fill with questions about output parsers failing, agents looping endlessly, and token costs spiraling out of control.

The root cause is almost always the same: using the wrong node for the job.

The Quick Answer

Use This	When You Need
Basic LLM Chain	Text transformation, classification, extraction, summarization
AI Agent	Tools, memory, multi-step reasoning, dynamic decisions

---

The Common Mistake

When you first discover n8n’s AI capabilities, the AI Agent node looks impressive. It can:

• Use external tools
• Remember conversations
• Reason through complex problems

So you use it for everything. Sentiment analysis? Agent. Text summarization? Agent. Data extraction? Agent.

This approach works, technically. But it’s like driving a semi-truck to the grocery store. You’ll get there, but you’re burning resources and making everything harder than it needs to be.

---

The Real Cost

An AI Agent doesn’t just call an LLM once. It enters a reasoning loop that may iterate multiple times:

Scenario	LLM Calls	Token Usage
Basic LLM Chain	1	Predictable
Simple Agent Task	2-3	2-3x higher
Complex Agent Task	5-10+	5-10x higher

Multiply this across thousands of executions, and your costs multiply accordingly.

---

What You’ll Learn

• The fundamental architectural difference between agents and chains
• A practical decision framework for choosing the right node
• When chains outperform agents (and vice versa)
• Configuration examples for common use cases
• Cost analysis and token management strategies
• How to combine both nodes for optimal results
• Troubleshooting common issues with each approach
• Advanced patterns used by production workflows

Understanding the Core Difference

Before diving into when to use each node, you need to understand how they work differently at an architectural level. This isn’t just academic knowledge. It directly affects cost, reliability, and debugging.

The Basic LLM Chain: Single-Pass Processing

The Basic LLM Chain node follows a simple flow:

Input → Prompt Template → LLM → Output

That’s it. One pass. No loops. No tool selection. No memory of previous executions.

When you trigger a Basic LLM Chain, it assembles your prompt from the template and input data, sends it to the connected LLM, and returns whatever the model generates. The node completes in a single API call.

This simplicity is a feature, not a limitation. For tasks where you know exactly what you want the LLM to do, a single-pass approach is faster, cheaper, and more reliable than iterative reasoning.

The AI Agent: Reasoning Loop

The AI Agent node operates completely differently:

1. Receive input
2. Think: "What should I do?"
3. Decide: Call a tool, respond, or give up
4. If tool called: Execute tool, observe result
5. Think: "Did this solve the problem?"
6. If not solved: Return to step 2
7. Generate final response

This loop continues until the agent decides it has completed the task or hits an iteration limit. A single user query might trigger multiple LLM calls as the agent reasons, acts, observes, and reasons again.

The loop architecture enables powerful capabilities. Agents can gather information from multiple sources, try different approaches when one fails, and synthesize complex answers. But every iteration costs tokens and adds latency.

Memory: The Critical Distinction

The most fundamental difference isn’t loops versus single-pass. It’s memory.

Basic LLM Chain has no memory. Each execution is completely independent. The chain doesn’t know about previous messages, previous executions, or any context beyond what you explicitly provide in the current prompt.

AI Agent supports multiple memory types. You can attach Simple Memory, Window Buffer Memory, Postgres Chat Memory, or Vector Store Memory to an agent. This enables multi-turn conversations where the agent remembers what was discussed previously.

If your use case requires remembering previous interactions, you need an agent. If each execution is independent, a chain is sufficient. For a deeper dive into chain concepts, the official n8n documentation on chains provides additional context.

Tool Access: Another Key Differentiator

Basic LLM Chains cannot use tools. They process text in and text out. If your workflow needs to call external APIs, search the web, query databases, or execute code as part of the AI reasoning, the chain node simply can’t do it.

AI Agents require at least one tool to function. Tools extend what the agent can do beyond text generation. An agent with a web search tool can look up current information. An agent with a database tool can query your data. An agent with a code execution tool can run calculations. Under the hood, n8n’s AI Agent uses the LLM’s native function calling capabilities to invoke tools.

If the task requires external actions during AI processing, you need an agent. If you just need text transformation, a chain handles it better.

When to Use Basic LLM Chain

The Basic LLM Chain excels at well-defined text transformations. When you know exactly what input goes in and what output should come out, chains deliver with reliability and predictability.

Ideal Use Cases

Sentiment Analysis

Classifying text as positive, negative, or neutral is a perfect chain task. The transformation is well-defined: text in, classification out. No tools needed. No memory required. A chain with a structured output parser handles this reliably for thousands of executions.

Content Summarization

Condensing long documents into summaries follows the same pattern. Input text, instructions for length and focus, output summary. The LLM doesn’t need to search for information or make decisions about what tools to use. It just needs to process and compress.

Data Extraction

Pulling structured data from unstructured text works beautifully with chains. Extract customer names, dates, amounts, and categories from emails. Pull product information from descriptions. Convert meeting notes to action items. The input-output relationship is clear and consistent.

Translation

Language translation is inherently stateless. Translate this text from English to Spanish. No memory of previous translations needed. No external tools required. Pure text transformation.

Classification and Categorization

Routing support tickets, categorizing documents, tagging content. These tasks involve analyzing input and assigning labels from a defined set. Chains handle classification with consistent results, especially when combined with output parsers for structured responses.

Text Reformatting

Converting between formats, standardizing data, correcting grammar, adjusting tone. Any task where you’re reshaping text according to specific rules fits the chain model perfectly.

Use Case Decision Table

Task	Use Chain?	Reason
Sentiment analysis	Yes	Fixed transformation, no tools needed
Summarization	Yes	Stateless, predictable output
Data extraction	Yes	Well-defined input/output
Translation	Yes	Pure text transformation
Classification	Yes	No external data required
Reformatting	Yes	Deterministic transformation
FAQ answering	Maybe	Use Q&A Chain for RAG workflows
Research tasks	No	Needs tools and iteration
Conversations	No	Requires memory
Dynamic decisions	No	Agent must decide actions

Why Chains Excel Here

For these use cases, chains aren’t just adequate. They’re actually better than agents.

Predictable cost. One LLM call per execution. You can calculate token usage precisely and budget accurately.

Reliable output parsing. When you need structured JSON output, chains work more reliably with output parsers than agents do. The agent’s reasoning loop can interfere with structured output generation, while chains produce formatted responses consistently.

Simpler debugging. When something goes wrong, you trace one API call. Input went in, output came out, something in between was wrong. No loops to untangle.

Faster execution. Single-pass means lower latency. For user-facing applications where response time matters, chains finish faster.

For a hands-on comparison, n8n provides an official workflow example where you can test both approaches with the same input.

When to Use AI Agent

The AI Agent shines when tasks require flexibility, external information, or ongoing context. When you can’t define the exact steps in advance, agents figure out the path.

Ideal Use Cases

Multi-Step Research

“Find information about company X, check their recent news, and summarize their competitive position.” This task requires multiple information-gathering steps. The agent needs to search, read results, decide what additional information is needed, and synthesize findings. A chain can’t do this without you predetermining every step.

Tool-Based Tasks

Any task requiring external actions during AI reasoning needs an agent. Calculate shipping costs based on current rates. Check inventory before responding. Look up customer history. Send notifications. Agents call tools as needed, chains cannot.

Conversational Applications

Building a chatbot that remembers context? Agent with memory. Support assistant that recalls the customer’s previous issues? Agent with memory. Any interaction where the AI needs to reference earlier messages requires the agent’s memory capabilities.

Dynamic Decision Making

“Help this customer with whatever they need.” The appropriate response depends entirely on what the customer asks. The agent might need to look up an order, explain a product, process a return, or escalate to support. Each path requires different tools and information. Agents handle this variability, chains cannot.

Complex Reasoning Tasks

Problems requiring multiple steps of reasoning, backtracking when approaches fail, or synthesizing information from various sources benefit from the agent loop. The agent can try one approach, evaluate results, and try another if needed.

Use Case Decision Table

Task	Use Agent?	Reason
Web research	Yes	Needs search tools and iteration
Customer support	Yes	Dynamic tool selection required
Chatbots	Yes	Requires memory for context
Data analysis	Yes	May need multiple tool calls
Task automation	Yes	External actions required
Complex Q&A	Yes	May need retrieval and reasoning
Simple extraction	No	Chain is more reliable
Classification	No	Chain is cheaper and faster
Summarization	No	No tools or memory needed
Translation	No	Stateless transformation

Why Agents Excel Here

For these scenarios, agents provide capabilities chains simply don’t have.

Adaptive behavior. The agent adjusts its approach based on what it learns. If one tool doesn’t provide needed information, it tries another. If the first search returns poor results, it refines the query. This behavior is based on the ReAct pattern from LangChain, where agents reason about what action to take next.

Memory for context. In conversations, the agent remembers what was discussed. It can reference earlier messages, maintain topic threads, and provide coherent multi-turn interactions.

Tool orchestration. The agent decides which tools to use, in what order, and with what parameters. You define the available tools; the agent handles the choreography.

Complex reasoning. For problems that can’t be solved in one step, the agent’s loop enables iterative reasoning toward a solution.

The Decision Framework

Use this framework when you’re unsure which node to choose. Work through the questions in order. The first “yes” typically determines your choice.

Question 1: Does the task need memory?

If your AI needs to remember previous messages in a conversation or reference earlier context, you need an agent. Chains are completely stateless.

Memory required → Use AI Agent

Question 2: Does the task need external tools?

If the AI needs to call APIs, search the web, query databases, or perform any external action as part of its reasoning, you need an agent. Chains can only process text.

Tools required → Use AI Agent

Question 3: Is structured output critical?

If you need guaranteed JSON structure or specific output formats for downstream processing, chains with output parsers are more reliable. Agents can produce structured output, but the reasoning loop sometimes interferes with formatting.

Structured output critical → Prefer Basic LLM Chain with Output Parser

Question 4: Is cost predictability important?

If you need to know exactly what each execution costs, chains provide that predictability. Agent costs vary based on how many iterations occur, which tools are called, and how complex the reasoning becomes.

Cost predictability critical → Prefer Basic LLM Chain

Question 5: Is the transformation well-defined?

If you can clearly specify “given this input, produce this output” without needing the AI to make decisions about how to get there, use a chain. If the path from input to output requires the AI to figure things out, use an agent.

Well-defined transformation → Use Basic LLM Chain AI must decide approach → Use AI Agent

Quick Reference Flowchart

Start
  │
  ├─ Need memory? ─────────────── Yes ──→ AI Agent
  │     │
  │    No
  │     │
  ├─ Need tools? ──────────────── Yes ──→ AI Agent
  │     │
  │    No
  │     │
  ├─ Critical structured output? ─ Yes ──→ Basic LLM Chain
  │     │
  │    No
  │     │
  ├─ Well-defined transformation? ─ Yes ──→ Basic LLM Chain
  │     │
  │    No
  │     │
  └─ AI must decide approach? ──── Yes ──→ AI Agent

Side-by-Side Comparison

This comprehensive comparison covers every major difference between the two nodes.

Feature	Basic LLM Chain	AI Agent
Memory	None	Multiple types available
Tools	Cannot use tools	Requires at least one tool
Execution	Single pass	Loop until complete
Token usage	Predictable (1 call)	Variable (multiple calls)
Cost	Lower, fixed	Higher, variable
Latency	Lower	Higher
Debugging	Simple	Complex
Output parsing	Very reliable	Can be inconsistent
Flexibility	Low	High
Best for	Transformations	Decisions
Error handling	Straightforward	Requires more care
Use case fit	Defined tasks	Open-ended tasks

Architectural Summary

Basic LLM Chain

• Input → Process → Output
• One API call per execution
• No state between executions
• Deterministic behavior

AI Agent

• Input → Think → Act → Observe → Repeat
• Multiple API calls possible
• Can maintain state via memory
• Adaptive behavior

Configuration Examples

These examples show real configurations for common scenarios. Use them as starting points for your own workflows.

Example 1: Sentiment Analysis (Basic LLM Chain)

This configuration analyzes customer feedback and returns structured sentiment data.

Node Setup:

• Basic LLM Chain connected to OpenAI Chat Model
• Structured Output Parser for JSON response
• Temperature set to 0 for consistent classification

Prompt:

Analyze the sentiment of the following customer feedback.

Feedback: {{ $json.feedbackText }}

Classify the sentiment and provide analysis.
Respond with a JSON object containing:
- sentiment: "positive", "negative", or "neutral"
- confidence: number from 0-100
- keyPhrases: array of phrases that influenced your classification
- summary: one sentence explaining your assessment

Output Parser Schema:

{
  "type": "object",
  "properties": {
    "sentiment": {
      "type": "string",
      "enum": ["positive", "negative", "neutral"]
    },
    "confidence": {
      "type": "number",
      "minimum": 0,
      "maximum": 100
    },
    "keyPhrases": {
      "type": "array",
      "items": { "type": "string" }
    },
    "summary": { "type": "string" }
  },
  "required": ["sentiment", "confidence", "summary"]
}

Why Chain Works Here:

• No memory needed between analyses
• No tools required
• Well-defined transformation
• Structured output with parser
• Predictable cost per execution

For expression syntax in prompts, see our n8n expressions guide.

Example 2: Customer Support Agent (AI Agent)

This configuration handles customer inquiries with access to order data and escalation capabilities.

Node Setup:

• AI Agent with OpenAI Chat Model
• Postgres Chat Memory for conversation continuity
• Three tools: order_lookup, product_search, escalate_ticket

System Prompt:

You are a customer support agent for TechStore.

AVAILABLE TOOLS:
- order_lookup: Search orders by order ID or customer email. Use for order status questions.
- product_search: Find products in catalog. Use for availability and product questions.
- escalate_ticket: Create support ticket for complex issues. Use for refunds over $200 or technical problems.

GUIDELINES:
- Always verify the customer before sharing order details
- For refund requests over $200, use escalate_ticket
- If you can't find an order, ask the customer to verify details
- Keep responses friendly but professional

RESPONSE FORMAT:
- Acknowledge the customer's question
- Provide the answer or solution
- Ask if there's anything else you can help with

Tool Descriptions:

Order Lookup:

Search customer orders by order ID or email address.
Input: order_id (string) OR customer_email (string)
Output: Order details including status, items, shipping info

Product Search:

Search product catalog for availability and information.
Input: search_query (string)
Output: Array of matching products with name, price, stock status

Escalate Ticket:

Create a support ticket for issues requiring human intervention.
Input: customer_email (string), issue_summary (string), priority (low/medium/high)
Output: Ticket ID and confirmation

Memory Configuration:

• Postgres Chat Memory
• Session ID: {{ $json.customerId }}_{{ $json.conversationId }}

Why Agent Works Here:

• Memory maintains conversation context
• Tools required for order lookup and escalation
• Dynamic decision-making based on customer needs
• Multi-turn conversation support

For detailed agent setup guidance, see our AI Agent node documentation.

Example 3: Hybrid Approach (Agent + Chain)

This pattern uses an agent for reasoning and a chain for final output formatting. It combines the flexibility of agents with the reliable structured output of chains.

Workflow Structure:

[Trigger] → [AI Agent] → [Edit Fields] → [Basic LLM Chain + Parser] → [Output]

Why This Pattern: The AI Agent handles complex reasoning, tool usage, and information gathering. Its output goes to an Edit Fields node that extracts the agent’s response text. Then a Basic LLM Chain with a Structured Output Parser formats the result into the exact JSON structure needed.

AI Agent Configuration:

• System prompt focuses on gathering information and reasoning
• No output format requirements in agent prompt
• Agent produces natural language response

Edit Fields Node:

• Extracts agent response: {{ $json.output }}
• Passes to formatting chain

Formatting Chain Prompt:

Convert the following analysis into structured JSON format.

Analysis:
{{ $json.agentResponse }}

Format as JSON with these fields:
- recommendation: main recommendation
- reasoning: array of supporting points
- confidence: percentage
- nextSteps: array of action items

Benefits of Hybrid:

• Agent flexibility for complex tasks
• Reliable structured output from chain
• Separation of concerns
• Easier debugging (reasoning vs formatting)

This pattern is recommended when you need both agent capabilities and guaranteed output structure. See our workflow development services for help implementing complex patterns.

Cost and Performance Analysis

Understanding the cost implications of each node helps you make economical choices without sacrificing capability.

Token Usage Comparison

Consider a simple task: analyzing a customer email and extracting key information.

With Basic LLM Chain:

• Input tokens: ~500 (email + prompt)
• Output tokens: ~100 (structured response)
• Total: ~600 tokens
• API calls: 1

With AI Agent (no tools needed):

• Input tokens: ~700 (email + prompt + system context + tool descriptions)
• Reasoning tokens: ~200 (agent thinking)
• Output tokens: ~150 (response with reasoning)
• Total: ~1,050 tokens
• API calls: 1-2 (depending on reasoning complexity)

For this simple task, the chain uses roughly 40% fewer tokens. Multiply across thousands of executions, and the savings compound significantly.

When Agent Costs Escalate

Agent costs increase when:

Multiple tool calls: Each tool call triggers a new iteration. An agent that searches the web, reads results, and searches again might use 3x the tokens of a single-pass chain.

Complex reasoning: Difficult problems require more thinking. The agent’s internal reasoning process consumes tokens even when it doesn’t call tools.

Long conversations: With memory attached, every message in history gets sent to the LLM on each turn. Ten messages of context means ten times the input tokens versus a fresh start.

Retry loops: If a tool returns unclear results, the agent might retry with different parameters. Each retry costs tokens.

Cost Control Strategies

Use chains for high-volume tasks. If you’re processing thousands of items daily, chain savings add up fast.

Limit agent memory. Use Window Buffer Memory with a small window (5-10 messages) instead of unlimited history. Old context drops off, limiting token growth.

Right-size models. Simple classification doesn’t need the most capable model. Smaller, cheaper models handle straightforward tasks effectively.

Add iteration limits. Configure maximum iterations in your agent setup to prevent runaway loops.

Track usage. Add a Code node to log execution details. Monitor which workflows consume the most tokens.

For rate limiting strategies that help control costs, see our API rate limits guide.

Performance Considerations

Beyond cost, consider execution time.

Chain latency: One API call. Typically 1-3 seconds depending on model and prompt length.

Agent latency: Multiple API calls plus tool execution time. A research agent might take 10-30 seconds to complete as it searches, reads, and synthesizes.

For user-facing applications where response time matters, chains provide faster feedback. For background processing where accuracy trumps speed, agents can take their time.

Common Mistakes and How to Avoid Them

These mistakes appear constantly in community discussions. Learning from others’ errors saves you debugging time.

Mistake 1: Using Agents for Simple Transformations

The pattern: Building an AI Agent with no meaningful tools just to classify text or extract data.

The problem: You get agent overhead (higher tokens, more complex debugging) without agent benefits (tools, memory, adaptive behavior).

The fix: If your task doesn’t need tools or memory, use a Basic LLM Chain. It’s not less capable for the task; it’s appropriately scoped.

Mistake 2: Expecting Memory from Chains

The pattern: Wondering why your Basic LLM Chain doesn’t remember what the user said in the previous message.

The problem: Chains are stateless by design. Each execution knows nothing about previous executions.

The fix: If you need conversation memory, switch to an AI Agent with a memory sub-node. If you want chain-like simplicity but need context, manually include relevant history in your prompt using n8n expressions.

Mistake 3: Output Parser Issues with Agents

The pattern: Connecting a Structured Output Parser to an AI Agent and getting inconsistent results or parse failures.

The problem: The agent’s reasoning loop can interfere with structured output generation. The agent might include reasoning text, tool call descriptions, or other content that breaks the expected format.

The fix: Use the hybrid approach. Let the agent reason freely, then pass its response through a separate Basic LLM Chain with an output parser for final formatting. This separation works much more reliably.

Mistake 4: Not Setting Iteration Limits

The pattern: An agent gets stuck in a loop, calling the same tool repeatedly or never deciding the task is complete.

The problem: Without limits, a confused agent can iterate indefinitely, consuming tokens until something crashes or you notice the problem.

The fix: Configure maximum iterations in your agent settings. Add clear completion criteria in your system prompt. Monitor for executions that take unusually long.

Mistake 5: Over-Complicated Tool Setups

The pattern: Connecting ten different tools to an agent “just in case” it needs them.

The problem: More tools mean more decisions for the agent. Each tool’s description consumes input tokens on every call. The agent might choose inappropriate tools or get confused about which tool handles what.

The fix: Start with minimal tools. Add more only when testing reveals they’re needed. Write clear, distinct tool descriptions so the agent knows exactly when to use each one.

For debugging workflow issues, use our workflow debugger tool.

Advanced Patterns

These patterns appear in production workflows that need both chain reliability and agent flexibility.

Routing Pattern: Classify Then Route

Use a chain to classify incoming requests, then route to specialized handlers.

[Input] → [Classification Chain] → [Switch Node]
                                      ├→ [Simple Handler (Chain)]
                                      ├→ [Complex Handler (Agent)]
                                      └→ [Special Case Handler]

The classification chain examines the request and outputs a category. The Switch node routes to the appropriate handler. Simple requests go to fast, cheap chains. Complex requests go to capable agents.

Benefits:

• Most requests handled by efficient chains
• Agent costs only where needed
• Clear separation of concerns
• Easy to add new categories

Sequential Processing: Chain Pipeline

For multi-step transformations, connect chains in sequence rather than using one agent.

[Input] → [Extract Chain] → [Analyze Chain] → [Format Chain] → [Output]

Each chain handles one well-defined step. The extract chain pulls data from raw text. The analyze chain processes the extracted data. The format chain structures the final output.

Benefits:

• Each step is testable independently
• Failures are easier to locate
• You can optimize each step separately
• Predictable total cost (sum of individual chains)

Orchestrator Pattern: Agent Delegates to Chains

A master agent decides what needs to happen, then delegates execution to specialized chains or sub-workflows.

[Input] → [Orchestrator Agent]
              ├─ Tool: summarize_workflow (calls a chain)
              ├─ Tool: extract_workflow (calls a chain)
              └─ Tool: analyze_workflow (calls a chain)

The agent handles high-level reasoning and decision-making. Actual text processing happens in reliable chains called as workflow tools.

Benefits:

• Agent flexibility for task selection
• Chain reliability for execution
• Modular, maintainable architecture
• Costs controlled at execution level

For implementing complex workflow architectures, our n8n consulting services provide expert guidance.

Troubleshooting Guide

When things go wrong, these solutions address the most common issues.

Issue: Agent Loops Infinitely

Symptoms: Execution runs for minutes. Token usage spikes. Agent keeps calling tools without reaching a conclusion.

Causes:

• Tool returns unclear or empty results
• System prompt lacks completion criteria
• Agent doesn’t recognize when the task is done

Solutions:

1. Check tool output. Is the tool returning actionable data? Empty or error responses confuse the agent.
2. Add explicit completion criteria to your system prompt: “When you have gathered sufficient information, provide your final response.”
3. Configure maximum iterations in agent settings.
4. Add logging to see what the agent is thinking at each step.

Issue: Output Parser Fails with Agent

Symptoms: “Could not parse LLM output” errors. Structured output sometimes works, sometimes doesn’t.

Causes:

• Agent reasoning text interferes with JSON structure
• Agent includes tool call information in response
• Temperature too high causes format variation

Solutions:

1. Use the hybrid pattern: Agent for reasoning, Chain for formatting.
2. Lower temperature to 0 for deterministic output.
3. Add explicit format instructions in both system prompt and user prompt.
4. Simplify the expected schema.

Issue: Chain Doesn’t Remember Context

Symptoms: Each message to the chain starts fresh. Previous conversation is lost.

Causes:

• Chains are stateless by design. This is expected behavior.

Solutions:

1. Switch to AI Agent with memory if you need conversation continuity.
2. If you must use a chain, manually include conversation history in your prompt:

{{ $json.conversationHistory.map(m => m.role + ": " + m.content).join("\n") }}

3. Store history in a database and retrieve it for each chain call.

Issue: Unexpected Token Costs

Symptoms: Bills higher than expected. Certain workflows consume disproportionate tokens.

Causes:

• Agent iterations more than expected
• Large conversation history in memory
• Verbose tool descriptions
• Long system prompts repeated on every call

Solutions:

1. Audit your workflows. Identify which consume the most tokens.
2. Switch high-volume simple tasks from agents to chains.
3. Use Window Buffer Memory with limited message count.
4. Trim tool descriptions to essential information.
5. Consider smaller models for simple tasks.

For timeout issues that often accompany complex agent workflows, see our timeout troubleshooting guide.

Frequently Asked Questions

Can I add memory to a Basic LLM Chain?

Short answer: No. Chains are stateless by design.

Basic LLM Chain nodes cannot connect to memory sub-nodes and don’t retain any context between executions.

Your options:

Approach	Pros	Cons
Switch to AI Agent	Native memory support	Higher token cost
Manual context in prompt	Keep chain reliability	More complexity
Store history in database	Full control	Requires setup

The manual approach works by storing conversation history externally and including relevant history in your chain’s prompt using expressions.

---

Why does my output parser work with Chain but fail with Agent?

Short answer: Agent reasoning loops interfere with structured output.

The difference comes from how each node generates output:

Node	Output Behavior
Basic LLM Chain	Single focused response, follows format directly
AI Agent	May include reasoning thoughts, tool calls, extra content

This additional agent content breaks parser expectations.

The fix: Use the hybrid pattern:

[AI Agent] → [Edit Fields] → [Basic LLM Chain + Output Parser]

Let the agent reason freely, then format with a chain. This separation works much more reliably.

---

How do I limit token costs when using AI Agent?

Short answer: Limit memory, minimize tools, set iteration caps.

Cost reduction strategies:

Strategy	Impact	Implementation
Limit memory size	High	Window Buffer Memory (5-10 messages)
Minimize tools	Medium	Remove unused tools, concise descriptions
Set iteration limits	High	Configure max iterations (3-5 typical)
Add completion criteria	Medium	Explicit “task complete” instructions
Right-size models	High	Smaller models for simpler tasks
Track usage	Ongoing	Log tokens per workflow, find outliers

---

When should I use Q&A Chain vs AI Agent with retrieval?

Short answer: Q&A Chain for simple document Q&A. Agent for complex retrieval scenarios.

Scenario	Best Choice
Simple “ask about documents”	Q&A Chain
Multiple retrieval sources	AI Agent
Retrieval + other tools	AI Agent
Conditional retrieval	AI Agent
Pure RAG workflow	Q&A Chain

The Question and Answer Chain is designed specifically for RAG workflows where you query a vector store and generate answers. It’s simpler and more cost-effective for pure document Q&A.

Use AI Agent when retrieval is just one step in a larger process, or when the agent needs to decide whether retrieval is even necessary.

---

Can I use multiple LLM providers in the same workflow?

Short answer: Yes, and it’s a smart optimization strategy.

Different models excel at different tasks and cost different amounts:

Task	Suggested Approach
Classification/routing	Fast, cheap model
Complex reasoning	Capable model
Summarization	Mid-tier model
Code generation	Specialized model

In n8n, each AI node connects to its own chat model sub-node. You can configure different providers for different nodes in the same workflow.

The n8n community has developed patterns for dynamically switching between LLMs based on workflow conditions.

For more details on LangChain integration, see the official n8n LangChain documentation.