I tried building AI Agents in n8n - Here’s why I sprinted back to Cursor AI

Here’s what we’ll talk about today

• Two agents, one loop 🤖🤖: I wanted a “curious student” bot to grill an “expert” bot about portable water-kefir vessels (don’t ask why, I’ll explain 🤓).

• n8n prototype ❌: 4h → red error bubbles ➜ rage-quit.

• Cursor + TaskMasterAI ✅: 4h later → a working workflow I can run via CLI.

• Screenshots, full YAML config, and the decision tree I’ll reuse on every future build lie below.

Sounds exciting? Let’s dive right into it!

How my living room hackathon became an accidental A/B test

Ever watched two chatbots debate physics?

I tried wiring that up in n8n on Thursday night, hoping to gift my friend (a self-described LLM knowledge-miner) an agent that would ask and answer his follow-up questions for him.

My friend loves interrogating large language models. He keeps asking deeper follow-ups until he can distill a synthesis for his newsletter readers. I wanted to automate that by pairing two agents:

1. Expert Agent – speaks with authority on a topic.

2. Curious Agent – keeps digging until the expert’s answer hits a predefined depth (or total number of iterations).

Anthropic calls this the “evaluator-optimizer” workflow: a generator produces a response, an evaluator critiques it, and the loop repeats until acceptance.

I modelled the loop in n8n but hit a wall when the platform’s current loop patterns (“Set node state,” “workflow static data,” or “run-index tracking”) collided with dynamic LLM tokens.

After four hours of trial-and-error (and a dozen community-forum dead ends), I had nothing to show my caffeine.

Just for the record, this workflow is 100% achievable in n8n. Here’s a great video on that topic - unfortunately, I wasn’t able to find it under time pressure on Thursday evening :(.

This article is written from the perspective of a person who used n8n for the second time (but wants to learn it and knows how to code already - I’m a Python R&D Engineer during my 9-5). I’m not ditching n8n for good, just describing my experiment!

n8n’s pre-built nodes save setup time for common integrations, but complex logic can box you in

n8n is great, don’t get me wrong. It wins in several situations:

• Straightforward automations with points.

• Trigger-heavy flows (Telegram → Notion → Email). n8n ships >400 ready nodes, so piping an LLM answer straight into your knowledge base is literally drag-and-drop

• Teams/Entrepreneurs that fear opening VS Code.

• Great community, lots of material and tutorials online. I think it’s the best out of AI Automation platforms.

However, the learning curve still exists. We need to be aware of a few traps:

• Recursion hurts. The platform’s own blog labels looping the good, the bad and the ugly because you must juggle extra Set nodes or static data for every iteration. I tried using static data but couldn’t get it to work (it was the bad part from the article 😂)

• Debug friction. Visual spaghetti means scrolling through node runs to find the bug; each test consumes API tokens while you click around.

• Edge-case time sink. My evaluator-optimizer loop needed dynamic stop conditions: number-of-turns or evaluator-score. Mapping that in n8n required run-index math and conditional branches that ballooned the diagram.

Cursor + TaskMasterAI turned the same spec into a greener learning curve

TaskMasterAI is a great tool that acts as a manager for your coding projects.

It is widely known these days that defining PRD (Project Requirements Document) with step-by-step tasks increases productivity when coding with AI tools. When tasks are small, the models don’t get overwhelmed and deliver more accurate code.

TaskMasterAI is a tool that makes creating and managing PRDs as simple as writing chat messages in Cursor.

The process of working with TaskMasterAI looks like this:

1. Initialize the Task Master in your repo with task-master init - It will create custom Cursor rules that will teach the models how to develop with Task Master. Here’s a snippet:

2. Start writing about your project in plain English in Cursor. It’s as easy as writing with the AI about what you want to build.

3. After you’re satisfied with Cursor’s understanding of your project, ask it to generate a PRD file. Here’s the one generated for my project.

4. Ask Cursor to parse the PRD into atomic tasks (or run task-master parse-prd ). This will create a list and detailed description of each task:

A description of each task is available in the tasks directory, so you can modify any of the tasks manually if needed:

5. Now, when you chat with Cursor, it will understand the progress of your project and know which task it should do next. You can now sit and watch your project being vibe coded (joking of course, it still requires coding skills and validation). However, I was pleasantly surprised by how good the models were - I used Gemini 2.5 Pro Thinking and Claude Sonnet 3.7 if Gemini got stuck.

After about 2-3h of back-and-forth in Cursor, the flow worked!

Why Cursor was faster than n8n

• AI IDEs compress onboarding. AI-assisted code tools obliterate boilerplate.

• Code beats n8n nodes for recursion. Plain code is more flexible; visual builders are nice, but you need to stick to predefined abstraction.

• PRD ↔ code feedback loop. TaskMasterAI keeps tickets in sync, so change the prompt, and Cursor rewrites the code.

Try it yourself

I pushed the working Cursor repo (plus sample water-kefir debate transcripts) to GitHub.

Clone it, run, and watch two bots nerd-out about the fermentation process (or anything else you find relevant).

The 60-second decision tree: nodes, code, or a hybrid?

• Does it need common SaaS triggers (Telegram, Google Drive, etc.)?
  Yes: n8n wins, ship in minutes.
  No: go to 2.

• Does the logic branch or loop based on dynamic data?
  Yes: lean code (Cursor, Replit).
  No: go to 3.

• Will non-dev teammates maintain it?
  Yes: use a hybrid; n8n for triggers + a Function node that calls your script.
  No: pure code keeps version control clean.

(Save this, you’ll thank Thursday-night you.)

Time to Wrap Up!

• Visual builders hand you integrations on a platter.

• AI-first IDEs hand you raw freedom and, surprisingly, a shorter learning curve when logic gets funky.

Pick wisely, save a weekend.

👉 Next step

I’m releasing my build-in-public videos on my YouTube channel.
Subscribe here and watch me face-palm in real time 🤦.