u/ageniusai

A birthday present kicked this off. My girlfriend got me a 3D printer last year, I taught myself Fusion 360, then I taught Claude to drive Fusion 360 for me. Once an AI was doing the CAD, I wanted to see how far the loop could go, so I pointed it at the content side: could a social account run itself with nobody writing the posts?

I built it, let it go, and it worked well enough that I pulled it out into a standalone n8n workflow anyone can import.

On a schedule it wakes up, decides what today's post should be, writes the caption, writes the image prompt, generates an original image, and publishes to a Facebook Page and its linked Instagram. I do not write anything.

What makes it more than a cron job that posts random stuff:

The account is aware of two things at once.

What it is about (topic-aware).

The whole content plan lives in one Config node: the vertical, the voice, five topics with angles and hashtags, and a 12-slot posting cycle. It is plain data, not hardcoded branches, so retargeting the pipeline to a completely different brand means editing that one node and nothing else.

What it already said (post-aware).

Before it writes, it reads its own recent history out of Airtable and will not repeat a topic it just covered. It also fills the grid in order, which matters because Instagram's grid fills left to right, so grouping a topic lays down a clean row instead of a random mess.

The honest results,

because that is the useful part: I ran it for months, twice a day. Around 11 cents a post (almost all of it the image), so roughly 22 cents a day. It got basically no traction. 149 posts in, the account has 6 followers. That is not the automation failing, it is that Instagram and Facebook both push video and reels with music now, and this posts still images.

I switched it off in June to stop the spend while I move it to a new setup, and the next version will generate video instead. That is a one-node swap (point the image step at a video model), it just costs more like a dollar or two a post.

You can see what it actually made here: instagram.com/agenius3d. Every image and caption there was the workflow, not me.

Stack: n8n, an LLM for the caption and image prompt (Claude Haiku by default, swappable), KIE.ai for the image, Airtable for the memory, and a notify node (Telegram, also swappable).

It is open source (MIT), with the workflow JSON, the Airtable schema, and the docs here: https://github.com/Mfrostbutter/n8n-workflow-templates/tree/main/workflows/autonomous-social-media-pipeline

Happy to break down any piece in the comments: the dedup logic, the grid-cycle math, the image poll loop, or the Instagram two-step publish.

Turn YouTube into a research feed for you and your agents. Here is the workflow.

YouTube is a great place to find someone walking through an architecture in depth. It is also 40+ minutes I do not have, and rarely 40 minutes of signal. So I built an n8n workflow that gets the information out of the video and in front of me. Here is how it runs.

📝 Paste a link. A form takes one field, the YouTube URL.

🎧 Pull the captions. An HTTP node calls a tiny yt-dlp service and gets the transcript back. Captions only, no Whisper, no GPU.

🧱 Build the prompt. A Code node assembles the system and user prompt and asks for a deep-dive structure. This is where the shape of the output lives, so it is easy to tune.

🤖 Run the model. An AI Agent node does the work. The chat model plugs in as a sub-node, so it is swappable. I shipped three as alternates (Claude, GPT, a local Ollama model) to run the same transcript through each and compare quality, speed, and cost.

📄 Save the doc. A Code node wraps the output in YAML frontmatter (title, source, channel, date) and a Drive node writes the markdown. What lands is a real breakdown: thesis, step-by-step walkthrough, verbatim commands and config, a table of the numbers, tools named, gotchas, and how to reproduce it.

Every node has a sticky note, so the canvas documents itself when you import it.

The reason the output is structured, with frontmatter and consistent sections, is that it has two readers. One is me. The other is my agents, because a clean tagged document drops straight into a RAG store or gets handed to a second agent as context. Get the knowledge out of the video and into something both a human and a machine can use.

I built this into my own app first, then pulled it out into a standalone workflow anyone can import. It needs one small Docker service (the captions wrapper), and the repo has it plus setup docs.

Open source (MIT). What is the first video you would point it at?

What are some of your favorite YouTube resources in the AI space?

https://github.com/Mfrostbutter/n8n-workflow-templates

I self-host a few n8n instances (dev, a couple of prod boxes, a client one). The thing that finally broke me was errors. A workflow would fail on one instance and I'd have no idea until something downstream went quiet. Checking meant opening each instance in its own tab and clicking around executions one by one.

So I built a command center that points at all of them at once. What it does today:

- Every instance in one list — workflows, executions, and active/inactive state across all of them, no tab-hopping.

- Errors grouped by cause, not by timestamp. Instead of scrolling a raw execution log, failures get grouped by workflow, node, and error type so you see "this HTTP node has failed 40 times since Tuesday" instead of 40 separate red rows.

- Success rates and trends per instance — which workflows are flaky, where the error volume is climbing.

- Health checks so a dead instance shows up as dead instead of silently returning nothing.

- Container management if you run your n8n (and its neighbors) in Docker — deploy and manage them from the same place.

It's self-hosted, runs as a single Docker Compose service, and it's MIT licensed. It talks to your instances through their APIs, so no plugin to install on the n8n side.

Still early and I'm building in the open. If you run more than one n8n instance, I'd genuinely like to know how you're handling the multi-instance error problem today, because that's the part I care most about getting right.

