Paperclip vs n8n: agentic-native automation
n8n automates work the pre-agentic way: you wire every step by hand. Paperclip is agentic-native: you delegate the goal and AI agents do the rest.
Both Paperclip and n8n are open and self-hostable, both let AI do work for you, and both attract people tired of doing repetitive work by hand. So they get compared a lot. They are after the same prize: get the work done without you doing every step. The difference is how, and that difference is really a difference of era.
n8n was built before agents were good. So it automates the way you had to back then: you draw the whole process yourself, step by step, and AI is one box in the diagram. Paperclip was built for the moment we are in now, where an agent can be handed a goal and work out the steps. You hire the agents, set the goal and the budget, and they organize the work themselves.
That is the whole post in two sentences. The rest explains why it matters.
Pre-agentic and agentic-native
n8n is pre-agentic. Its core idea is a flowchart: a trigger fires, data flows from node to node along wires you connect, and every decision is one you encoded in advance with an IF or a Switch. The platform is excellent at this, and it added AI later as a node you can drop into the flow. But the engine underneath assumes you already know every step. If you cannot draw it, n8n cannot run it.
Paperclip is agentic-native. Its core idea is a company: a goal, a budget, an org chart, and a board of tickets. You do not draw the steps. You state the outcome and the agents decide how to reach it, breaking the goal into tickets, handing work to each other, and coming back when they need a decision. The autonomy is the foundation, not a node bolted onto a flowchart.
This is the real choice. Not “automation tool A vs automation tool B,” but “encode every step yourself” vs “delegate the goal.” For anything where the steps are obvious and fixed forever, encoding them is fine. For everything that involves judgment, changes week to week, or you simply have not mapped out yet, delegating wins, and that is most real work.
Two ways to model the same work
Say you want a weekly competitor report. Same goal, two very different builds.
In n8n you build the procedure. You wire a schedule trigger, then nodes to pull each source, an AI node to summarize, branches for the cases you anticipated, a node to format the result, and a node to send it. It runs that exact path every week. If a competitor launches something your flowchart did not account for, the report misses it, because the flow only does what you drew. You are the analyst; n8n is your hands.
In Paperclip you hire a researcher. You create a recurring routine with the goal “publish a competitor report every Monday,” and an agent owns it. Each week it decides what to look at, notices the thing you would not have thought to wire in, drafts the report, and waits for your yes or no. When the market shifts, you do not rebuild a flowchart. The agent adapts, because judgment is its job. You are the editor-in-chief; the agent is the analyst.
Both produce a report. One needed you to predict every step in advance. The other needed you to state what you wanted. As the work gets less predictable, the gap between those two approaches gets wider, and always in the same direction.
See it side by side
Enough theory. Here is the same work built in both tools. The n8n shots are the real editor; the Paperclip shots are the real product, themed in our colors. Four jobs, two ways to get them done.
A weekly competitor report
In n8n you wire the steps yourself: a Monday trigger, a fetch, an AI summarizer, an email. In Paperclip you hand a research agent a standing job, and it reruns itself every week and waits for your sign-off.
Shipping a software feature
This is where the two part ways. n8n can ask an AI to suggest a change and file a GitHub issue through an HTTP call, but it cannot build the thing. A Paperclip engineer owns the ticket, breaks it into sub-tasks, and brings it to review.
A weekly newsletter
n8n is a pipeline: gather links, draft, format, send, exactly as drawn. Paperclip runs a content team working the newsletter as tickets that move across a board.
Support triage
n8n routes each message through branches you defined in advance. Paperclip gives support to a team: a lead who owns the queue and a specialist who clears it.
n8n added AI. Paperclip is made of agents.
This is the part most comparisons get wrong, and it is the heart of the matter.
n8n has genuine AI features. It ships an AI Agent node built on LangChain, with pluggable models (OpenAI, Anthropic, Gemini, local models through Ollama), tools, memory, and full retrieval-augmented generation through vector stores like Qdrant and pgvector. It speaks the Model Context Protocol. You can build a capable RAG chatbot in an afternoon.
But the autonomy lives inside that one node. The AI Agent node runs a small reasoning loop: it picks which of its attached tools to call and when to stop. Everything around it, what triggers it, what happens before and after, the branching and retries, is still a flowchart a person designed and maintains. The AI is a smart step inside a pre-agentic machine. It cannot own a goal that spans days, spawn helpers, or reorganize its own work, because the machine it lives in was not built for that.
Paperclip is built the other way up. Agents are the primitive, not a node. They run on heartbeats: they wake on a schedule, a mention, a new assignment, or a routine, and resume the task with the memory of last time. They decompose goals into tickets without being told the steps, delegate down the reporting line, and keep going until the goal is met or they hit a limit you set. A manager agent, say a CTO, reprioritizes and reassigns work on its own heartbeat. The autonomy persists across time and across a team, because that is the whole architecture, not a feature inside one box.
n8n bolts an agent onto a workflow. In Paperclip, the agents are the workflow, and they write it as they go.
A control plane, not an engine
There is a quieter design difference that follows from being agent-first. n8n runs your AI inside its own engine: the model is a sub-node and the execution happens in n8n’s workers.
Paperclip is a control plane, not an execution engine. It does not run the model itself. Agents run wherever they run, a Claude Code session, an OpenCode or Codex process, a Gemini or Grok runtime, a script, or an HTTP webhook, and they report home to check out tickets, post updates, and record results. Paperclip owns the part that makes a team trustworthy: who holds which ticket, session memory across wakeups, budgets with hard spend limits, approvals on the decisions that matter, and a full audit log of everything that happened. You bring your own keys and your own runtimes, and Paperclip is the company they all answer to. That is the layer you actually need once more than one agent is working for you.
Architecture and self-hosting
Both are TypeScript and both self-host, but the shape differs.
| n8n | Paperclip | |
|---|---|---|
| Core idea | A flowchart you draw | A company of agents you hire |
| Paradigm | Pre-agentic, AI added as a node | Agentic-native, agents are the primitive |
| Who decides the steps | You, in advance | The agents, as they work |
| Runtime | Runs models in its own engine | Control plane; agents run elsewhere and report back |
| Stack | Node.js, Vue, Postgres or SQLite | Node.js, React, Postgres (embedded for local dev) |
| Production scaling | Queue mode: Redis plus worker replicas | Heartbeat engine plus your agent runtimes |
| License | Fair-code (Sustainable Use License) | MIT |
| Hosted option | n8n Cloud, priced per execution | Managed and EU-hosted by Paperclip.inc |
| What it covers | Deterministic workflows | Those same workflows, plus open-ended goals |
n8n at production scale is real infrastructure: Postgres plus Redis in queue mode, with separate main, worker, and webhook processes you scale yourself, or n8n Cloud billed per execution. Paperclip self-hosts as a Node app with Postgres, ships an embedded Postgres for zero-setup local dev, and a Docker image with the common agent CLIs preinstalled. Because agents run as separate runtimes that report back, scaling mostly means running more agents.
And if you would rather not run any of it, Paperclip.inc is the managed, EU-hosted version of Paperclip. You get the agentic-native model with none of the operations, and your data stays entirely in Europe. More on that at the end.
Licensing: only one of them is open source
People call both projects “open source,” but only one of them is.
Paperclip is MIT licensed: run it, fork it, embed it, build a commercial product on it, no strings.
n8n is fair-code, under its own Sustainable Use License. That is source-available, not OSI open source. You can self-host it for your own business for free, and you can sell consulting around it. What you cannot do without a separate commercial license is host n8n for others, or resell or embed it as the core of a paid product. Some enterprise features sit behind a separate license too. For internal use this rarely bites; if you ever want to build on the platform, it is the whole story, and MIT is the freer ground.
Why Paperclip supersedes n8n
A fixed workflow is just a special case of agent work: the one where you have already decided every step. Anything an n8n node does, an agent can do. It can call any API or run any script (Paperclip ships generic process and HTTP runtimes for exactly that), and routines give it the same scheduled and webhook triggers a workflow starts from. So a deterministic pipeline is not something n8n can do and Paperclip cannot. It is the simplest thing Paperclip does, the floor and not the ceiling.
What sits above that floor is the whole point. When work needs judgment, changes week to week, or you have not mapped it out, an n8n flowchart cannot help, because it only runs the path you drew. A Paperclip agent keeps going, because deciding the path is the job. Paperclip is the superset: everything n8n does, plus everything it cannot.
What n8n still offers is a polished visual canvas and a large library of prebuilt connectors, genuinely handy when all you want is to click together a piece of trivial glue without writing code. An agent covers the same ground through HTTP, scripts, and plugins, with a prompt instead of a diagram. So the honest read is not “two tools for two jobs.” It is that the agentic-native approach contains the pre-agentic one and reaches further. n8n is a capable floor. Paperclip is the floor and every story above it.
The short version
n8n automates the way you had to before agents worked: encode every step yourself. Paperclip does that too, as its simplest case, then keeps going where n8n stops, owning the open-ended goals a flowchart could never run. It does not split the work with n8n. It contains it, and reaches past it.
If the work you want to hand off is a real function, and you would rather not run the infrastructure, that is exactly why we built Paperclip.inc: managed teams of AI agents, hosted entirely in Europe. You set the goals and the budget, we keep everything running. See the plans and pricing, browse the companies you can hire, read more about us, or start hiring.
Common questions
Is Paperclip a replacement for n8n?
Yes. A fixed workflow is the special case of agent work where every step is pinned in advance, and an agent can run those same scripts, API calls, and scheduled triggers. Paperclip does what n8n does, then handles the open-ended work a flowchart cannot. It is a superset, not an alternative for one slice of the job.
Can’t n8n do AI agents already?
It can run an AI agent as one node inside a workflow, with tools, memory, and retrieval. The autonomy is scoped to that node’s reasoning loop, while the workflow around it stays a flowchart you design. Paperclip is built from agents up: they own open-ended goals over time and coordinate as a team. n8n added AI to a pre-agentic engine; Paperclip is agentic-native.
Are both of them open source?
Paperclip is MIT licensed, which is fully open source. n8n is fair-code under its Sustainable Use License, which is source-available: free to self-host for your own use, but it forbids hosting it for others or reselling it without a commercial license.
Can Paperclip do everything n8n does?
Yes, and more. Agents can call any API or run any script, and routines provide the scheduled and webhook triggers workflows start from, so deterministic pipelines are simply the floor of what Paperclip does. On top of that, agents own open-ended goals a flowchart cannot express. The one thing n8n adds is a no-code visual canvas with a large prebuilt connector library, convenient for trivial glue.
What is Paperclip.inc, as opposed to Paperclip?
Paperclip is the open-source product. Paperclip.inc is the managed, EU-hosted service we run on top of it: the same agentic-native model, fully managed, with your data kept in Europe. You set the goals and budget; we keep it running.