You connect an AI agent to n8n by dropping the native AI Agent node onto your canvas, attaching an LLM, and supplying it with tools—no middleware, no custom webhook wrappers, no separate orchestration service. It lives inside your workflows so memory, branching, and human-in-the-loop steps are first-class citizens, not bolted-on afterthoughts. We wired one up to process a YouTube link into a personalized email, and the toughest parts weren’t the model—they were the credential scoping and the moment the agent decided to stop mid-loop.

Here’s the exact sequence that works, plus the gotchas you’ll actually hit.

How to Connect an AI Agent to n8n

The AI Agent node is the bridge between an LLM and the rest of your n8n automation. You drop it in, choose a model, and give it tools—child nodes that the model can call as functions. The agent then runs a tool-calling loop: it decides what to execute, sees the result, and decides whether to call another tool or stop and produce a final answer.

A common mistake is treating the Agent node as a one-shot prompt wrapper. It’s not. It’s a runtime that iterates. If you only need a single template fill, use the Basic LLM Chain node instead. Reach for the Agent node when the model needs to poke multiple services or branches based on uncertain input.

Step 1: Anchor the workflow with a trigger

Everything in n8n needs a trigger. For testing, the easiest is a Chat Trigger or Manual Trigger. The Chat Trigger gives you a webhook URL you can POST to, which is handy if you’re eventually calling this from a frontend or Slack.

Practical detail we learned: put a Set node right after the trigger to normalize the input. Our YouTube-to-email workflow often receives a full chat message like “Hey, can you extract key points from https://youtube.com/…” — the raw body has nested fields. Extracting chatInput into a clean youtubeUrl field here keeps the agent from choking on unexpected JSON structure when you pass it the schema later.

Step 2: Drop in the AI Agent node and pick a model

Search for AI Agent in the node panel and drag it in. Connect it to your trigger. Under Agent, pick Tools Agent. The other options (ReAct Agent, OpenAI Functions Agent) are for specific legacy or model-calling formats; Tools Agent handles both OpenAI’s tool-calling and Anthropic’s tool-use with a consistent interface, so start there.

Under LLM Model, you’ll need a credential. If you’re using OpenAI, create an OpenAI API credential with your key. Scoping tip that bit us: n8n credentials defaults can inadvertently lock the credential to a single workflow. Double-check that the credential isn’t scoped to a different workflow or you’ll spend 20 minutes wondering why the Agent node says “No credential” despite creating one seconds ago. Keep it available to all workflows during prototyping, then lock it down later.

Step 3: Set system message and prompt

Use a descriptive system message that tells the agent what it can do, not just who it is. Ours reads:

“You are a content extraction agent. You have access to tools that can fetch YouTube transcripts, summarize them, and create draft emails. Use the tools in sequence when you receive a YouTube URL.”

This is more actionable than “You are a helpful assistant.” The agent gets a tool list from its child nodes automatically; the system message should connect intent (“a YouTube URL arrives”) to the available tool chain.

Step 4: Attach tools as child nodes

The agent’s power is that it calls child nodes as functions. Connect whatever services the agent needs directly below the Agent node. In our n8n automation pipeline:

1. HTTP Request node — wraps the YouTube Transcript API (or a RapidAPI endpoint for transcripts). We pass videoId extracted from the URL. The node returns raw transcript chunks.
2. OpenAI Chat Model node — summarizes the transcript into five bullet points. This is a separate LLM call, not the agent’s own model. Giving the agent a dedicated summarization tool lets you swap the summarizer to a cheaper model independent of the agent brain.
3. Gmail node — drafts an email with the bullet points and sends it. The agent’s final output schema includes recipient, subject, and bullets. The Gmail tool maps those to the actual email fields.

When the Agent node runs, it sees these three child nodes as tool definitions and can call them in sequence automatically—no hardcoded branching required.

Step 5: Set the output schema

Under the Agent node’s Response section, switch output to As Object (Structured Output) and define a JSON schema. This is how you connect an AI agent to n8n downstream logic without parsing markdown. Our schema for the email drafter:

