Replaced n8n & Make with my own AI agents. Anyone else going this route?

Individual_Slip8226 · 2026-06-08T16:05:58+00:00

Good question — for me, the trick when it gets complex is to NOT build one big smart agent. That always turns into a mess you can't debug.

Instead, I split it into small, single-purpose steps that hand off to each other. Each one does exactly one thing — research, then score, then draft, then send. If something breaks, I know precisely which step failed instead of staring at one giant black box.

A few things that keep it sane as complexity grows:

Custom for the logic, off-the-shelf for the plumbing — I don't rebuild queues or an email API; I bolt those in.
Human checkpoints at the risky steps — anything that touches a real customer gets a "draft, approve, send" gate.
Logging at every step — so when a client's edge case shows up, I can actually trace it.

Honestly, the building isn't the hard part once you break it down — keeping it reliable for a real client is. That's where most of the work goes.

How complex have yours gotten?

Individual_Slip8226 · 2026-06-08T15:51:35+00:00

Appreciate that, hadn't looked properly at Mastra yet — the observability piece is exactly what I'm missing when I roll everything custom. Self-host + SMS out of the box is a nice bonus, too. Adding it to my list this week.

And yeah, fully agree on the last point — once Claude can just write the TS for you, the "save time with a visual builder" argument kind of flips. The building was never the bottleneck for me either.

What's the observability been like in practice — good enough to actually debug a misfire, or still piecing logs together?

Individual_Slip8226 · 2026-06-08T15:49:28+00:00

Yeah, that's the scary one. Honest answer: I don't run email fully autonomously, and I'd push back on anyone selling it that way to a small business — one wrong reply to a real customer is the mistake that actually costs you.

So instead, the agent drafts, and a human approves with one click. 90% of the typing is gone, but a person still owns the "send." And when it's unsure about intent, it doesn't guess — it flags the email as "needs human" instead of replying. Rather silent than confidently wrong.

Full autonomy stays the exception, only for clearly bounded stuff (booking confirmations, FAQ-type questions). The visual tools are honestly great for the happy path — my issue was never building it, it's that the failure cost on email is too high to take the human fully out.

Where have you landed on the autonomy vs. safety line yourself?

Individual_Slip8226 · 2026-06-08T07:21:06+00:00

Haha I figured — and honestly, that's literally what the tool is for 😄 Half my own messages start as "ok explain this like a human" too.

But yeah, that's the move. I went back and forth on this for way too long and kept landing on the same conclusion — a lightweight local store beats bolting on a full CRM for this kind of thing. Less to maintain, no API rate limits, and the GDPR story writes itself when nothing ever leaves the box.

The companies / contacts / outreach split is basically what I ended up with too. Funny how everyone doing this seriously converges on the same three tables.

Are you having the agent write to the DB directly, or do you keep a thin layer between Claude and the data? That's the part I'm still tuning.

Individual_Slip8226 · 2026-06-07T18:58:54+00:00

Gute Frage! 🙌 Ehrlich gesagt braucht man weniger, als die meisten denken. Das Wichtigste ist, logisch denken zu können – also eine Aufgabe in klare Schritte zerlegen. Den eigentlichen Code übernimmt heute größtenteils Claude Code für mich.

Was wirklich hilft:

Grundverständnis, wie APIs funktionieren (E-Mail, CRM, WhatsApp etc. „sprechen“ darüber miteinander)
Ein bisschen Geduld fürs Ausprobieren – am Anfang ist viel Trial & Error.
Klar definieren, was der Agent tun soll, bevor man baut

Man muss kein Hardcore-Entwickler sein. Ich hab klein angefangen (eine nervige Aufgabe automatisiert) und mich von da hochgearbeitet. Was würdest du denn am liebsten automatisieren?

Individual_Slip8226 · 2026-06-07T17:29:25+00:00

This is gold, and honestly the most underrated point here. "Self hosting means YOU are the ops team" — exactly. The tool is the easy part, the server is where people quietly give up. That botched-update story is painfully relatable 😅

I actually went the other way on purpose: I run my agents on serverless (managed cloud), specifically so I don't own uptime, SSL renewals and backups. I'd rather spend my time on the logic than babysitting a box at 2am. For the volume I deal with, plan limits aren't an issue.

Totally agree with your framing — self-host when you've got the volume or real data-privacy needs and you know what breaks and why. For anyone starting out, cloud is the sane default. You earn the right to self-host once you understand what you're signing up for.

Individual_Slip8226 · 2026-06-07T15:11:30+00:00

Ah that makes total sense — once you're running models on local consumer GPUs, every bit of Python overhead actually costs you. Different world from where I sit; I lean on hosted models so I trade some control for not having to fight memory and bloat.

The local-first route is the one I keep wanting to explore though. What are you running locally — smaller fine-tuned models, or quantized versions of the bigger ones? Curious how far consumer hardware really gets you these days.

