# agent-manager keeps eleven agent CLIs on a private tmux server named agentmgr

> A Go TUI that puts Claude Code, Codex, OpenCode and eight other coding CLIs side by side, one persistent tmux session each, with live status, a quick prompt that never attaches, and a diff review that sends your line comments back as one prompt. It is a thin layer: no cost tracking, and everything else is tmux plus your own installed tools.

**YoanWai/agent-manager** — The fastest workflow for every AI coding agent. Live status, quick prompts, worktrees, and diff review from one tmux TUI.

- Repository: https://github.com/YoanWai/agent-manager
- Website: https://agent-manager.dev
- Stars: 540 · Forks: 56
- Language: Go
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/yoanwai-agent-manager

## Sessions live on a private tmux server called agentmgr

Every agent runs in its own persistent tmux session under the `am_*` namespace, so a session outlives the manager itself: quit the TUI and the work is still running inside tmux. The sessions sit on a private tmux server named `agentmgr`, which is the detail that makes the arrangement safe to share with a personal tmux setup. Because the server is separate, a `kill-server` on your own socket leaves the agent sessions alone, and the two never mix in one `tmux ls`. Reaching a session from a plain shell means naming that server:

```bash
tmux -L agentmgr ls
tmux -L agentmgr attach -t am_<id>
```

Inside a session, `Ctrl+Q` detaches back to the manager and `Ctrl+\` is an alternate under the same rule. `Ctrl+R` opens that session's diff review, `F3` opens its directory in your editor, and `agent-manager --version` prints the version.

## space prompts without attaching, T opens a shell, f forks the conversation

The list is the interface. Each session appears once with live status, grouped into a project tree you can fold and reorder, so the question of which agent is done and which is stuck is answered by looking rather than by cycling terminal tabs. `space` sends a prompt straight into the selected session's pane, or spawns a new agent in the selected group, without attaching at all. A dead session revives on its own conversation with `v`. `f` continues a conversation in a separate named fork, and `T` opens a shell under the selected agent, or in the selected group, for builds, Git and one-off commands. The mouse works across the whole manager: the wheel moves the cursor, a click focuses a session, a click on its row or the mouse back button returns to the list, and a row drags by its `⠿` handle to reorder or move into another group. Settings has a mouse toggle for terminals where you want native text selection back.

## ctrl+r shows the full-file diff and C returns your comments as one prompt

The diff review is the part that changes how you work with an agent. `ctrl+r` opens a full-file diff of what the agent changed, syntax-highlighted, and the comments you leave on individual lines are collected and sent back to the agent's pane as a single review prompt when you press `C`. One round trip instead of one per comment. The highlighting is not cosmetic plumbing: `github.com/alecthomas/chroma/v2` sits in the module requirements, so the colouring runs through a syntax highlighter rather than raw terminal escapes. Diffing is pulled in twice, `github.com/aymanbagabas/go-udiff` and `github.com/sergi/go-diff`, which is more than one project needs for a unified view; the module file does not say which one drives the review screen and which serves something else, such as the uncommitted work a session leaves behind. The Go module also carries `github.com/modelcontextprotocol/go-sdk`, and every MCP-capable session is launched with tools to spawn another agent, send it a message, and wait until it is done.

## Nested tmux needs an inner prefix sent before d

Running agent-manager inside an existing tmux session is the awkward case the documentation spends most of its words on. Detaching a session needs the inner prefix followed by `d`, where the inner prefix is the one shown in the session footer when the configuration provides it. If both tmux servers use the same prefix, the documented workaround is to invoke the outer tmux's `send-prefix` binding. If the outer tmux captures the inner prefix instead of forwarding it, that one has to be configured to forward the key. In a full-screen attach the footer shows the inner prefix followed by `d` when it is configured, and the README does not describe what the footer shows when it is not. Key handling is split across two tables in `config.toml`: `[keybindings.session]` moves any session key or hands one back to the agent, while `[keybindings.list]` moves or turns off any action belonging to the manager's own list, with `esc` and `ctrl+c` fixed and not remappable.

## Eleven CLIs have status rules, and three of them cannot fork

Status detection covers eleven tools: Claude Code, Codex, OpenCode, Grok Build, Gemini CLI, Antigravity CLI, Pi, Command Code, Hermes Agent, Muse Code and Oh My Pi. Each one's launch, revive, fork and status rules are compiled into the binary, so upgrading agent-manager brings the current version of all of them at once rather than fetching rule files. The rules are not uniform. Hermes, Antigravity and Oh My Pi have no fork, which means `f` is unavailable on three of the eleven and the behaviour differs by which row you are on. The opening paragraph of the README calls the ninth tool Grok while the supported-tools section calls it Grok Build, so the binary's own naming for that row is worth checking against the executable it launches. A CLI that is not on the list is handled as a feature request rather than as an unsupported runtime, and eleven tools is a moving target: three releases landed in the three weeks up to v0.39.0 on 2026-09-26.

## brew install builds from source while the cask hands you a prebuilt binary

There are two Homebrew routes and they produce different artifacts. The formula is the homebrew-core one, so it compiles from source:

```bash
brew install agent-manager
```

It installs tmux if it is missing, and because Homebrew itself runs on git, both of the tool's dependencies are covered by that single command. The prebuilt binary lives in the author's own tap instead, reached as `brew install --cask yoanwai/tap/agent-manager`. The install script is the third route:

```bash
curl -fsSL https://raw.githubusercontent.com/YoanWai/agent-manager/main/install.sh | sh
```

It downloads the latest release for your platform, verifies it against the published checksums, and installs to `~/.local/bin`. It then checks for tmux 3.1+ and git and offers to install whichever is missing through whichever package manager it finds, Homebrew, apt, dnf, pacman, zypper or apk, printing the exact command when you decline. `AGENT_MANAGER_INSTALL_DIR` moves the destination, `AGENT_MANAGER_VERSION` pins a version, and `AGENT_MANAGER_INSTALL_DEPS=1` answers the dependency prompt up front, with `=0` skipping it.

## Not here yet: cost tracking

One feature is called out as missing in the middle of the feature tour, in six words: not here yet, cost tracking. For a tool whose selling point is running eleven agents at once that is the notable absence, and nothing elsewhere in the documentation fills the gap. The status line in the list is described as live status without saying what it reports, and the module requirements show no billing or pricing client among the dependencies, so the cost data is not being collected anywhere in this tree. Configuration lives in `config.toml`, with the key binding tables and the per-agent CLI settings under `docs/configuration.md`, and the README's own last paragraph points at a full key reference, the quick prompt, and killing and reviving sessions, where that sentence stops. The site at `https://agent-manager.dev/docs/` is where the rest of it is meant to live.

