Always-on agents · Open source and free

n8n, Huginn and Node-RED: always-on behaviour without an agent framework

Before anyone said agent, these three were already watching feeds and acting at 3am. If the decision in your job fits in an if-statement, one of them is the right tool, and I built the same flow in two of them to show where a model belongs and where it does not.

In short

n8n, Huginn and Node-RED give you triggers, persistence and unattended execution without a model: a schedule or an event starts a flow, each step is a visible node, and the result is written somewhere. They have done this for over a decade. Add a model at exactly one node, the one that needs judgement, and you have the cheapest always-on agent you will ever run.

Part of the Always-on agents series, post 29 of 33.

In the agent, chatbot or automation post I gave myself one rule: if I can write the decision as a rule, I write the rule and I do not call it an agent. The tools in this post are where those rules live. They are not new, they are not clever, and two of them have been running on other people's servers since 2013, which is the whole point. An always-on job that does not need judgement should run on something that has already proven it can stay up.

Three tools, three licences

ToolWhat it isLicenceAge and size, read on 20 October 2026
n8nFair-code workflow automation platform with native AI capabilities, in its own words; a visual editor over hundreds of integrations, self-hosted or cloudFair-code: distributed under the Sustainable Use License and an enterprise licence, so not open source in the OSI sense208k GitHub stars
HuginnCreate agents that monitor and act on your behalf, per its README; a self-hosted Rails app the project calls a hackable alternative to IFTTT or ZapierMITCreated by @cantino in 2013; 50.1k stars
Node-REDLow-code programming for event-driven applications; a flow editor and runtime on Node.jsApache-2.0Started in early 2013 as a side project at IBM's Emerging Technology Services by Nick O'Leary and Dave Conway-Jones, open-sourced that September, a founding project of the JS Foundation in 2016, now under the OpenJS Foundation; 23.8k stars

Two of the three are open source in the strict sense. n8n is not, and I think the honest thing is to say so plainly rather than file it under open source because it is on GitHub. For a company running it internally the Sustainable Use License is rarely a problem; for a product built on top of it, read the licence first.

The flow I built in both: watch a feed, keep the matches, flag what needs a human

This is the listening half of the brand watch agent, with no model in the loop except at one node, and it is the same flow in Node-RED and in n8n.

  1. Trigger on a clock. Once an hour, and once at start so you see it work. Node-RED's inject node has a repeat interval and a fire-once-on-start switch; n8n's Schedule Trigger has an hourly rule.
  2. Fetch a feed. An HTTP request in Node-RED, parsed with the xml node; n8n has an RSS Read node that returns one item per entry. I used the Hacker News search feed for the word agent.
  3. Filter by rule. Title contains agent. A function node in Node-RED, a Filter node in n8n. This is a rule, so it is a rule, not a prompt.
  4. One judgement node, stubbed. Which hits need a human now? In my test it is a regular expression for security, outage, breach and incident. In production this is the one node that calls a model, with the title and link and a one-word answer: human or log.
  5. Write the result where you will see it. A file in this test; a Telegram message or a webhook in yours. Overwrite, not append, so the file is always the latest run and a stale run is visible.

Node-RED

The flow is a JSON file. Drop it into the data folder, start the container, and the runtime loads it. No account, no login, no editor needed, although the editor is there on port 1880 if you want to see the wires.

