I Killed My Multi-Agent System. Here's What I Actually Use Now.

built a multi-agent operating system from scratch. Six specialized agents. Cron jobs. A Discord bot named after Opus. Memory layers. Routing logic. The whole stack.

I called it Nexus.

And I shut it down.

Not because it was broken. Because it was too much. Too many moving parts. Too many places for things to go wrong. Too much surface area to debug at 11pm on a Tuesday when I just wanted one thing to work.

This is the post I wish someone had written for me a year ago.

What I Built

OpenClaw was a multi-agent system running on a Mac Mini in my office. Six specialized agents. Each one had a job.

A main router. A growth agent. A content agent. A strategy agent. An ops agent. A health agent.

They talked to each other through a shared memory layer. They wrote to Supabase. They pulled context from Mem0. They ran on schedules. They posted to Discord. They could spin up subprocesses, call APIs, scrape the web, and write to my filesystem.

It worked. For a while.

Why I Killed It

The agents started going haywire.

Not in a dramatic way. In a quiet way. Tasks would silently fail. One agent would call another and get a hallucinated response. Cron jobs would fire and write garbage data. The Discord bot would post something that made no sense.

Here's the math nobody tells you when you start building multi-agent systems:

Ten agents at 95% individual reliability equals 60% system reliability.

That's not a typo. That's compound failure. Each handoff between agents is a chance for the chain to break. The more agents you stack, the more brittle the whole thing becomes. And once you can't trust the output, you have to babysit the system. And once you're babysitting the system, you don't have a system. You have a hobby that costs you sleep.

So I shut it down.

I killed every cron job. I disabled every LaunchAgent. I shut off the Discord bot. I exported what mattered and let the rest die.

And then something interesting happened. My output went up.

What I Actually Use Now

Here's the entire stack. Five tools. That's it.

1. Claude Code

This is my dev environment. Not VS Code with a Claude plugin. Claude Code itself, running in the terminal, with full access to my filesystem.

Why it matters: I'm not writing code and asking Claude to review it. I'm describing what I want and watching it get built. The loop between idea and shipped feature collapsed from days to hours.

2. Claude Cowork

This is what replaced OpenClaw.

Cowork lets me delegate real work — research, file management, multi-step tasks — without standing up my own agent infrastructure. I'm not maintaining cron jobs. I'm not babysitting routing logic. I'm not waking up to a broken pipeline.

I just give it the task and walk away.

The difference between OpenClaw and Cowork is the difference between owning a fleet and calling an Uber. Both get you there. One of them eats your weekends.

3. MCP Servers

This is the connector layer. Slack. Gmail. Drive. Vercel. Supabase. Apollo. Canva. Firecrawl. Each one plugged in through MCP.

I don't write integrations anymore. I connect a server, scope its permissions, and the AI knows how to use it.

If you're still building custom API wrappers in 2026, you're doing it the hard way. MCP made integration a configuration problem instead of a coding problem. That's the whole game.

4. Vercel

Everything I ship goes here. DayCode. The UGC dashboard. The intelligence command center. The Second Brain. All of it sits on Vercel.

One deploy command. Zero infrastructure to think about. The build either works or it doesn't, and when it doesn't the logs tell me exactly why.

5. Supabase

This is where the data lives. Every project. Auth, database, storage, edge functions — one platform, one mental model.

I used to run Postgres locally and sync to a dev environment and a staging environment and a prod environment. Now I have one Supabase project per app and I move on with my life.

What I Removed

Here's the more important list.

I removed agent orchestration. I removed the routing layer. I removed Mem0 as a separate memory service. I removed the Discord bot. I removed the cron scheduler. I removed three half-built MCP servers I wrote myself before I realized the official ones were better. I removed two Notion workspaces. I removed every "AI workflow tool" that promised to make me more productive and instead made me spend an hour configuring it.

The best tool is the one you actually use. Everything else is a museum of good intentions.

The Lesson

I needed to build OpenClaw to learn what I didn't need.

That's the part nobody talks about. You don't get to the simple stack by reading about it. You get there by overbuilding, watching it collapse, and being honest about what actually moved the needle.

The simple stack on the other side of complexity isn't the same as the simple stack before it. It looks the same from the outside. But you know the difference. You've seen what each piece replaces. You've felt what happens when it's missing.

That's why this post isn't a hot take. It's a postmortem.

What I Run Today

Build: Claude Code Delegate: Claude Cowork Connect: MCP Servers Ship: Vercel Store: Supabase

Five tools. One person. Everything I need to move from idea to live in a day.

I don't have a multi-agent system anymore. I have a workflow. There's a difference.

The agents I trusted least were the ones I built. The agents I trust most are the ones I didn't.

Build less. Ship more. Sleep better.

If you're sitting on a half-built agent stack right now wondering why it keeps breaking, you already know the answer. The question is whether you're going to keep patching it or kill it and start over with less.

Kill it.