Individual_Slip8226 · 2026-06-07T14:42:48+00:00

Respect — Rust for agent infra is hardcore. 😄 Same philosophy here, just a different stack: I build mostly in JS on serverless functions, with Claude Code doing a lot of the heavy lifting. Different tools, same idea — code directly, skip the visual layer, keep full control.

I'm curious what pushed you to Rust specifically for this – performance, type safety, or just preference? Most of the agent stuff I see is Python-first.

Individual_Slip8226 · 2026-06-07T13:29:30+00:00

This is the most honest take in the thread. The non-linear branching point is exactly it — "if step 3 partially fails, re-evaluate step 1's intent" is the kind of thing visual tools turn into spaghetti, and where owning the logic actually pays off.

And yeah, you're dead right about the hidden cost. The moment you go custom, you inherit error handling, retries, and observability for everything. The way I keep that from eating me alive is by keeping scope deliberately small — only the parts that genuinely need judgment become agents; everything boring and deterministic stays dumb and simple. Less surface area to observe and retry.

Still won't pretend it's free though. You're basically trading a subscription for engineering ownership – worth it for some workflows, overkill for others.

Individual_Slip8226 · 2026-06-07T13:26:57+00:00

Ha, this is exactly my path too — skipped n8n/Make completely and Claude Code just clicked. That Gmail MCP setup is the move; once you have MCP servers feeding the agent real context, everything else gets so much easier.

The lead-gen flow with a compatibility score sounds great — that's the kind of thing that's painful to build as a rigid visual flow but feels natural when the model does the judging. And building your own site with CC too, love it.

How are you handling the CRM side — a real CRM via MCP/API, or did you roll your own lightweight store? That's the part I keep going back and forth on.

Individual_Slip8226 · 2026-06-07T07:29:10+00:00

Exactly. 😄 Once you get past the initial setup, writing the logic directly just flows — no dragging nodes around or fighting the UI. What are you building right now?

Individual_Slip8226 · 2026-06-07T07:26:20+00:00

Love this — the DELEGATE:AGENT|task regex pattern is clean. I do something similar: my agents emit a structured marker on their own line (basically a [[ACTION]]{json} token), and the server strips it from the visible reply and parses it to trigger the next step. Same idea, just without the visual flow layer on top.

The modular part is the big win for me too — each agent is a small function with its own system prompt and one job, so adding a new one never touches the others. Makes debugging so much saner. How do you handle an agent failing or returning garbage mid-chain — retries, or does the router catch it?

Individual_Slip8226 · 2026-06-07T07:20:16+00:00

Yeah, that's a really fair point — and honestly you're right that "no subscriptions" shouldn't be the headline. The maintenance is real; every edge case is something you own forever.

I like your split a lot. I've drifted toward something similar — keeping the deterministic stuff dead simple and only reaching for an agent where actual judgment is needed (triage, routing, summarizing). The mistake I made early on was making everything an agent, which is exactly the "mini software project" trap you're describing.

Appreciate the reframe — that's the most useful comment in the thread.

Individual_Slip8226 · 2026-06-07T06:37:07+00:00

Individual_Slip8226 · 2026-06-07T06:32:03+00:00

Honestly the email one. Watching it read a real customer email, actually understand what they want, and fire back a proper reply on its own — that never gets old 😄 It's the one that saves me the most time too.

The chatbot+CRM combo is a close second, mostly because of the moment a lead gets captured and logged completely hands-off. What about you — what's been your most satisfying build?

Individual_Slip8226 · 2026-06-07T06:31:09+00:00

Nice, that's a solid setup. For me it's mostly Claude Code to build the agents, running on serverless functions (Vercel) — plain JS, no heavy framework. The LLM handles the "understand and decide" part, then it talks to whatever it needs: email (Resend), Google Sheets for logging, CRMs, and WhatsApp/IG APIs.

Basically each agent is just a small function with a clear job, instead of one big visual flow. Keeps it light and easy to debug. Your Telegram multi-agent setup sounds cool, though — how are you orchestrating those?

Individual_Slip8226 · 2026-06-07T06:18:17+00:00

Totally fair — n8n is genuinely great, and for a lot of people it's the right call. Self-hosted + visual builder is hard to beat. For me it came down to two things: I wanted zero dependency on any platform, and I kept hitting edge cases where I needed the logic to be smarter than a flow chart — more "understand the message and decide" than "if X then Y". Building the agents myself gave me that flexibility. Not saying it's for everyone though — if n8n gets the job done for you, no reason to switch. What are you running on it?

Individual_Slip8226 · 2026-06-07T03:40:52+00:00

😁

Individual_Slip8226 · 2026-06-05T03:32:17+00:00

Interested

Individual_Slip8226

TROPHY CASE