10 n8n AI Agent Templates You Can Deploy Today

The n8n community template library passed 9,000 workflows this year, and AI agent workflows now dominate new submissions. That sounds like abundance. In practice it is mostly noise. Search "AI agent" in the library and you will find 80-node monsters with three LLM calls chained for no reason, workflows that only run on the author's exact Notion setup, and demos that were never executed against real traffic.

After building and auditing dozens of these for client projects, I use a simple test for whether a template is worth importing. A good n8n AI agent template has five properties:

1. One clear trigger. A Webhook, Chat Trigger, Gmail Trigger, or Schedule Trigger. If you cannot say in one sentence what event starts the workflow, skip it.

2. One AI Agent node with 2-4 tools. The AI Agent node (n8n's LangChain-based agent) should be the brain, with tools like HTTP Request, Google Sheets, or a Vector Store attached. Templates that chain five separate LLM nodes to fake agent behavior are harder to debug and cost more per run.

3. Explicit memory. A Window Buffer Memory (or Postgres Chat Memory) node with a sensible session key. Conversational templates without memory produce agents with amnesia.

4. A human fallback branch. An IF node routing low-confidence or high-stakes outputs to Slack, email, or a review sheet instead of straight to the customer.

5. A logging step. Usually a Google Sheets append or database insert. If you cannot see what the agent did yesterday, you cannot improve it.

Every template below passes this test. All 10 are included as importable JSON in our free n8n AI agent template pack, so you can grab the files, import them, and follow along. Here is the master comparison table:

If you are brand new to the AI Agent node itself, read our n8n AI agent tutorial first. This post assumes you know what a tool and a memory node are, and focuses on the patterns.

What it does: Reads every incoming support email, classifies it (billing, bug, feature request, refund, spam), assigns urgency, drafts a suggested reply, and routes it to the right channel. It does not send anything to customers on its own - it makes your human team 3-4x faster. Trigger: new email. Setup time: about 45 minutes. Difficulty: beginner.

Node chain: Gmail Trigger (polling every minute on your support inbox) feeds a Set node that extracts sender, subject, and body. That goes into the AI Agent node with a structured Output Parser forcing JSON output. A Switch node routes on the category field: billing goes to the finance Slack channel via a Slack node, bugs get created as issues via HTTP Request to your tracker, refunds over a threshold ping a manager, and everything gets appended to a Google Sheets log.

System prompt sketch:

You are a support triage assistant for [COMPANY].
Classify each email into exactly one category:
billing | bug | feature_request | refund | spam | other.
Assign urgency: low | medium | high.
High urgency = outage reports, payment failures, angry
customers threatening to churn.
Draft a suggested reply in our tone: friendly, direct,
no corporate filler.
Return JSON only:
{"category": "...", "urgency": "...",
 "summary": "one sentence",
 "suggested_reply": "..."}

Customisation tips: Add your real category taxonomy - the generic six above are a starting point. Paste 5 anonymized real emails with correct labels into the prompt as few-shot examples; classification accuracy jumps noticeably. Wire the urgency field to Slack mentions so high-urgency emails ping an actual human.

When NOT to use it: If you get fewer than 10 support emails a day, triage overhead is not your problem. And do not extend this template to auto-send replies until you have watched its drafts for at least two weeks. When you are ready for a full autonomous support agent with escalation, follow our customer support agent with n8n guide.

What it does: A chatbot that answers questions from your own documentation instead of hallucinating from the model's training data. This is the most-searched agent template in the n8n library for a reason: it is the pattern behind internal help desks, docs assistants, and onboarding bots. Trigger: chat message (or webhook from your site widget). Setup time: 2-3 hours including document ingestion. Difficulty: intermediate.

Node chain: Two workflows. The ingestion workflow uses a Google Drive Trigger watching a docs folder, a Default Data Loader with a Recursive Character Text Splitter (chunk size 800-1200, overlap 100-200), an Embeddings node, and a Vector Store node (Pinecone, Qdrant, or the built-in Simple Vector Store for testing). The chat workflow uses a Chat Trigger, an AI Agent with the vector store attached as a retrieval tool, and Window Buffer Memory keyed on the chat session ID.

System prompt sketch:

You answer questions about [PRODUCT] using ONLY the
knowledge base tool. Always search before answering.
If the retrieved context does not contain the answer,
say "I don't have that in my docs" and offer to
connect the user with the team. Never invent URLs,
prices, or version numbers. Cite the doc title you
used at the end of each answer.

Customisation tips: The single biggest quality lever is chunking, not the model. Split on headings where possible so each chunk is self-contained. Set the retriever to return 4-6 chunks, not 20. Add a fallback branch: an IF node checks whether the agent's answer contains the "I don't have that" phrase and logs those questions to a Sheet - that sheet becomes your docs backlog.

When NOT to use it: If your knowledge base is under roughly 30 pages, skip the vector store entirely and stuff the docs into the prompt or a Google Sheets tool. RAG infrastructure for a tiny corpus is pure overhead. For the full architecture including reranking, evaluation, and embedding the chat widget on your site, see our n8n RAG agent deep dive.

What it does: Every form submission gets scored, enriched with a one-paragraph research summary, and routed within a minute: hot leads ping sales in Slack, warm leads get a nurture tag, junk gets archived. Speed-to-lead is the highest-ROI sales metric there is, and this template attacks it directly. Trigger: form webhook. Setup time: about 1 hour. Difficulty: beginner.

Node chain: A Webhook node receives the form payload (Typeform, Tally, your own site). A Set node normalizes fields. An HTTP Request node optionally pulls the company's homepage or an enrichment API. The AI Agent scores the lead with a structured Output Parser. An IF node splits on score: 70+ triggers a Slack message to the sales channel with the summary and a booking link, below that a Google Sheets or CRM node (HubSpot, Pipedrive) records the lead with the score and tag.

System prompt sketch:

You are a lead qualification analyst for [COMPANY],
which sells [OFFER] to [ICP].
Score this lead 0-100 based on:
- company size and industry fit (40 pts)
- stated problem matches our offer (40 pts)
- budget/urgency signals in the message (20 pts)
Free email domains with no company info: max 30.
Return JSON:
{"score": N, "tier": "hot|warm|cold",
 "reasoning": "2 sentences",
 "suggested_opener": "one personalized line"}

Customisation tips: Calibrate against history: run your last 50 leads through it, compare scores with what actually closed, and adjust the rubric weights. The "suggested_opener" field is a sleeper feature - sales reps actually use the agent output when it saves them the first line of an email.

When NOT to use it: Low-volume, high-touch pipelines (a few enterprise leads a month) where a founder reads every submission anyway. Also do not let this template auto-reply to leads; scoring and drafting are safe, unsupervised outbound is not.

What it does: For every email that needs a reply, the agent writes a draft in your voice and saves it in your Gmail drafts folder. You open your inbox, review, tweak, send. It is the highest adoption-rate template I deploy because the failure mode is harmless: a bad draft just gets deleted. Trigger: new email. Setup time: 45 minutes. Difficulty: beginner.

Node chain: Gmail Trigger on the inbox, an IF node filtering out newsletters and notifications (check for List-Unsubscribe headers and no-reply senders), then the AI Agent with a Gmail tool configured to fetch the last few messages in the thread for context. The output goes to a Gmail node in "Create Draft" operation, attached to the original thread ID so the draft appears inside the conversation.

System prompt sketch:

You draft email replies as [NAME], [ROLE] at [COMPANY].
Voice: [3 adjectives, e.g. warm, concise, direct].
Rules:
- Match the sender's formality level.
- Max 120 words unless the question demands more.
- Never commit to prices, dates, or legal terms;
  write "[CONFIRM]" as a placeholder instead.
- If the email needs no reply, output SKIP.
Here are 3 examples of my real replies: [EXAMPLES]

Customisation tips: The three real reply examples matter more than any adjective list - the model imitates concrete samples far better than abstract style instructions. Handle the SKIP output with an IF node so the workflow ends quietly. Add a Sheets log of drafted vs. sent to measure how often your drafts survive review; above 70% acceptance means the prompt is dialed in.

When NOT to use it: Legal, HR, or medical correspondence where a plausible-but-wrong draft could get sent in a hurry. And never flip this template from "create draft" to "send" for external email - the entire safety model of this pattern is the human review step.

What it does: Watches an inbox or Drive folder for invoice PDFs, extracts vendor, invoice number, line items, totals, tax, and due date into structured rows, and flags anything suspicious for human review. This replaces the worst kind of manual data entry. Trigger: email attachment or new file. Setup time: about 1.5 hours. Difficulty: intermediate.

Node chain: Gmail Trigger filtered to messages with attachments (or a Google Drive Trigger on an "Invoices" folder), an IF node checking the attachment is a PDF, an Extract from File node to pull the text (for scanned invoices, swap in a vision-capable model and pass the file directly), then the AI Agent with a strict Structured Output Parser. A validation IF node checks that line items sum to the stated total; matches append to Google Sheets or your accounting API via HTTP Request, mismatches go to a Slack review channel with the original file attached.

System prompt sketch:

Extract invoice data from the text below.
Return JSON exactly matching this schema:
{"vendor": "", "invoice_number": "",
 "invoice_date": "YYYY-MM-DD", "due_date": "YYYY-MM-DD",
 "currency": "", "line_items": [{"desc": "", "qty": 0,
 "unit_price": 0, "amount": 0}],
 "subtotal": 0, "tax": 0, "total": 0}
Rules: never guess missing values, use null.
Do not convert currencies. If the document is not
an invoice, return {"error": "not_an_invoice"}.

Customisation tips: The arithmetic validation node is the whole trick - LLM extraction is 95%+ accurate, and the checksum catches most of the remaining 5%. Add a duplicate check against existing invoice numbers before writing. Keep a folder of your 10 weirdest historical invoices as a regression test set every time you change the prompt.

When NOT to use it: If your vendors send fewer than 20 invoices a month, or if you need audited, compliance-grade capture - then use a dedicated OCR product and let n8n do the routing. Our invoice processing automation guide covers the full pipeline including approval chains.

What it does: A conversational agent that lives where your customers already are. It answers FAQs, checks order status via your API, and hands off to a human when it gets stuck. Telegram is the 30-minute version; WhatsApp adds Meta Business API setup and compliance rules but reaches a far bigger audience. Trigger: incoming message. Setup time: 2 hours for Telegram, closer to 4 for WhatsApp. Difficulty: intermediate.

Node chain (Telegram): Telegram Trigger, a Set node extracting chat ID and text, the AI Agent with Window Buffer Memory keyed on the chat ID, tools like an HTTP Request tool for your order API and a Google Sheets tool for FAQs, then a Telegram node sending the reply. For WhatsApp, replace the trigger with a Webhook node receiving Meta's payload, add an IF node filtering out status events (delivery receipts will otherwise trigger your agent), and send replies through an HTTP Request to the Graph API.

System prompt sketch:

You are the [COMPANY] assistant on [CHANNEL].
Keep replies under 3 short paragraphs. No markdown.
You can: answer FAQs (use the FAQ tool), check order
status (use the orders tool, ask for the order number
if missing).
If the user is angry, asks for a human, or you fail
twice, start your reply with HANDOFF_REQUIRED plus
a one-line summary for the human agent.

Customisation tips: The HANDOFF_REQUIRED sentinel plus an IF node routing to Slack is the simplest reliable escalation pattern. Store a "human mode" flag per chat ID in a Sheet so the bot stops intercepting messages after handoff. Keep the memory window at 8-12 messages; messaging conversations are transactional and longer windows just burn tokens.

When NOT to use it: Outbound marketing on WhatsApp - the 24-hour window and template approval rules make agent-style free-form outbound a fast way to get your number restricted. For the complete WhatsApp build including webhook verification, media handling, and compliance, follow our step-by-step WhatsApp AI agent with n8n tutorial.

What it does: Every meeting transcript that lands in a Drive folder gets turned into a structured summary: decisions made, action items with owners and deadlines, open questions, and a three-sentence TLDR, posted to Slack and archived in Notion or Sheets within minutes of the call ending. Trigger: new file in a folder. Setup time: about 1 hour. Difficulty: beginner.

Node chain: Google Drive Trigger watching your recordings/transcripts folder (most meeting tools like Fathom, Fireflies, or Google Meet can auto-export transcripts there), a Google Drive node downloading the file, Extract from File for the text, then the AI Agent with a structured Output Parser. The output fans out: a Slack node posts the summary to the relevant channel, a Notion or Google Sheets node archives it, and an optional loop creates one task per action item via HTTP Request to your task manager.

System prompt sketch:

Summarize this meeting transcript.
Return JSON:
{"tldr": "3 sentences max",
 "decisions": ["..."],
 "action_items": [{"task": "", "owner": "",
   "due": "YYYY-MM-DD or null"}],
 "open_questions": ["..."]}
Only include action items with a clear owner stated
in the transcript. Do not invent owners or deadlines.
Attribute decisions to the person who made them.

Customisation tips: The "do not invent owners" rule is critical - without it, models cheerfully assign tasks to whoever spoke last. For transcripts over ~30k tokens, add a chunked map-reduce step or use a long-context model. Route summaries to different Slack channels based on calendar metadata (standup vs. client call) with a Switch node.

When NOT to use it: Sensitive meetings (HR, legal, M&A) unless you are running a self-hosted model, and any org where transcripts contain data your LLM provider agreement does not cover. Our meeting notes automation guide covers the transcription layer and privacy options in detail.

What it does: Pulls new mentions, comments, and DMs from your social accounts every 30 minutes, classifies each (question, praise, complaint, spam, lead), drafts an on-brand reply, and sends the batch to a Slack approval queue. A human taps approve and the reply posts. You get near-real-time engagement without giving an LLM the keys to your public voice. Trigger: schedule. Setup time: about 1.5 hours. Difficulty: intermediate.

Node chain: A Schedule Trigger every 30 minutes, HTTP Request nodes to each platform API (X, LinkedIn, Instagram via Meta Graph) fetching items since the last run (store the cursor in a Google Sheets state row), a Loop Over Items node, then the AI Agent classifying and drafting. An IF node drops spam. The rest go to Slack as messages with approve/edit buttons (Slack interactive messages hitting a second Webhook workflow), and approved replies post via HTTP Request.

System prompt sketch:

You draft social replies for [BRAND].
Voice: [e.g. helpful, playful, never defensive].
Classify: question | praise | complaint | spam | lead.
Rules:
- Complaints: acknowledge, apologize once, move to DM.
- Never argue, never mention competitors.
- Questions you cannot answer from the brand facts
  below: draft "flagging this for the team" reply.
- Max 220 characters for X replies.
Brand facts: [PASTE KEY FACTS]

Customisation tips: The approval queue is the feature, not a limitation - keep it even after trust builds, just add auto-approve for the "praise" category (a thank-you reply is low risk). Log approved vs. edited vs. rejected drafts; the edit diff is free training data for your prompt.

When NOT to use it: Crisis situations or regulated industries (finance, health) where every public statement needs compliance review, and brands whose engagement volume is under 10 interactions a day. The full architecture, including platform API quirks, is in our social media reply automation guide.

What it does: Whenever a new contact hits your CRM with just a name and email, the agent researches the company, fills in industry, size, tech stack, and a two-line "why they might buy" note, and writes it all back to the CRM record. Sales opens the record and it is already warm. Trigger: new CRM contact webhook. Setup time: about 1.5 hours. Difficulty: intermediate.

Node chain: A Webhook node receiving the CRM's new-contact event (HubSpot, Pipedrive, and Attio all support outbound webhooks), a Set node extracting the email domain, an IF node skipping free email providers, then HTTP Request nodes fetching the company homepage and optionally an enrichment API. The AI Agent synthesizes everything into structured fields via an Output Parser, and a HubSpot (or generic HTTP Request) node updates the contact. Failures append to a Google Sheets "needs manual enrichment" tab.

System prompt sketch:

Research this company from the provided homepage text
and enrichment data. We sell [OFFER] to [ICP].
Return JSON:
{"industry": "", "employee_range": "1-10|11-50|51-200|200+",
 "summary": "what they do, 1 sentence",
 "buying_signal": "why they might need us, 2 sentences,
  or null if no plausible fit",
 "confidence": "high|medium|low"}
Base everything on the provided text. If the data is
thin, say so via low confidence. Never fabricate.

Customisation tips: Write the confidence field into the CRM too and teach sales to distrust "low" rows. Cache results by domain in a Sheet so five contacts from the same company cost one enrichment, not five. Pair this with the lead qualification template above and you have a full inbound pipeline built from two small workflows.

When NOT to use it: When you already pay for Clay or Apollo enrichment at scale - do not rebuild their crawlers, just use n8n to route their output. Also mind GDPR: enriching EU persons (rather than companies) has legal implications, so keep enrichment at the company level.

What it does: Every morning at 7:30, one Slack message (or email) summarizes everything you would otherwise check across five tabs: yesterday's sales and signups, support ticket volume and hot issues, ad spend, and the three emails in your inbox that actually need you. It is the least glamorous template here and the one clients refuse to give up. Trigger: schedule. Setup time: about 1 hour. Difficulty: beginner.

Node chain: A Schedule Trigger (cron: 30 7 * * 1-5), then parallel data-gathering branches: Google Sheets reads for metrics, HTTP Request nodes to Stripe and your analytics API, a Gmail node fetching unread messages, and optionally your support tool's API. A Merge node combines the branches, the AI Agent writes the digest, and a Slack node posts it (or Gmail sends it). No memory node needed; each run is stateless.

System prompt sketch:

Write a morning briefing for the [COMPANY] team from
the JSON data provided.
Format:
1. Headline number vs. same day last week, with the
   percentage change.
2. Three bullets: what changed and the likely why.
3. "Needs attention": max 3 items, only if genuinely
   anomalous (>20% deviation or explicit errors).
4. Inbox: list emails needing a reply, one line each.
Tone: dry, factual. No motivational filler.
If a data source is missing, say "source unavailable",
never estimate.

Customisation tips: "Never estimate" is the load-bearing line - a digest that silently invents numbers when an API fails is worse than no digest. Add an error branch per data source that injects an explicit failure marker into the merged payload. Start with three data sources maximum; digests die from bloat, not from missing data.

When NOT to use it: If your metrics live in a BI tool with good scheduled reports already, the AI layer only adds value for the narrative and inbox parts. And do not put the digest in a channel nobody reads - deliver it where the decision-makers already look at 8am.

Importing a template takes 30 seconds. Making it yours takes an afternoon. Here is the process I use on every client engagement.

Importing: From the n8n template library, click "Use for free" and choose your instance. For JSON files (like the ones in our downloadable template pack), open a new workflow in n8n and either paste the JSON directly onto the canvas with Ctrl+V or use the menu: Workflow, Import from File. All node positions, settings, and connections come across; credentials do not, by design.

The adaptation sequence:

1. Reconnect credentials first. Every node with a red warning needs a credential. Do this before touching anything else, because you cannot test half-configured workflows meaningfully.

2. Pin sample data and walk the chain. Trigger the workflow once with real data (or use n8n's "pin data" feature on the trigger node), then execute node by node with "Execute step." Read the actual JSON at each hop. Most template failures are field-path mismatches: the template expects {{ $json.email }} and your form sends {{ $json.fields.email }}.

3. Rewrite the system prompt. Replace every placeholder, add your taxonomy, and paste in 3-5 real examples from your own data. This is where a generic template becomes an agent that sounds like your company.

4. Swap models deliberately. Templates often ship wired to a specific model. Classification and extraction run fine on cheap fast models; customer-facing generation and multi-step tool use deserve a stronger one. Estimate the monthly cost of your volume with our n8n workflow cost calculator before you commit, and if you are unsure which model tier fits which template, the calculator's presets map to the ten patterns in this post.

5. Test the unhappy paths. Send it an empty message, a 40-page PDF, an emoji-only reply, a non-English email. Every input that breaks a node needs either handling or an explicit error route.

If you are still choosing a platform rather than a template, n8n's AI Agent node is the reason these patterns stay compact; our comparison of n8n against Make covers that decision in depth.

A template that works in testing is maybe 60% of a production system. Before pointing real traffic at any of these workflows, run this checklist. It is short because it is the distilled version of every incident I have debugged.

1. Error workflow attached. In workflow settings, set an Error Workflow that catches any failed execution and posts the workflow name, error, and execution URL to a Slack channel. An agent failing silently for three days is the most common production incident, and this single setting prevents it.

2. Timeouts and retries on every external call. Set "Retry on Fail" (2-3 attempts, exponential-ish waits) on HTTP Request and LLM nodes. Set a workflow timeout so a hung API call does not pile up executions.

3. Cost caps. Set hard spending limits in your LLM provider dashboard, and log token usage per execution to a Sheet. A retry loop against a long document can burn a month's budget overnight; the cap turns a disaster into an alert.

4. Structured output validation. Never trust that the model returned valid JSON. Use the Structured Output Parser with auto-fix enabled, and add an IF node that verifies required fields exist before writing to any system of record.

5. Idempotency. Webhooks get delivered twice; polling triggers overlap. Deduplicate on a natural key (message ID, invoice number, contact email) against your log sheet before processing.

6. Human fallback tested, not just built. Actually trigger the escalation path and confirm a human sees it within your target SLA. An escalation branch posting to an archived Slack channel is worse than none, because everyone believes it works.

7. Queue mode for volume. Self-hosting with more than a few hundred executions a day? Run n8n with EXECUTIONS_MODE=queue and Redis so concurrent webhooks do not drop.

8. A weekly review ritual. Fifteen minutes reading the log sheet: what did the agent get wrong, what got escalated, what should move into the prompt as a new rule. Agents improve on this loop or not at all.

The deeper reasoning behind these practices - architecture, evaluation, and scaling patterns - is in our complete guide to building AI agents with n8n.

Reading about templates is planning. Importing one and pointing it at your real inbox is progress. Here is the fastest path from this post to a running agent:

Download the pack. All 10 workflows in this post are available as importable JSON in our free n8n AI agent template pack, with the system prompts pre-filled with placeholders and the fallback branches already wired. Pick the one closest to your most annoying manual task, import it, and follow the adaptation sequence above. Most people have their first agent running the same afternoon.

Learn the underlying skill. Templates get you to a working v1, but the teams that get real ROI are the ones who can modify, debug, and extend agents themselves. Our n8n AI Agents course teaches exactly that: the AI Agent node internals, tool design, memory strategies, evaluation, and the production patterns from the hardening checklist, built through real projects rather than toy demos.

Or have us build it with you. If you have a workflow that does not fit any template - multi-system integrations, compliance requirements, high-volume pipelines - that is the work we do every week. Work with us and we will scope it in one call, honestly, including telling you when a simple template is all you actually need.

Start with one template. Ship it this week. The second one takes half the time, and by the third you will be writing your own.