Model or dataset
agent-of-empires/agent-of-empires avatar
agent-of-empires/agent-of-empires

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

Manage multiple Claude Code, OpenCode agents from either TUI or Web for easy access on mobile. Also supports Mistral Vibe, Codex CLI, Gemini CLI, Pi.dev, Copilot CLI, Factory Droid Coding.

4,506 stars412 forksRustMIT

At a glance

What is it?
Agent of Empires (AoE) wraps Claude Code, Codex, Gemini CLI, and other agent CLIs in persistent tmux sessions, adding a TUI, web dashboard, and mobile access. It targets developers who run multiple agents across branches and want to monitor them from anywhere.
Who is it for?
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.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • agent-of-empires/agent-of-empires4,506 ★ · +1,293
Star history
Repository2026-09-102026-11-15
agent-of-empires/agent-of-empires3.2k4.5k

1,293 Stars in the last 66 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

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. 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.

Frequently asked questions

What is Agent of Empires?

A session manager for AI coding agents on Linux and macOS. It runs agents in parallel across branches, keeps each one in a persistent session with optional worktree and container isolation, and can be monitored from a terminal interface, a browser, the command line or an HTTP API.

Which AI coding agents does Agent of Empires support?

The project description names Claude Code, OpenCode, Mistral Vibe, Codex CLI, Gemini CLI, Pi.dev, Copilot CLI and Factory Droid Coding. The FAQ points you at a subcommand for the current list and what is available on your machine.

Does Agent of Empires work on Windows?

Only through WSL2, because the tool depends on tmux and on POSIX process handling. Linux and macOS are the supported platforms, and tmux is a required prerequisite while a container runtime is optional.

What happens to running agents if I close Agent of Empires?

Nothing. Each agent runs in its own tmux session in the background, and sessions are removed only when you delete them. You can also attach to any session with tmux directly, so the tool is a layer on top rather than a replacement.

How does Agent of Empires differ from plain tmux?

tmux gives you persistent sessions. On top of that the tool adds agent-aware status detection, git worktree management, container sandboxing, a web dashboard with phone access, and a diff viewer around the sessions.

Official sources

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

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/agent-of-empires-agent-of-empires.svg)](https://hysenlabs.com/projects/agent-of-empires-agent-of-empires)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/agent-of-empires-agent-of-empires.svg)](https://hysenlabs.com/projects/agent-of-empires-agent-of-empires)

Was this useful?