n8n vs LangGraph: Automation Platform or Agent Framework?

n8n vs LangGraph is not a like-for-like choice: n8n is a workflow automation platform you configure on a canvas, and LangGraph is a code library for building stateful AI agents. Use n8n when the job is mostly triggers, app integrations and a contained AI step; use LangGraph when the agent's own control flow is the hard part; and use both when you need the two at once, with n8n calling a LangGraph service over HTTP.

A documentation-based comparison, not a benchmark. Checked on 11 October 2026 against the LangGraph docs (overview, persistence, interrupts, local server), the Agent Server docs and its OpenAPI specification, the LangGraph releases and licence, LangSmith pricing, n8n's docs on LangChain in n8n, the AI Agent node and human review for tools, the n8n pricing page, and the source of n8n 2.42.6.

The two get compared because both can produce "an AI agent". They get there from opposite ends. n8n starts with the plumbing, a webhook, a CRM, a spreadsheet, and lets you drop an agent into it. LangGraph starts with the agent's reasoning and leaves the plumbing to you. This page gives you a decision tree, the head-to-head facts, and a working example of the hybrid. It belongs to our n8n hub; for what makes a workflow agentic in the first place, start with agentic AI workflows.

n8n or LangGraph for AI agents: the decision tree

Answer the questions in order and stop at the first one that settles it. The first two send most projects to n8n. The next three are the real reasons to pick up a framework.

n8n vs LangGraph head to head

Two rows carry most of the weight. State: in n8n an agent remembers through a memory sub-node that stores chat history, while in LangGraph the state is whatever structure you define, saved after every step. Agent loop: n8n gives you one well-built loop, and LangGraph gives you the parts to build any loop.

What n8n gives an agent

In n8n an agent is a node. You connect a chat model, optional memory and at least one tool to the AI Agent node, and it decides which tools to call. Since n8n 1.82 every AI Agent node works as a Tools Agent; the older agent types are deprecated and the docs say version 1 of the node goes in n8n 3.0. n8n also has a separate Agents feature, where an agent is built from a model, instructions and tools without a canvas; n8n labels it Preview, so this comparison uses the AI Agent node.

• Tools from the app library. App nodes, an HTTP request, another workflow or an MCP server can all be attached as tools, using credentials you have already stored.
• Memory as a sub-node. Simple Memory, Postgres or Redis chat memory keep the conversation. Our n8n AI agent memory guide builds all three tiers.
• Human review for tools. A tool can require approval through Chat, Slack or another channel before it runs. The reviewer can approve or deny.
• Everything around the agent. Triggers, retries, error workflows and delivery to the apps where people work.

The limits follow from the same design. The loop lives inside the node, so you set a system message and a maximum number of iterations, not the path. Memory is chat history, not arbitrary state. Chains cannot use memory at all. And a multi-step cycle such as "draft, check, redo until good" has to be drawn with If and loop nodes around the agent, which works for one cycle and gets hard to read by the third.

Price, checked October 2026: the self-hosted Community Edition is free; Cloud Starter is €20 a month billed annually for 2,500 executions, and its feature list includes agents, MCP and AI nodes. One chat turn or one webhook call is one execution. Model tokens are billed by your model provider on top.

What LangGraph gives an agent

LangGraph's docs describe it as "a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents". You define a state type, write node functions that read and update it, and connect them with edges, including conditional edges that route on the state. It is MIT-licensed, ships for Python and TypeScript, and reached version 1.2.14 on 6 October 2026.

• Any control flow. Cycles, branches, parallel workers and sub-graphs are first-class, and deterministic steps mix with model-driven ones in the same graph.
• Persistence. A checkpointer saves the state of each thread at every step. An in-memory saver is for tests; the docs point to Postgres or SQLite for anything that must survive a restart.
• Interrupts. Calling interrupt() inside a node saves the state and waits, indefinitely, until you resume the same thread with a value.
• A server when you want one. Agent Server wraps your graphs in an HTTP API with threads, background runs, cron jobs and completion webhooks, and handles persistence itself.

What it does not give you is anything outside the agent. There is no Gmail node and no credential store. Every integration is a function you write or a LangChain package you add. The docs are candid that it is "very low-level", and they send people who want a ready-made tool-calling loop to LangChain's higher-level agents instead.

n8n vs LangChain: is n8n the same thing underneath?

Partly. The n8n docs state that its AI nodes "implement LangChain's JavaScript framework", and they publish a table mapping LangChain concepts to nodes: chains and agents become root nodes, while models, memory, tools, retrievers and output parsers become sub-nodes. So an n8n AI Agent is a LangChain agent with a visual wrapper.

That does not make n8n a LangGraph front end. In LangChain's own description, LangChain is the agent framework and LangGraph is the orchestration runtime beneath it. n8n exposes the first layer. Custom graph state, checkpoints you can rewind and interrupts in the middle of a node are LangGraph features with no n8n node. The escape hatch inside n8n is the LangChain Code node, which runs LangChain JavaScript you write yourself; by the time you need it often, a separate service is usually cleaner.

The hybrid pattern: n8n triggers, LangGraph thinks

The pattern that holds up is a split by strength. n8n owns everything that touches other systems. LangGraph owns the reasoning. They meet at one HTTP call.

Here is a working example. The graph is the evaluator and optimizer pattern from the LangGraph docs, pointed at support tickets: one model call writes a reply, a second grades it, and a conditional edge sends it back for another pass, three at most.

from typing import Literal
from typing_extensions import TypedDict
from pydantic import BaseModel, Field
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph, START, END