{
  "type": "object",
  "properties": {
    "recipient": { "type": "string" },
    "subject": { "type": "string" },
    "body": { "type": "string" }
  },
  "required": ["recipient", "subject", "body"]
}

When the output schema is set, the agent cannot end its loop without producing a valid object. This eliminated the “agent returns a friendly OK message instead of data” problem we hit early on.

Step 6: Attach memory (so it knows what it already did)

Without memory, every agent turn is amnesiac. Attach a Window Buffer Memory node as another child. Configure it with:

• Session Key: chatInput (or whatever your trigger posts) so conversations don’t cross streams.
• Context Window Length: 10 (keeps token burn manageable).

The memory node re-injects the last N exchanges into the agent’s prompt automatically. This is critical for multi-tool sequences: when the agent fetches a transcript then needs to summarize it, without memory it has no idea the transcript fetch succeeded unless you pass that data explicitly through the chain. Memory handles it.

The Loop That Bites: What Actually Happens at Runtime

When you hit Execute, the agent doesn’t just run once top-to-bottom. It enters a tool-calling loop:

1. The LLM receives your system prompt, user message, and tool definitions.
2. It decides whether to call a tool or produce a final answer. If it calls a tool, n8n executes the child node inline and feeds the result back.
3. The LLM gets the tool’s output plus the entire memory buffer and decides again: call another tool, or stop?
4. This repeats until either the output schema is satisfied or the maximum iterations are hit.

The gotcha we hit: the agent correctly fetched the transcript, successfully summarized it, called the Gmail draft tool… and then didn’t stop. It attempted one more iteration, re-called the summarizer tool with already-summarized text, and timed out at 20 iterations. The fix was two-fold: tighten the system message to say “After calling the email draft tool, output the final object immediately,” and enable Require Specific Output to force the loop to close against the schema. Both settings are in the Agent node’s configuration.

Why Not Roll Your Own Loop?

You could theoretically use an HTTP Request node to call the OpenAI API directly, parse its tool-call responses, and route them back with Switch nodes. That path turns into a maintenance disaster when Anthropic changes its tool format or you add a third model. The Agent node abstracts the provider differences behind a single tool-calling interface and handles the iteration loop, memory injection, and stop-condition—all natively inside your workflow. For a team offering AI automation agency services, this cuts onboarding and debugging time per workflow significantly.

Beyond the Basics: When to Pull the Plug on the Agent

Agents are non-deterministic loops. In production, always place guardrails outside the Agent node:

• Timeout: Add a Wait node or a workflow-level timeout so a runaway loop doesn’t consume execution minutes.
• Human review: After drafting an email, route the output to a Slack approval step via the built-in human-in-the-loop pattern. That way, the agent proposes, a human disposes—and nothing inaccurate goes to a client.
• Cost tracking: The Agent node exposes token usage metadata that you can log to a database. Sum it across runs to watch for model-level cost spikes.

FAQ

Can I use local models like Ollama with the n8n AI Agent node?

Yes. The AI Agent node connects to any LLM sub-node, including the Ollama LLM node. Point it at your local model endpoint, enable JSON mode if your model supports it, and use the same Tools Agent configuration. Be aware that smaller local models may struggle with multi-turn tool calling loops—you’ll likely need a model that reliably follows function-calling syntax.

What happens if the agent calls a tool that errors out?

By default, the error message is fed back to the agent as the tool’s output, and it will attempt to self-correct (often by calling the tool again with adjusted parameters). This can be useful—but if the API is genuinely unreachable, it can also burn iterations. Set a tight Maximum Iterations value and consider adding an Error Trigger workflow that catches agent-timeout events and alerts you.

Do I need separate API keys for every tool the agent calls?

You need credentials for whatever services the child nodes use (Gmail OAuth, YouTube API key, etc.), but those are configured on the individual child nodes—not the Agent node itself. The Agent node only needs the LLM credential. Each child node manages its own auth independently, so the agent security model is as strong as your weakest child-node credential.