Agent of Empires: A Session Manager for Parallel AI Coding Agents

What Problem It Solves

AI coding agents like Claude Code and Codex CLI are typically run one at a time in a terminal. If you close the terminal or lose an SSH connection, the agent stops. Agent of Empires (AoE) solves that by giving each agent its own persistent tmux session, so agents keep running in the background. The project targets developers who want to run several agents in parallel, each on a different branch, and monitor them from a single interface. It also addresses the need to check on agents from a phone or another machine through a web dashboard. The README positions it as a session manager, not a replacement for the agents themselves. It wraps whatever CLI you already use, which means you do not have to change your agent workflow, only how you launch and observe it.

How It Works: tmux Underneath

The core mechanism is tmux. Each agent runs in its own tmux session, so closing the TUI or disconnecting SSH does not stop the agent. The README states that sessions persist and are only removed when you explicitly delete them. The key shortcut is Ctrl+b d to detach from a session and return to the TUI. On top of tmux, AoE adds agent-aware status detection, meaning it can distinguish running, waiting, idle, and error states. It also manages git worktrees and multi-repo workspaces, so you can assign different branches to different agents. For isolation, it supports Docker, Podman, and Apple Containers sandboxing. The web dashboard and HTTP API are separate surfaces that talk to the same tmux sessions. You can still attach directly to any AoE session with tmux, which is a useful escape hatch if you want to bypass the tool entirely.

Getting It Running: Install and Quick Start

Installation requires tmux as a prerequisite. Docker is optional and only needed for sandboxing. The README gives several install paths. The quick install script is curl piped to bash: curl -fsSL https://raw.githubusercontent.com/agent-of-empires/agent-of-empires/main/scripts/install.sh | bash. Homebrew users can run brew install aoe. Nix users can run nix run github:agent-of-empires/agent-of-empires. Building from source requires cloning the repo and running cargo build --release, which implies a Rust toolchain. After installation, the quick start is three commands: aoe launches the TUI, aoe add --cmd claude creates a session running Claude Code, and aoe serve starts the web dashboard. The README notes that pressing ? in the TUI shows help and the bottom bar displays keybindings. For a full reference, it points to the documentation site for CLI and HTTP API details, which are not reproduced in the README.

Supported Agents and the 'aoe agents' Command

The repository description lists support for Claude Code, OpenCode, Mistral Vibe, Codex CLI, Gemini CLI, Pi.dev, Copilot CLI, and Factory Droid Coding. The README does not list them all in one place, but it says to run aoe agents to see the current list and availability on your machine. That command is important because support may depend on what is installed and how the CLI is invoked. The project appears to treat agents as generic commands wrapped in tmux, so adding a new agent might be as simple as specifying its command, as in aoe add --cmd claude. However, the README mentions custom agent commands and profiles, which suggests there is configuration for agent-specific behavior. The exact mechanism for defining a new agent is not documented in the README, so you would need to consult the CLI reference or guides on the website. The point is that AoE is not tied to one vendor, which is its main flexibility.

Limitations and Failure Modes

The most obvious limitation is platform support. AoE depends on tmux and POSIX process handling, so native Windows is not supported. The README says it only works through WSL2. That rules out a large group of developers who use Windows as their primary OS. Another limitation is that the README does not describe what happens when an agent process crashes or hangs. It mentions status detection for error states, but not recovery behavior. If an agent inside a tmux session dies, the session may remain, but AoE's response is unclear from the material. Also, the web dashboard requires you to run aoe serve, which exposes an HTTP API. The README does not discuss authentication or security for that server. If you expose it to the internet for mobile access, you are taking on that risk without documented safeguards. Finally, the project is young, with recent releases in late 2026, but the roadmap is public, which indicates ongoing change. Features may shift, and documentation may lag.

Comparison with Direct tmux Usage

The FAQ addresses the obvious question: how is this different from just using tmux? The answer is that tmux gives persistent sessions, but AoE adds agent-aware status detection, git worktree management, Docker sandboxing, a web dashboard, remote phone access, and a diff viewer. That is a fair distinction. If you only need persistent sessions, tmux alone is simpler and has no extra dependency. But tmux does not understand what an agent is doing. AoE's value is in the layer that interprets agent state and provides a structured view. The trade-off is complexity: you now have a Rust binary, a potential web server, and a configuration surface. For a single agent, tmux is overkill, and AoE is overkill too. For multiple agents across branches, the added structure pays off. The README also notes that AoE was inspired by agent-deck, which is a Go and Bubble Tea project. That gives a point of comparison: agent-deck likely offers a similar TUI but may lack the web and mobile components that AoE emphasizes.

Maintenance, License, and Upgrade Considerations

The project is written in Rust, which brings memory safety and a single static binary, but also a build step if you compile from source. The README shows standard cargo commands: cargo build, cargo test, cargo fmt, cargo clippy, and cargo build --features web. The last one indicates that the web interface is an optional feature, which may affect how you install and upgrade. If you use the Homebrew formula, upgrades are handled by brew, but if you build from source, you need to pull the latest tag and rebuild. The license is MIT, which is permissive. However, one file, src/tui/hyperlink.rs, contains code derived from herdr under the Apache License 2.0. The README points to THIRD_PARTY_NOTICES.md for details. That is a minor compliance consideration, not a blocker. The project is maintained by a community with support from Mozilla.ai, and there is a public roadmap. Recent releases are frequent, with three versions in late August and early September 2026, so active maintenance is evident. But that also means you should expect breaking changes if you rely on the HTTP API, so check the changelog before upgrading.

Editorial conclusion

Adopt Agent of Empires if you run multiple AI coding agents in parallel and need persistent sessions that survive SSH disconnects, plus a browser-based view for phone access. It suits Linux and macOS users comfortable with tmux and willing to manage a web server. Avoid it if you need native Windows support, as it only works through WSL2. Before adopting, verify that your specific agent CLIs are in the `aoe agents` list, and check the current roadmap for any missing features you depend on. The project is MIT licensed with a single Apache-2.0-derived file, so review the third-party notice if that matters to you.

Official sources

1. agent-of-empires/agent-of-empires on GitHub
2. License: MIT
3. Project website
4. README
5. Releases