nodered/flows.json (trimmed to the fields that matter)[
 {"id":"t1","type":"tab","label":"feed watch"},
 {"id":"i1","type":"inject","z":"t1","name":"every hour (and once at start)",
  "repeat":"3600","once":true,"onceDelay":2,"payloadType":"date","wires":[["h1"]]},
 {"id":"h1","type":"http request","z":"t1","name":"fetch the feed","method":"GET","ret":"txt",
  "url":"https://hnrss.org/newest?q=agent","wires":[["x1"]]},
 {"id":"x1","type":"xml","z":"t1","name":"parse","property":"payload","wires":[["f1"]]},
 {"id":"f1","type":"function","z":"t1","name":"filter: title mentions agent",
  "func":"const items = (msg.payload.rss && msg.payload.rss.channel[0].item) || [];\nconst hits = items.filter(i => /agent/i.test(i.title[0]));\nmsg.items = hits.map(i => ({ title: i.title[0], link: i.link[0] }));\nmsg.count = hits.length;\nreturn msg;",
  "wires":[["j1"]]},
 {"id":"j1","type":"function","z":"t1","name":"judgement (stub for the model call)",
  "func":"// The one place a model belongs: deciding which hits need a human now.\n// Stub rule in this test; a real flow calls a local model here with the title and link.\nconst urgent = /security|outage|breach|incident/i;\nconst lines = msg.items.map(i => (urgent.test(i.title) ? 'HUMAN ' : 'log   ') + i.title + ' :: ' + i.link);\nmsg.payload = lines.join('\\n') + '\\n';\nreturn msg;",
  "wires":[["w1","d1"]]},
 {"id":"w1","type":"file","z":"t1","name":"write matches.txt","filename":"/data/matches.txt",
  "overwriteFile":"true","wires":[[]]},
 {"id":"d1","type":"debug","z":"t1","name":"count","complete":"count","console":true,"wires":[]}
]
container log## node-red log (filtered)
20 Oct 22:37:37 - [info] Node-RED version: v5.0.8
20 Oct 22:37:38 - [info] Started flows
20 Oct 22:37:41 - [info] [debug:count] 20
## /data/matches.txt
-rw-r--r--    1 node-red node-red      2493 Oct 20 22:37 /data/matches.txt
log   How Much of a Harness Does a Strong Agent Need for Autonomous ML Engineering? :: https://arxiv.org/abs/2609.40303
log   Show HN: Agent-Zero - Starter template for AI-native coding projects :: https://github.com/amorey/agent-zero
log   Ask HN: Are agent benchmarks the new credit ratings? :: https://news.ycombinator.com/item?id=50172009
log   Mouse against Opus 5.5 in an agent harness. 13x faster :: https://twitter.com/heypeterjames/status/2112621952879771744
log   Show HN: Harness Studio: an open-source desktop coding agent for any model :: https://github.com/vigneshv1cky/harness-studio
log   Show HN: What the Harness? LLM agent inconsistencies in MCP implementation :: https://what-the-harness.polytomic.com
log   Minlit - an AI agent that reads CS/ML papers and answers with citations :: https://www.minlit.app/ask
log   Show HN: Gauge CLI - Open-Source Hillclimbing for Agent Experience :: https://github.com/gauge-sh/gauge-cli
(3 feed titles contained a dash character; shown as a hyphen here, nothing else changed)

n8n

n8n also stores a workflow as JSON, and its command line can import one and run it once without touching the editor, which is how I tested it. The node types and versions in the file matter: they are the contract between you and the runtime, and an import that succeeds with a wrong version can still fail at execution.