Repo <------------grab it here!

More info https://ageniusdesk.com/

I run n8n for a few different projects and got tired of juggling logins, scattered logs, and having no single view of what's broken across instances. So I built a self-hosted dashboard that pulls all my n8n instances into one place, and I've open-sourced the community edition (MIT). Looking for a few people to actually run it and tell me what breaks.

This has been WIP since April and I finally released it!

What it does today:

🗂️ One dashboard for every instance

🚨 Live error feed with one-click AI root-cause

🔬 Per-execution tracing & token spend tracking(see exactly where a run slowed or failed)

🧠 AI workflow builder that injects straight into n8n

🧰 Integrated, sandboxed Harness (agent skills, research, RAG, SQL, Redis, MCP)

🔐 Fernet-encrypted secrets vault (inject credentials straight into any n8n)

🐳 Full Docker management & One-click Docker deploy (n8n, Postgres, Redis, Qdrant, Ollama)

Full setup and walkthrough video here

full walk through video here https://youtu.be/cbpyj9h-AAY?si=HU6Jh3Uen9Iug-Eu

Clickable mockup demo if you want to see it before installing (sample data, nothing wired up): https://ageniusdesk.app

Code (MIT): https://github.com/Mfrostbutter/ageniusdesk-ce

It's early and there are rough edges, especially around different n8n versions and self-hosted quirks. What would help most: tell me what breaks on your setup, whether the multi-instance view and error feed actually match how you work, and the one missing thing that would make you keep it running. Happy to answer anything here.

I built this while prepping for a LangChain interview. I wanted a real LangGraph project instead of a toy demo, so I picked a problem I actually have: when an n8n workflow breaks at 2am, I wanted something that could diagnose it and draft a fix before I wake up, without it silently rewriting my workflows. It turned into something I actually run, so I put the code up (MIT).

The flow: n8n's error workflow POSTs the failed execution to the agent. It diagnoses the root cause, decides whether it's fixable in the workflow JSON or needs a human (auth problems are always human), drafts a corrected workflow, and then the part I actually care about.

The model that proposes the fix never approves its own work. A model from a different vendor reviews it (Claude proposes, OpenAI reviews). Different training, different blind spots, so the second opinion is genuinely independent. And the reviewer has no write access, so even if it's wrong or gets talked into approving something bad, it can't apply anything.

Two things carry the safety, not the model choice:

1. A deterministic diff gate. Before any write, plain code (not a model) rejects a patch that touches a node outside the diagnosed set, adds a node that makes a network call, references a new credential, or changes a trigger. It doesn't depend on the reviewer catching anything.

2. Snapshot-first. Every change is preceded by a durable snapshot and applied with per-step rollback. Nothing gets overwritten without a way back, and DRY_RUN is on by default.

If it can't safely fix something, it pages me in Slack and pauses for a human to resume.

Pipeline: triage (Haiku) -> route (deterministic) -> propose (Sonnet) -> review (OpenAI, read-only) -> diff gate (deterministic) -> remediate (snapshot, patch, verify, rollback on failure).

It's a prototype (v0.2). The tests run headless with stub models, so you can poke at the logic without any API keys.

Repo: https://github.com/Mfrostbutter/self-healing-ops

Short demo: https://youtu.be/RGuKOIWNr78

Curious if anyone else has let an agent write back to n8n directly, and how you gated it. The "no model marks its own homework" plus a deterministic gate is the only reason I got comfortable giving it a write path at all.

My wife runs a small candle company on the side. Between that and both of us working full-time jobs, fresh product photos were the thing that never got done, and paying for a shoot every time we had a new scent wasn't realistic. I'm an engineer, so instead of booking a photographer I automated the whole thing in n8n. Cleaned it up to share.

It's one n8n form. You upload a product photo, pick a look (flatlay / hero / ecommerce / banner) and an aspect ratio, and type one line describing the scene. The workflow:

1. Uploads your photo to KIE.AI to get a temporary URL the image model can read.

2. Sends your one-liner + the chosen look to an OpenAI agent (gpt-4.1-mini) that expands it into a full photography prompt. The system prompt forces it to describe only the scene, lighting, and composition, never the product, so the model doesn't redraw your item.

3. Runs image-to-image on KIE.AI's nano-banana-2 with your photo as the input.

4. Polls every 5s until it's done and shows the result on the form's completion screen.

Two credentials total (KIE.AI + OpenAI). Roughly $0.11 per image all-in. Import the JSON, plug in the keys, activate, open the form URL.

Repo (workflow JSON + setup + a before/after):

https://github.com/Mfrostbutter/n8n-ai-product-photo-studio

Two things that might save you time:

- nano-banana-2 is image-to-image here, so the prompt has to describe the scene AROUND the product, not the product. Let the prompt model describe the product and it'll happily redraw your label. The system prompt in the workflow handles that.

- KIE's uploaded files and result URLs are temporary (they expire after a few days). If you want links that stick, add a storage node after generation (Imgur, S3/R2, Dropbox). I left that out to keep the base workflow minimal.

Happy to answer questions on the polling loop or the prompt setup.