7 Stars, 1 Message: Agent of Empires Tops GitHub Trending

The dev lead in a Bristol fintech startup put it plainly last week: “I didn’t hire four senior engineers to babysit AI agents.”

She wasn’t angry. Just tired. Her team ran parallel Claude Code instances across feature branches, one per engineer, plus a few for legacy refactors. They’d set up tmux sessions, sure. But no one had built a way to see which agent was waiting for input, which had hung on a git conflict, which had silently nuked a worktree.

They’d resorted to Slack threads. Manual pings. “Is agent-3 still running?” “Did it push?” “Why is staging broken again?”

Then someone found a Rust crate on GitHub called agent-of-empires. Seven stars today. Not much. But enough to surface a truth: we’ve crossed a threshold. Running one AI agent is a novelty. Running five? That’s operations.

And operations demand tooling.

The Deployment

Agent of Empires (AoE) is a session manager for AI coding agents on Linux and macOS. It’s not an agent itself. It doesn’t generate code. What it does is organize the chaos.

You install it via curl, Homebrew, or Nix. It requires tmux, non-negotiable. Docker is optional, but recommended for sandboxing.

Once installed, you launch the TUI (text-based user interface). From there, you can spin up a new session with aoe add --cmd claude. It hooks into any CLI-based AI agent: Claude Code, OpenCode, Mistral Vibe, Codex CLI, Gemini CLI, Cursor CLI, Copilot CLI, Pi.dev, Factory Droid. It doesn’t care which. It just watches them.

Each agent runs in its own tmux session. That means: no more lost work when your terminal crashes. No more “where was I?” after a weekend. Close the TUI, reopen it, everything’s still running.

But AoE adds layers tmux doesn’t touch. It detects agent state: running, waiting for input, idle, errored. It manages git worktrees so agents don’t trample each other’s branches. It can sandbox each agent in a Docker container, sharing only the auth tokens they need.

And then there’s the web dashboard, currently in beta. You press R in the TUI, and it exposes a secure HTTPS endpoint. On your phone, you scan a QR code, enter a passphrase, and you’re in. You see all sessions. You can switch between them. You can type into the terminal. You can review diffs.

No SSH. No port forwarding. Just a browser.

It uses Tailscale Funnel when available, stable URLs, persistent access. Falls back to Cloudflare Tunnel if not.

This is how a team in Dublin debugged a staging rollback at 2:30 a.m. One engineer was on a train with spotty Wi-Fi. The other was watching her kid’s school play. They both pulled up the web dashboard, spotted the stuck agent, sent a manual approval, and got the deploy through.

Not because the AI was smarter. Because the ops layer was.

[[IMG: a software engineer in a home office at night, reviewing multiple AI agent sessions on a laptop, phone propped nearby showing the same dashboard via browser]]

Why It Matters

We’ve spent five years treating AI agents as solo performers. The demo was always: watch this one model refactor a function. Now we’re in the era of ensemble play.

Teams aren’t running one agent. They’re running many, across repos, branches, services. And the failure mode isn’t hallucination. It’s operational drift.

An agent waiting for input. An agent that made a git mess. An agent that’s looping on a test failure it can’t resolve.

These aren’t bugs in the AI. They’re gaps in the runtime environment.

What agent-of-empires reveals is that the next battleground for AI developer tools isn’t model quality. It’s session integrity.

Think back to the early days of Docker. People didn’t adopt it because containers ran code better. They adopted it because they could finally answer: “Why does it work on my machine?”

AoE answers: “Why is agent-4 stuck?”

It’s not flashy. But it’s essential.

And it’s not alone. The pattern is spreading. agent-deck, the Go-based tool it cites as inspiration, does something similar. So does Cursor’s internal session layer. But AoE is different: it’s agnostic. It doesn’t care if you’re using Claude or Copilot. It just manages the session.

That neutrality matters.

Because the real tension isn’t between models. It’s between workflow control and vendor lock-in.

When OpenAI launched the Assistants API, they baked in state management, but only for their ecosystem. Same with Anthropic’s agent SDKs. You get tooling, but you’re locked to the provider.

AoE offers an escape hatch. You keep your agents. You just manage them outside the walled garden.

That’s why it’s trending.

Not because it’s new. Because it’s necessary.

What Other Businesses Can Learn

If you’re running AI agents at any scale, even two or three, you’re already feeling the drag.

You might not know it yet. But someone on your team is spending fifteen minutes a day checking on agent status. Another is manually cleaning up worktrees. Another is restarting sessions after SSH drops.

That’s tax. Invisible. Cumulative. Real.

Here’s how to avoid it.

First: adopt a session manager before you need one. Don’t wait until you’re drowning in tmux panes. Set up AoE (or something like it) as part of your standard dev environment. Bake it into your onboarding scripts.

Second: enable Docker sandboxing by default. One agent with write access can corrupt a shared environment. Sandboxing isolates the blast radius. Yes, it adds overhead. But the cost of a broken dev environment is far higher.

Third: use the web dashboard as a fallback path. Engineers will resist it, “I don’t need a browser to use a terminal.” But when their SSH client dies mid-agent-run, they’ll thank you. Especially on mobile. Press R, scan, in. No tunnel setup. No config.

Fourth: audit sessions as part of your CI/CD teardown. If an agent session lives past a PR merge, it’s technical debt. Use the CLI to list and clean up idle sessions. Automate it with a pre-merge hook.

Running one AI agent is easy. Running five of them across different branches, keeping track of which is stuck, which is waiting on input, and which just made a mess of your working tree, becomes a part-time job.

That line from the README isn’t marketing. It’s a confession. And it’s true.

The teams that win here aren’t the ones with the best prompts. They’re the ones who treat AI agents like production services, with monitoring, isolation, and recovery paths.

You wouldn’t run five microservices without observability. Don’t run five agents without session management.

[[IMG: a mid-career developer in a co-working space using a phone to check the status of AI coding agents running on a remote server, laptop open with terminal output]]

Looking Ahead

The author, Nate Brake, is a machine learning engineer at Mozilla.ai. He built this because he needed it.

That’s the pattern with the best dev tools: they’re not invented in a lab. They’re pulled from the wreckage of real workflows.

The beta web dashboard will stabilize. The Docker integration will deepen. Someone will add Slack alerts for stuck agents.

And eventually, this kind of session control won’t be a side project. It’ll be standard.

But for now, it’s a choice.

On one side: the friction of manual tracking, the cost of lost time, the risk of silent failures.

On the other: seven GitHub stars, a tmux shortcut, and a phone you can use to rescue a stuck agent at 2 a.m.

The engineer in Bristol didn’t care about Rust or TUIs. She cared about not wasting her team’s time.

She installed AoE on a Friday. On Monday, she said: “It’s like we got an ops engineer for free.”

No fanfare. No press release.

Just fewer Slack messages asking, “Is it still running?”