llm = ChatAnthropic(model="claude-sonnet-5-5")


class State(TypedDict):
    ticket: str
    draft: str
    feedback: str
    verdict: str
    revisions: int


class Review(BaseModel):
    verdict: Literal["send", "revise"] = Field(
        description="send if the reply fully answers the ticket, otherwise revise"
    )
    feedback: str = Field(description="What to fix when the verdict is revise")


reviewer = llm.with_structured_output(Review)


def write_draft(state: State):
    prompt = f"Write a short, polite reply to this support ticket:\n{state['ticket']}"
    if state.get("feedback"):
        prompt += f"\nFix this in your previous draft: {state['feedback']}"
    msg = llm.invoke(prompt)
    return {"draft": msg.content, "revisions": state.get("revisions", 0) + 1}


def review_draft(state: State):
    review = reviewer.invoke(
        f"Ticket:\n{state['ticket']}\n\nDraft reply:\n{state['draft']}"
    )
    return {"verdict": review.verdict, "feedback": review.feedback}


def next_step(state: State):
    if state["verdict"] == "send" or state["revisions"] >= 3:
        return "done"
    return "retry"


builder = StateGraph(State)
builder.add_node("write_draft", write_draft)
builder.add_node("review_draft", review_draft)
builder.add_edge(START, "write_draft")
builder.add_edge("write_draft", "review_draft")
builder.add_conditional_edges(
    "review_draft", next_step, {"done": END, "retry": "write_draft"}
)
graph = builder.compile()

Save it as src/agent/graph.py in a project made with langgraph new, and name the graph in langgraph.json:

{
  "dependencies": [
    "."
  ],
  "graphs": {
    "agent": "./src/agent/graph.py:graph"
  },
  "env": "./.env"
}

langgraph dev then starts Agent Server on http://127.0.0.1:2024. The docs describe this mode as in-memory and meant for development. On the n8n side, three nodes are enough: paste this JSON onto an empty canvas.

{
  "name": "Ticket in, LangGraph draft out",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "ticket-draft",
        "responseMode": "lastNode",
        "options": {}
      },
      "id": "a7c1e2d4-0001-4b6f-9c3a-000000000001",
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2.1,
      "position": [
        0,
        0
      ],
      "webhookId": "a7c1e2d4-1000-4b6f-9c3a-000000000010"
    },
    {
      "parameters": {
        "method": "POST",
        "url": "http://127.0.0.1:2024/runs/wait",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={\n  \"assistant_id\": \"agent\",\n  \"input\": { \"ticket\": {{ JSON.stringify($json.body.ticket) }} }\n}",
        "options": {
          "timeout": 120000
        }
      },
      "id": "a7c1e2d4-0002-4b6f-9c3a-000000000002",
      "name": "Run LangGraph agent",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        240,
        0
      ]
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "a7c1e2d4-2000-4b6f-9c3a-000000000020",
              "name": "draft",
              "value": "={{ $json.draft }}",
              "type": "string"
            },
            {
              "id": "a7c1e2d4-2000-4b6f-9c3a-000000000021",
              "name": "verdict",
              "value": "={{ $json.verdict }}",
              "type": "string"
            },
            {
              "id": "a7c1e2d4-2000-4b6f-9c3a-000000000022",
              "name": "revisions",
              "value": "={{ $json.revisions }}",
              "type": "number"
            }
          ]
        },
        "options": {}
      },
      "id": "a7c1e2d4-0003-4b6f-9c3a-000000000003",
      "name": "Shape reply",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        480,
        0
      ]
    }
  ],
  "connections": {
    "Webhook": {
      "main": [
        [
          {
            "node": "Run LangGraph agent",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Run LangGraph agent": {
      "main": [
        [
          {
            "node": "Shape reply",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

What was checked: the Python follows the syntax of the LangGraph 1.x docs, the endpoint and body fields come from the Agent Server OpenAPI specification, and the n8n node types, versions and parameter names come from the n8n 2.42.6 source. Neither file was executed for this article, so treat the first run as a test.

Three production notes. A deployment on LangSmith expects a LangSmith API key in the x-api-key header, so store it as a Header Auth credential in n8n instead of typing it into the node. A self-hosted Agent Server has no authentication by default, per the docs, so do not expose it without your own. And give the n8n workflow an error workflow before it goes live; our Error Trigger guide has one ready to import.

What each side costs

Neither tool is the expensive part. The table lists what each piece costs to run, from the vendors' published prices.

One thing the hybrid does to an n8n bill is hide work: a graph that calls the model eight times still counts as a single n8n execution, because n8n only sees one HTTP request. The tokens do not hide. Our LLM API pricing comparison has current per-token rates.

Alternatives between the two

• Visual agent builders. Langflow sits closer to LangGraph's concepts while staying on a canvas. Our AI agent builder comparison covers it next to n8n, and notes what happened to Flowise.
• LangChain's prebuilt agents. If you want code but not graph design, the LangGraph docs themselves recommend starting there.
• A plain SDK loop. A model API with tool use and a while loop covers many agents without a framework.
• Other workflow platforms. If the n8n half is the part you are unsure of, n8n alternatives compares twelve.

That third option is where our own material sits. The AI SaaS Builder program has no n8n or LangGraph lessons; it teaches the layer both are built on, with the Claude API for tool use and structured output, MCP servers, a research agent built step by step, and the Supabase, Vercel and Stripe work that turns an agent into something people pay for.

n8n vs LangGraph: FAQ