## go 1.27.1 and a dependency list built for process introspection

The module file is the clearest statement of what the tool actually does. It requires `go 1.27.1`, which sets the floor for anyone building from source, matching the homebrew-core formula path rather than the prebuilt one. Twenty-one direct requirements sit in the first block, and several of them exist to look at the machine rather than to draw a screen. `github.com/shirou/gopsutil/v4` reads process and system state, `github.com/distatus/battery` reports battery, `howett.net/plist` reads macOS property lists, `github.com/ebitengine/purego` is a foreign function interface, and `modernc.org/sqlite` is a pure-Go SQLite driver, which together suggest session state kept in a local database with no cgo toolchain needed. The UI stack is the charmbracelet set, bubbletea, bubbles and lipgloss, with `github.com/muesli/termenv` and `golang.org/x/image` underneath. The last push on the default branch is dated 2026-09-29, three days after the v0.39.0 tag.

## Conclusion

Use agent-manager if you already have several coding agents installed and lose time working out which one is finished, because the value is the shared list and the private `agentmgr` tmux server, not any agent feature. Do not use it to track spend: the README names cost tracking as absent, and nothing in the dependency list suggests a pricing model is being collected. Before installing, decide which artifact you want, since `brew install agent-manager` compiles from source while `brew install --cask yoanwai/tap/agent-manager` and the install script hand you a checksum-verified prebuilt binary, and check whether your tmux prefix survives being nested inside another tmux server.

## FAQ

### Which AI coding agents does agent-manager support?

Status detection covers eleven: Claude Code, Codex, OpenCode, Grok Build, Gemini CLI, Antigravity CLI, Pi, Command Code, Hermes Agent, Muse Code and Oh My Pi. Launch, revive, fork and status rules for each ship inside the binary, and a CLI that is not on the list is handled as a feature request.

### Do my agent-manager sessions survive if I quit the TUI?

Yes. Sessions run inside tmux under the `am_*` namespace, so they keep working after the manager quits. They live on a private tmux server named `agentmgr`, which means a `kill-server` on your own socket leaves them alone, and you can attach from a plain shell with `tmux -L agentmgr attach -t am_<id>`.

### How do I send a prompt to an agent without switching to its terminal?

Press `space` on a session to send a prompt straight into its pane, or to spawn a new agent in the selected group. A dead session revives on its own conversation with `v`, and `f` continues a conversation in a separate named fork.

### Does agent-manager track what my agents cost?

No. The README names cost tracking as not implemented yet, and no billing or pricing client appears in the module requirements. The list reports live status, but the documentation does not say what that status includes beyond which session is done and which is stuck.

### How do I install agent-manager with a prebuilt binary?

Use `brew install --cask yoanwai/tap/agent-manager` or the install script, which downloads the latest release for your platform, verifies it against the published checksums and installs it to `~/.local/bin`. The plain `brew install agent-manager` formula is the homebrew-core one and builds from source instead.

## Sources

- [License: Apache-2.0](https://github.com/YoanWai/agent-manager/blob/main/LICENSE)
- [Project website](https://agent-manager.dev)
- [README](https://github.com/YoanWai/agent-manager/blob/main/README.md)
- [Releases](https://github.com/YoanWai/agent-manager/releases)
- [YoanWai/agent-manager on GitHub](https://github.com/YoanWai/agent-manager)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yoanwai-agent-manager