agent-of-empires - mobile-first multi-agent control plane

Running one AI coding agent is easy. Running five of them across different branches - keeping track of which is stuck waiting for input, which just trashed your working tree, and which is about to hit a rate limit - turns into a part-time job. Agent of Empires (aoe) is the session manager that makes it a glance instead of a job.

The architectural decision worth understanding first: every agent runs in its own tmux session. That single choice carries the whole product. Sessions persist when you close the TUI, when you disconnect over SSH, when your terminal crashes. You reopen aoe and everything is exactly where you left it.

Quick start

Prereqs are tmux (required) and Docker (optional, for sandboxing).

curl -fsSL \
  https://raw.githubusercontent.com/njbrake/agent-of-empires/main/scripts/install.sh \
  | bash

Or:

brew install aoe
nix run github:njbrake/agent-of-empires

Then:

aoe                          # launch the TUI
aoe add --cmd claude         # create a session running Claude Code
aoe serve                    # start the web dashboard

Inside the TUI, press ? for help. The bottom information bar always shows the keybindings that are available in the current context.

Which agents it manages

Auto-detects whichever of these are installed: Claude Code, OpenCode, Mistral Vibe, Codex CLI, Gemini CLI, Cursor CLI, Copilot CLI, Pi.dev, Factory Droid, and Hermes. You can run a heterogeneous mix - Codex on one worktree, Claude on another, OpenCode on a third - all visible from the same dashboard.

The pieces that aren't tmux

tmux gives you persistent sessions and pane management. AoE adds the layer above that:

• Status detection - "running", "waiting for input", "idle", "error", visible per session in a single column
• Git worktrees - parallel agents on different branches of the same repo, with the worktree lifecycle managed for you
• Docker sandboxing - isolate each agent in a container with shared auth volumes, optional but recommended for anything you don't fully trust
• Diff view - review and edit git changes without leaving the TUI
• Profiles - separate workspaces for different projects or clients
• Notifications - know when an agent finishes or needs attention
• Web dashboard (beta) - the actual agent terminal renders in the browser, including switching sessions, typing, and reviewing diffs

You can still tmux attach to any AoE session directly. AoE doesn't hide tmux - it composes on top of it.

Remote phone access

This is the feature that surprises people. Press R in the TUI and AoE exposes the web dashboard over HTTPS with QR-code + passphrase auth. It uses Tailscale Funnel when available - that gives you a stable URL and PWAs that survive restarts - or falls back to a Cloudflare tunnel.

Combined with the persistent tmux sessions, the practical workflow becomes: kick off a long agent task at your desk, walk away, check on it from your phone in line for coffee, approve a permission prompt, walk back. The agents don't care that you closed the laptop.

Mobile SSH clients (Termius, Blink)

If you're connecting via mobile SSH, the README's tip is to wrap aoe in tmux:

tmux new-session -s main
aoe

Then Ctrl+b L toggles back to aoe after you've attached to an agent session.

When to reach for it

• You routinely run two or more agents in parallel.
• You're already a tmux user, or willing to become one - this is the natural escalation.
• You want to check in on long-running agents from your phone without standing up your own dashboard infrastructure.

When not to

• Native Windows. WSL2 only. AoE depends on tmux and POSIX process handling.
• Single-agent workflows. The session-manager value scales with session count.
• Workflows that need a polished, "click here to start" web UI as the primary surface. The web dashboard is beta; the TUI is the centre of gravity.

What persists, what doesn't

Closing aoe does nothing to the sessions - they keep running until you explicitly delete them. That's mostly what you want, but it means runaway agents keep burning tokens after you walk away. Pair aoe with a budget gate (a gateway like ThinkWatch, or a per-key cap at the provider) if you can't trust an agent left unattended.

The Docker-sandboxing path is opt-in, not default. For agents touching anything sensitive, turn it on; the shared-auth-volume design makes it less annoying than it sounds.

Author and acknowledgments

Built by Nate Brake (ML engineer at Mozilla.ai), inspired by agent-deck (Go + Bubble Tea). MIT licensed.