n8n/wf.json (trimmed){
 "id": "aofeedwatch", "name": "ao feed watch", "active": false,
 "nodes": [
  {"name":"Every hour","type":"n8n-nodes-base.scheduleTrigger","typeVersion":1.2,
   "parameters":{"rule":{"interval":[{"field":"hours","hoursInterval":1}]}}},
  {"name":"Run once by hand","type":"n8n-nodes-base.manualTrigger","typeVersion":1,"parameters":{}},
  {"name":"Read feed","type":"n8n-nodes-base.rssFeedRead","typeVersion":1.1,
   "parameters":{"url":"https://hnrss.org/newest?q=agent"}},
  {"name":"Mentions agent","type":"n8n-nodes-base.filter","typeVersion":2.2,
   "parameters":{"conditions":{"conditions":[{"leftValue":"={{ $json.title }}","rightValue":"agent",
     "operator":{"type":"string","operation":"contains"}}],"combinator":"and"}}},
  {"name":"Judgement (stub for the model call)","type":"n8n-nodes-base.code","typeVersion":2,
   "parameters":{"jsCode":"const urgent = /security|outage|breach|incident/i;\nconst lines = $input.all().map(i => (urgent.test(i.json.title) ? 'HUMAN ' : 'log   ') + i.json.title + ' :: ' + i.json.link);\nreturn [{ json: { count: lines.length, text: lines.join('\\n') + '\\n' } }];"}},
  {"name":"To file","type":"n8n-nodes-base.convertToFile","typeVersion":1.1,
   "parameters":{"operation":"toText","sourceProperty":"text"}},
  {"name":"Write file","type":"n8n-nodes-base.readWriteFile","typeVersion":1,
   "parameters":{"operation":"write","fileName":"/home/node/out/matches.txt"}}
 ],
 "connections": {"Every hour":{"main":[[{"node":"Read feed"}]]}, "Run once by hand":{"main":[[{"node":"Read feed"}]]},
  "Read feed":{"main":[[{"node":"Mentions agent"}]]},
  "Mentions agent":{"main":[[{"node":"Judgement (stub for the model call)"}]]},
  "Judgement (stub for the model call)":{"main":[[{"node":"To file"}]]}, "To file":{"main":[[{"node":"Write file"}]]}}
}
Terminal# Node-RED: the flow file is the whole configuration
docker run -d --name feedwatch --memory=1g -v "$PWD/nodered:/data" nodered/node-red
# flows.json in that folder is loaded at start; the inject node fires once, then hourly

# n8n: import the workflow, then run it once by hand to see the output
# n8n only writes files under a folder you name in N8N_RESTRICT_FILE_ACCESS_TO
docker run -d --name n8n --memory=1g -v n8n_data:/home/node/.n8n -e N8N_RESTRICT_FILE_ACCESS_TO=/home/node/out docker.n8n.io/n8nio/n8n
docker cp n8n/wf.json n8n:/tmp/wf.json
docker exec n8n n8n import:workflow --input=/tmp/wf.json
docker exec n8n n8n execute --id=aofeedwatch     # runs from the manual trigger; the hourly trigger needs the server running
container log## n8n version
2.44.5
## import
[license SDK] Skipping renewal on init: license cert is not initialized
Importing 1 workflows...
Successfully imported 1 workflow.
## execute once from the CLI
(n8n prints the whole execution record as JSON here; trimmed)
## output file
-rw-r--r--    1 node     node          2358 Oct 21 14:38 /home/node/out/matches.txt
log   Release of Summonr - The open-source coding agent that stays light on your token :: https://summonr.dev/
log   Show HN: VT Code - A terminal-first coding agent with sandboxed tools :: https://github.com/vinhnx/VTCode
log   Free agent skills that walk you through designing a website with AI :: https://github.com/caelo-cms/website-design-skills
log   Show HN: My personal agent, distributed as a prompt :: https://github.com/mattabate/life-distributable
log   Show HN: Memdoor - A coding agent that can build and run headless workflows :: https://github.com/guregodevo/memdoor
log   Show HN: Mnestiq - tamper-evident logs of what an AI agent saw and did :: https://github.com/mnestiq/mnestiq
log   Agent-Head Architecture :: https://agentitter.com/agent-head
log   Compression should be part of your agent harness :: https://hackteam.io/blog/why-compression-should-be-part-of-your-agent-harness/
(4 feed titles contained a dash character; shown as a hyphen here, nothing else changed)

Huginn, which I did not run

Huginn is the oldest of the three and the one whose vocabulary is closest to this series: it calls its building blocks agents, and has since 2013, long before the word meant a language model. A Website Agent watches a page, an RSS Agent reads a feed, a Trigger Agent applies a rule, an Email Agent tells you. I did not run it for this post, because it is a Rails application with a database and the two above needed one container each; I would reach for it when the job is scraping a page that has no feed, which is where its agents are strongest.

