On Friday, ten pull requests landed on one of my side projects. I didn't review a single diff. I clicked through the preview a few times, said "nice" or "move that", and went back to my coffee.

A year ago that would have scared me. TBH it still scares me a little..

But it worked, and I want to show you how my setup looks today, because it changed a lot in the last months and I think it finally makes sense.

I don't juggle agents anymore

Before this, my day looked like this:

• Claude Code in one tab, Codex in another, a third one "just to compare".
• Copy the output from one, paste it into the other.
• Forget which tab was doing what.
• Come back after lunch and find an agent waiting for a yes since 11 AM.

I tried to fix it many times. In January I ran Clawdbot on a VPS, locked behind Tailscale (I posted about that one). Then OpenClaw. Then Hermes. Every one of them taught me something, and every one of them ended up as one more thing to babysit.

Tuning your agents is the new "tuning your vim". You can spend weeks on it and still have nothing working. I'm gonna be honest here: I spent those weeks.

What finally clicked was not a better model. It was one rule: I talk to one agent, and that agent runs the rest.

Three machines, one private network

The hardware is boring on purpose:

• Mac mini. My main drive. This is where I sit, and where FirstMate and Grok Bot live.
• omy, a Linux mini PC running Omarchy. Always on. This is the agents' home.
• MacBook Pro. For when I'm away from the desk. It joins the same network and attaches to the same sessions.

Everything is on a Tailscale tailnet. Nothing is open to the internet. Every app the agents build gets a private link that only my devices can open, so I can check a preview from the couch or from my phone.

FirstMate, the one I talk to

The orchestrator is FirstMate. I didn't build it, I just run it every day. It lives in the terminal, inside Herdr, and it's in charge of everything that is code.

I give FirstMate a goal, not a task list. Something like "ship the onboarding fix and audit the docs". It answers "on it, two workers, two clean worktrees, I'll only ping you for decisions", and that is the last time I think about it until something is ready.

Under the hood:

• Every worker gets its own clean git worktree, so nobody steps on anybody's code.
• Every worker runs in a visible tab in Herdr, a terminal multiplexer built for agents. Local and remote machines show up in one window, and every pane says working, blocked or idle.
• When something is ready (a PR, a preview, a prototype), I hear about it right away. Not buried in a progress log.

The SecondMates on omy

FirstMate doesn't do all the work itself. Over the tailnet it talks to the SecondMates on omy, one per lane of work. In the video there are six with fake names. In real life I run five: client work, a SaaS, my plugin business, a family business and my personal stuff.

Each SecondMate owns its lane: its own backlog, its own state, its own workers. The backlogs are plain markdown files, so what I read and what the agents edit is the same file.

BTW, I tried to move FirstMate to omy too, to have everything in one box. It lasted one day. I moved it back to the Mac the same afternoon. Some ideas look great on paper..

A watcher that costs nothing

This is my favorite part.

A small watcher sleeps on the whole fleet. It doesn't call any model while nothing happens, zero tokens. When a lane changes status, it wakes a supervisor, the supervisor checks, and only then I get a message.

I only hear about three things:

• Decisions only I can make.
• Things that failed.
• Work ready for review.

Everything else is noise, and noise is what killed all my previous setups.

Review the finished thing, not every PR

Back to Friday.

Every PR goes through a push gate first (no-mistakes). It runs an AI code review, the tests, lint, docs and live checks against the real app, in a throwaway worktree, before anything becomes a PR I would ever see.

For a project in its early phase, I now let the crew merge on green. If the gate passes, it merges and the preview moves to the new main. If it fails, it never merges. I get one line per merge, or one summary per batch.

That's how ten PRs landed in one day while I only looked at the result.

The hard limits stay, no matter what:

• Production deploys, billing, domains and keys wait for me.
• Client work still gets my approval PR by PR.
• The agents can't even read my credential files. On Friday a deploy stopped because a Cloudflare key was missing some permissions. FirstMate listed exactly which ones, I fixed the key myself, and it continued. That's the right way around.

There's also an away mode. One command tells FirstMate I'm out, the crew keeps building and testing, and every decision waits for a short brief when I'm back. Away mode never adds powers, it only holds things.

Claude or OpenAI? It doesn't matter

People always ask "Claude or OpenAI?". Wrong question.

The idea is the agent, not the model. Every worker is an independent agent with its own model and its own provider. Today one lane runs on Claude Code and another on Codex. Tomorrow I can swap any of them, and FirstMate doesn't care. It hands out goals, it doesn't hand out models.

Claude Code and Codex are my daily drivers, on both machines. I also have pi, omp, opencode, Cursor's CLI and Gemini CLI installed, and I use them from time to time for a second opinion.

No lock-in. If a provider gets slower, pricier or worse next month, I change one line and the crew keeps shipping.

The teammates outside the terminal

