Agent-Manager: A Tmux TUI for Running Claude Code, Codex, and OpenCode Side by Side

If you run multiple AI coding agents at once, you know the feeling: you have five terminal tabs open, three of them are sitting on permission prompts you never saw, and the one that finished its task five minutes ago is waiting for you to notice. The time sink is not the coding. It is keeping track of what state each agent is in.

Agent-Manager is a new open-source tool built to solve exactly that problem. It wraps tmux in a Go bubbletea TUI that shows every coding agent in a single tree view with live status, grouped by project, and lets you interact with any of them without leaving the manager.

The project reached the front page of Hacker News on July 30, 2026, drawing 75 points and 58 comments from a community that clearly shares the pain.

What Agent-Manager Does#

Agent-Manager is a single Go binary that sits on top of tmux. It does not replace tmux or run its own multiplexer. Every agent session is a plain tmux session in the am_* namespace, which means quitting the manager leaves everything running and you can reattach to any session with vanilla tmux commands.

The interface shows a sidebar with sessions grouped into a project tree of unlimited depth. Each row carries the session name, tool type, and a live status indicator:

• working - the agent is busy on a turn
• waiting - blocked on input (a permission prompt, a question, a dialog)
• finished - turn ended, awaiting review
• errored - the tool reported an error
• idle - nothing running
• dead - the tmux session is gone

Selecting a session shows a live preview of its pane tail on the right, so a "waiting" agent's actual question reaches you without attaching.

The keybindings reflect the author's own workflow. The standout interaction is space, which docks a quick-prompt bar at the bottom. On a blocked session, it sends your typed answer directly into that agent's pane without attaching. On a project group, it spawns a new agent already working on the prompt. Press ctrl+r to open a full-screen diff review of what a session changed, rendered as whole files with syntax highlighting and tinted change lines. Line comments made in review mode are bundled and sent back to the agent as a prompt.

Status detection is per-tool and configurable. Claude Code sessions use Anthropic's hook events for first-hand lifecycle state instead of pane scraping. Other tools fall back to regex rules matched against visible pane text. The author documented the config format clearly, making it straightforward to add custom tools.

The header shows a fleet summary: per-status counts, plus CPU, RAM, and network gauges for the whole machine. Sessions spawned without a custom name get a placeholder like claude-a1b2, and the first prompt asks the agent to self-name by running agent-manager rename "<name>" once. The tool also ships with an MCP server that registers rename, review_repo, and review_base as native tools for Claude Code, Codex, and OpenCode.

What HN Is Saying#

The Hacker News discussion at https://news.ycombinator.com/item?id=49107749 revealed a developer community deep in the same exploration. The most active thread was a debate about whether tools like this add real value over plain tmux.

The "why not just tmux" question. Multiple commenters asked directly what these agent-specific multiplexers offer that tmux does not. The answers crystallized around three points: tmux does not natively show agent statuses or notify you when one needs input; it does not handle git worktree management for parallel agents working on different branches; and its tree view is not designed for the agent workflow. One commenter noted that having a priority queue of agents requiring intervention is the main value. Another pointed out that with plain tmux, finding which of five agents is blocked means cycling through every pane.

The Cambrian explosion. Several commenters had built their own similar tools. One listed 36 other projects at https://pleasedonotescape.com/. The thread included authors of Herdr, agent-deck, tmux-agent-switcher, ouijit, kabelsalat, gogoagent, and oh-my-openagent, all describing slightly different approaches to the same problem. The HN consensus: "we're all working on solving this problem" and the variety is a good thing while the space figures out what works.

The author's differentiators. Agent-Manager author yoanwaidev engaged directly with comparisons. Against Herdr, which is a full runtime with its own multiplexer and plugin system, Agent-Manager stays on tmux. The key differentiators are the space bar quick-prompt (sends input to a pane without attaching) and the ctrl+r review mode (whole-file diffs with inline comments piped back to the agent as prompts). Several commenters also appreciated that it is a single Go binary with no daemon, no server, and no config file needed for basic use.

Skepticism about agent swarms. Not everyone was sold. One commenter bluntly said "I use a coding agent but still don't see the need to manage a swarm of them like this." The counterpoint from another user described the practical use case: three tabs running long-running tasks (PR reviews, autonomous feature development) alongside a primary working window. The tool seems most valuable for developers running three or more concurrent agent sessions.

Why This Matters#

Agent-Manager is part of a larger pattern. As AI coding agents become reliable enough to run unattended, the bottleneck shifts from what the agent can do to how many agents you can effectively supervise. This is the same transition that container orchestration went through: Docker made it easy to run one container, but running fifty required Kubernetes. The agent management tooling space is at an earlier stage of that arc.

The tool's design choices reflect real operational experience. Status detection via Claude Code hooks instead of pane scraping is a pragmatic improvement over similar tools that rely on regex matching against terminal output. The MCP server that registers agent-manager commands as native tools for MCP-capable agents avoids prompt injection vectors and works without per-project setup.

For developers already running parallel Claude Code sessions, the ability to answer a blocked agent with a single keystroke without attaching to its terminal is a genuine quality-of-life improvement. The review mode that captures line-level feedback and sends it back to the agent as a prompt closes a loop that existing terminal workflows leave open.

Agent-Manager is MIT-licensed and has 139 stars, 193 commits, and active development. It installs via Homebrew on macOS and Linux, or as a Go module. The project supports Claude Code, OpenCode, Codex, and Grok Build out of the box, with a documented extension path for custom tools.

Sources#

• Agent-Manager GitHub repository: https://github.com/YoanWai/agent-manager
• Hacker News discussion: https://news.ycombinator.com/item?id=49107749
• Claude Code hooks documentation: https://docs.anthropic.com/en/docs/claude-code/hooks
• Pleasedontescape.com (agent sandbox directory): https://pleasedonotescape.com/

Continue Reading#

• Claude Code: What It Is and How to Use It - The full guide to Anthropic's terminal-native coding agent
• Zed Just Made Parallel AI Agents a Native Editor Primitive - A look at the multi-agent workflow that tools like Agent-Manager target
• Agent SDK Evolution: From Scripts to Protocols - How the agent tooling ecosystem is maturing
• The Agentic Dev Stack in 2026 - A survey of the tools, frameworks, and platforms that make up the modern AI coding stack
• 12 Tools in One Night With Claude Code - What happens when you let Claude Code run at scale
• Prime Agent: A Self-Improving Coding Harness Where Everything Is Python