How to Run 20+ Agents Comfortably (July 2026)

In 6 to 12 months I will probably laugh about this setup. Some open source tool, a new technique, or a smarter agent will do all of it for you. Read this as temporal.

It is heavily inspired by @levelsio’s tweets. Most of the credit is his, this is just my practical take.

The goal: keep 20+ agents working in parallel, reachable from anywhere including my phone, without babysitting them. Below are the building blocks. The hard technical details you can solve with your own agent.

Architecture overview for running 20+ agents comfortably

That drawing stops at “Etc…”. Here is the same shape with the etcetera filled in: 20 agents across four servers, a Raspberry Pi and the laptop. The names are indicative, yours will be different.

flowchart LR

  PHONE["Phone<br/>ssh + mosh, reattach tmux"]
  TS{{"Tailscale mesh<br/>every machine by name<br/>all public ports closed"}}
  PHONE ==> TS

  subgraph LAP["Laptop: cmux + editor as filesystem"]
    CMUX["cmux<br/>glance across all 20"]
    A19["19. drafts"]
    A20["20. scratch"]
    CMUX --> A19 & A20
  end
  TS ==> CMUX

  subgraph S1["Server 1: Work, 8GB"]
    T1["tmux<br/>5 windows"]
    A1["1. api-service"]
    A2["2. web-app"]
    A3["3. report-builder"]
    A4["4. site-crawler"]
    A5["5. inbox-triage"]
    T1 --> A1 & A2 & A3 & A4 & A5
  end

  subgraph S2["Server 2: Private, 8GB"]
    T2["tmux<br/>5 windows"]
    A6["6. data-pipeline"]
    A7["7. knowledge-base"]
    A8["8. metrics-tracker"]
    A9["9. graph-builder"]
    A10["10. note-sync"]
    T2 --> A6 & A7 & A8 & A9 & A10
  end

  subgraph S3["Server 3: Lab, 4GB"]
    T3["tmux<br/>3 windows"]
    A11["11. spike"]
    A12["12. refactor-bot"]
    A13["13. scraper"]
    T3 --> A11 & A12 & A13
  end

  subgraph S4["Server 4: Jobs, 4GB"]
    T4["tmux<br/>3 windows"]
    A14["14. media-encode"]
    A15["15. tts-render"]
    A16["16. backup-verify"]
    T4 --> A14 & A15 & A16
  end

  subgraph RPI["Raspberry Pi: home LAN, always on"]
    T5["tmux<br/>2 windows"]
    A17["17. home-dashboard"]
    A18["18. lan-watchdog"]
    T5 --> A17 & A18
  end

  TS ==> T1 & T2 & T3 & T4 & T5

  CF["Cloudflare tunnel<br/>dials out, no inbound ports<br/>public domains + Access wall"]
  A2 --> CF
  A7 --> CF
  A17 -. "never exposed" .-> LANONLY["Home LAN only"]

  BK["Backups, 4 layers:<br/>Hetzner snapshot, Litestream,<br/>nightly dump, rclone offsite"]
  MON["Uptime Kuma + ntfy<br/>pings my phone"]
  A5 --> BK
  A10 --> BK
  A16 --> BK
  A2 --> MON
  A7 --> MON

The shape. A few cheap always-on servers, split by trust: one for work, one private. In my case Hetzner Ubuntu boxes, 4GB of RAM is doable, 8GB is more comfortable. OVH Cloud is a fine alternative. Agents run on the servers, not on my laptop. The laptop and phone are just windows into them, so nothing dies when I close the lid or lose signal.

Access, from anywhere

Tailscale. One private mesh over every machine: servers, laptop, phone. They reach each other by name. This is the backbone.
All ports closed. Firewall everything shut and reach the machines only over Tailscale. Nothing SSH-facing on the public internet.
ssh + mosh. mosh survives flaky wifi, network switching and sleep. Paired with tmux you reconnect and nothing was lost. This is what makes driving agents from a phone actually work.
Hetzner recovery console. You will lock yourself out at some point, a bad firewall rule or Tailscale down. The provider’s out-of-band console is your way back in. Find it before you need it.

Running the agents

cmux on the Mac, tmux on the servers. cmux to fan out and glance across many agents at once. tmux windows per project on each server, so every session stays alive server-side.
Auto mode on, remote connections always on. Agents keep going without me clicking approve, and I can reach them from any device.
MCP and skills per project. Each project ships the tools and skills its agents need, so an agent lands ready to work.
pm2. Keeps the apps and long-running processes up across disconnects and reboots.
An editor as a filesystem. I keep Cursor open on the servers over the network, mostly to browse and read what the agents actually did.

Exposing the work

Cloudflare tunnels for exposed domains. Public apps dial out through a tunnel, so there are no open inbound ports.
Cloudflare Access for protected domains. An auth wall in front of anything private but remote, so a half-built internal tool is never on the open web.

Safety net

Backups, four layers, because agents move fast and delete things. Hetzner runs a daily full-server backup under everything. Litestream streams the live databases off the box continuously. A nightly job dumps the databases and content locally. rclone then syncs the whole server off-site to Google Cloud Storage every night.
Monitoring and push alerts. Uptime Kuma watches the services, ntfy pings my phone when something falls over. With 20+ agents you will not notice a dead app by staring at it.

That is the whole thing. Cheap servers, one private network, closed by default, deliberate holes where needed, and a way back in when you lock yourself out.

← Back to posts