Tier 7

Tier 7 — Fleet Ops: Operate your agents as a fleet, so long runs don't die on you

Reach for this tier when runs die because your laptop slept, parallel agents collide, or you want to drive them from your phone. Get this right and a run survives your laptop closing and keeps going while you're away.

Once you're running more than one agent, or runs longer than you'll sit and watch, where and how you run them becomes its own engineering problem. This is the operations layer of agentic work.

52. Manage parallel agents in an agent-aware terminal — so you see which one is blocked.

Instead of: a dozen plain terminal tabs where you lose track of which agent is blocked.

Prefer: a terminal built for agents (Warp) — panes per agent, notifications when one needs input, a built-in diff/review panel.

How: Claude Code runs inside Warp. One tab per repo; Cmd+D to split a pane per agent in that repo. A session that needs your input is flagged (a star / notification); the rest run in the background.

Cmd+Shift++ opens the code-review panel to diff what an agent changed and send inline comments back. (Claude Code also has its own agent view for grouping sessions.)

53. Isolate parallel agents with worktrees + one session each.

Instead of: two agents editing the same working copy and clobbering each other.

Prefer: one git worktree + branch + session per agent.

How:

git worktree add ../feat-auth feat-auth     # separate dir + branch
git worktree add ../feat-search feat-search
# run one agent in each, in its own tmux/Warp session — no collisions

Bonus: run the same task with Claude Code in one worktree and Codex in another, then diff the two approaches side by side.

54. Host long runs on a box that doesn't sleep; persist with tmux.

Instead of: a run that dies the moment your laptop sleeps or wifi drops.

Prefer: run on a small always-on server and wrap each agent in tmux.

How:

tmux new -s claude-auth        # one named session per task
claude                          # run the agent inside it
# detach: Ctrl+b then d   → the session keeps running on the server
tmux attach -t claude-auth     # reattach later, from any device

Why this works: Claude Code is API-bound, not compute-bound — inference runs on Anthropic's servers; your machine just holds the thread. A box that doesn't sleep keeps the agent moving. A 4 GB VPS handles one agent; budget 16 GB+ for dynamic workflows or many parallel subagents (heavy orchestration OOM-kills small boxes, and that takes the tmux session with it). Caveat: tmux survives disconnects, not crashes or reboots.

55. Drive the fleet from your phone — clear blockers from anywhere.

Instead of: being chained to a desk to answer one permission prompt.

Prefer: SSH in from a mobile client and clear decision points from anywhere.

How: Tailscale for a private network, Termius/Blink as the SSH client, tmux attach to look in on a run and unblock it.

For unattended runs, give an explicit stopping condition ("work until the tests pass, then stop and notify") so it doesn't loop, and consider a Telegram/notification bridge.

(Claude Code's built-in Remote Control still runs on your local machine — the server + tmux setup is the only true close-the-laptop persistence.)

56. Secure the agent server like production.

Instead of: root login and API keys in a committed file on an internet-facing box.

Prefer: non-root sudo user, SSH-keys-only, firewall, secrets in env / a secrets manager.

How: disable password and root SSH login, UFW-allow only SSH, keep ANTHROPIC_API_KEY in the environment (never committed).

If you run unattended with --dangerously-skip-permissions, put it behind a PreToolUse guard hook that blocks destructive commands — that's the layer the model can't talk its way past.

Next level up is the managed version of all this: Warp's Oz and Claude Code's dynamic workflows run agents in the cloud on schedules/triggers with central tracking — the same fleet ideas, hosted.