Where the model goes, and where it does not

Look at the two flows again and count the nodes with judgement in them. One. The trigger is a clock. The fetch is a URL. The filter is a word match. The write is a path. Only the node that asks which of these a human needs to see now is a decision I could not write as a rule in advance, and even there my stub rule caught the obvious cases. When I add a model to that node I add exactly one point of cost, one point of latency and one point of being wrong, and I can see it on the canvas.

That is the discipline these tools enforce by their shape. An agent framework lets the model decide everything, including whether to fetch the feed at all. A workflow tool makes you draw the box the model is allowed to be in. For most always-on jobs in a small company, including most of mine, the box is small.

When a workflow beats an agent

  • The trigger is a clock or a webhook and the inputs are structured. A feed, a form, a row in a sheet.
  • Every step but one can be written as a rule, and you can say which one.
  • The job has run for years without a model and only needs one for a single step.
  • You want to see the pipeline on a canvas when it breaks at 3am, not read a transcript of what a model decided to do.

And the reverse: when the inputs change faster than you can redraw the boxes, or the decision spans several steps, that is when I move to one of the frameworks in the open-source comparison and accept the transcript.

What I tested, and what I did not

Both flows ran in fresh containers on this Mac, memory-capped, with the model step stubbed as a rule, against a live public feed, and the logs above are from those runs. The first n8n run failed with a 502 from the feed host, which took nine seconds to answer a plain request from my machine at the same moment; the second run, a few minutes later, went through unchanged. That is an ordinary morning for an always-on job, and it is why the timer, not the run, is the unit of reliability. Huginn I described from its README and did not run. None of the three needed anything installed on the Mac itself, which is the other reason they make good first always-on jobs.

Sources

  1. n8n, n8n README on GitHub (accessed October 20, 2026)
  2. Huginn, Huginn README on GitHub (accessed October 20, 2026)
  3. Node-RED, Node-RED repository on GitHub (accessed October 20, 2026)
  4. Node-RED, About Node-RED (accessed October 20, 2026)

Written by Lera Leonteva. Both container runs are reproduced above; star counts and licence lines are as shown on GitHub on the access date.

Frequently asked questions

Is n8n open source?

No, in the strict sense. n8n's README says it is fair-code, distributed under the Sustainable Use License and an enterprise licence. You can self-host it freely for internal use; building a product on it is restricted. Huginn is MIT and Node-RED is Apache-2.0, both open source.

Can n8n or Node-RED replace an AI agent?

For jobs where every step but one is a rule, yes, and they are more reliable at it. Add a model at the one node that needs judgement. When the decision spans many steps or the inputs change shape often, an agent framework is the better fit.

How do I run a Node-RED flow on a schedule?

The inject node has a repeat interval in seconds and a switch to fire once at startup. Put the flow in flows.json in the data folder and the runtime loads it when the container starts.

How do I run an n8n workflow without the editor?

Import the workflow JSON with n8n import:workflow and run it once with n8n execute --id, both from the command line inside the container. That is how the flow in this post was tested.

Which of the three should a non-engineer start with?

Node-RED if you like wiring boxes and want to see the data move; n8n if you want the largest library of ready-made integrations and a hosted option. Huginn rewards people who are comfortable with a Rails application and want to scrape pages that have no feed.

Lera Leonteva
Lera Leonteva
CEO & Founder, Leo AI

Lera Leonteva is the founder and CEO of Leo AI, where she works on turning long-form footage into short-form video that earns attention on its own merits. She writes Video Scaling Strategies, taking one piece of content that worked and one that did not, and using what the market is doing to explain the gap.

The always-on agent I run for social video

Leo watches what your audience is responding to, picks a clip from footage you already have, edits it and books it on the calendar. Every hour, without being asked. It is the agent this whole series grew out of.

Keep going with the series

Every post in the Always-on agents series is on one page, newest first. If you would rather see the agent I run for social video, here it is.