Not everything is code. For everything else I use Grok Bot, where I can run several bots as chat teammates. The chief of those bots is Donna.

Donna is the one I talk to there. I ask for something, Donna routes it to the right bot and brings me back the summary.

The rest of the team:

• An inbox manager that drafts replies to clients.
• An SEO desk for keyword and market research.
• A copywriter for bios and launch tweets.
• A work diary bot that reads what the crew did each night and pitches me stories (this post started there).
• A silly one, my football digest. Every morning it gets all the games from the biggest leagues in the world and the national teams, and makes me a nice image with the kick-off time and where each match is on TV. Zero business value. I check it a couple of times a day and pick what to watch 😆
• Independent bots that run some of my new side projects completely. One per project.

That last one is my favorite. Each side project bot has its own schedule. It checks the SEO, the visits, the keyword rankings, and decides what the site needs next. Then it either makes the change itself or asks FirstMate for it.

There's a small bridge between Grok Bot and FirstMate. The project bot drops its request straight into FirstMate's inbox, no Donna, no me in the middle. FirstMate turns it into work for the crew, and the next thing I see is a message like "there are new PRs for review, requested by the bot of project X".

I never opened an issue. I never copied a report from one place to another. A bot noticed something, the crew built it, and I just review.

And omy runs the boring automations on a schedule:

• Every morning, an agent researches trends for short quiz videos.
• Every night, another one produces one approved video.
• Every Monday, a dead-link report for a public site.
• Every six hours, the notes vault syncs.

One brain for everyone

All of this shares one memory: my Obsidian vault. Decisions, project notes, research, how I like things done. If a note and an agent's memory disagree, the note wins.

Small thing, huge difference. Every new session starts knowing what I decided last week.

What breaks

It's not magic, and I don't want you to think it is:

• Scheduled jobs fail quietly. This week my vault sync timer on omy failed more than once, and nothing screamed about it.
• More moving parts means more things to update. Herdr, FirstMate, the gate, the harnesses.. it adds up.
• It costs money. About $330 a month: Claude Max 20x ($200), Codex ($100), Grok ($30). Tailscale is free. No API bills. I almost never hit a session limit, but every week I finish with only 3 to 5% of the weekly limit left. I use more than 95% of what I pay for, so if the crew grows, the bill grows too.
• The agents make mistakes. All the time. A layout that ignores my design system, a page off brand, and I ask for it again. Annoying, never catastrophic.

I'm gonna be honest here: I never had a catastrophic one. Not luck. Since my first day with AI I have one hard rule: anything destructive is forbidden. If something destructive really needs to happen, the agent stops and I confirm it myself. Explicitly. Every time.

Small mistakes I can fix in a minute. A deleted database I can't. That rule is the cheapest thing in my whole setup, and the most important.

What I'm testing next: pstack

The weak spot in my setup is not speed. It's rigor. The crew ships fast, and the push gate catches a lot, but most of the "how do we do this well" lives in my head and in a pile of my own skills.

That's why I'm adding pstack by @poteto (Lauren Tan, React core team, now at Cursor). It's the same set of skills poteto uses every day to ship code at Cursor, and the goal is the opposite of what most AI tools sell: less code, better code.

What caught my eye:

• One entry point, /poteto-mode. It reads the task, picks a playbook (bug fix, feature, refactor, perf, shipping, orchestrate.. 23 of them) and copies its steps into the agent's todo list.
• A set of small engineering principles the agent applies when a task needs them, like "prove it works".
• Validation everywhere. "The build passed" is not evidence. A bug fix needs a repro first and runtime proof after.
• Multi-model review. Some skills send the same diff to several models and compare.

It was made for Cursor, but it installs in Claude Code as a plugin, and there are community ports for Codex and pi. Same idea as before: the agent and the process matter, not the provider.

Its whole pitch is "fearless parallelism": if you can trust one agent to do rigorous work, you can run many. That's exactly the bet my crew is making, so I want to see if pstack makes the SecondMates' workers more boring and more correct.

I'm gonna be honest here: I don't know yet if it fits. It adds more guidance and more validation steps, and more steps can also mean slower lanes and more tokens. Let's see.. I'll test it, put it in the setup if it earns its place, and come back with an update.

The stack

• Machines: Mac mini, Linux mini PC with Omarchy, MacBook Pro.
• Network: Tailscale.
• Orchestration: FirstMate, Herdr.
• Coding agents: Claude Code, Codex (plus pi, omp, opencode, Cursor CLI, Gemini CLI).
• Push gate: no-mistakes.
• Testing next: pstack.
• Chat teammates: Grok bots.
• Memory: Obsidian.
• Hosting for the side projects: Cloudflare Workers.

The setup will change again, it always does. The rule won't: I talk to one agent, and nothing destructive happens without my yes.

Your turn. How many agents do you run at the same time, and who keeps an eye on them?