agtx CLI
A Rust terminal task board: every task runs in its own git worktree and tmux window while Claude Code, Codex, Gemini CLI and other agents work in parallel
- 1,718 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- Runs agents that write and delete files and execute commands in working copies, and the oneshot skill merges the result into the local base branch by itself
- The mobile board opens reading of tasks and agent screens and typing into an agent session, which is arbitrary command execution on your computer
- Contacts GitHub once a day for a new release, and the install script and the update download a binary
Install
- Works in
Manual install
curl -fsSL https://raw.githubusercontent.com/fynnfluegge/agtx/main/install.sh | bashDownloads a prebuilt binary for Linux or macOS into `~/.local/bin` and verifies the checksum. Needs tmux and git.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- Runs agents that write and delete files and execute commands in working copies, and the oneshot skill merges the result into the local base branch by itself
- The mobile board opens reading of tasks and agent screens and typing into an agent session, which is arbitrary command execution on your computer
- Contacts GitHub once a day for a new release, and the install script and the update download a binary
This is third-party code. Review the repository files before installing.
What it does
agtx is a Rust terminal program that turns work with several AI agents into a board with columns. Running `agtx` in a repository opens a task board by stage: backlog, planning, running, review, done. For each task agtx creates its own git worktree and a tmux window with its own agent, so the agents do not get in each other's way and work in parallel. The agent is chosen in `~/.config/agtx/config.toml`: Claude Code, Codex, Grok, Cursor, OpenCode, Antigravity, Gemini CLI, Copilot and pi are supported. Different stages can be given to different agents, for example research to Gemini, implementation to Claude and review to Codex, and agtx then switches the session and hands over context itself. Dependencies between tasks hold the next one until the previous one reaches review. When a task in review goes idle, agtx checks for merge conflicts with `git merge-tree` and, if needed, sends the agent the `/agtx:merge-conflicts` skill. Ready-made sets of steps plug in as plugins: gsd, spec-kit, openspec, bmad, superpowers and others, while the `void` plugin leaves a plain session with no prompts. Agents connect to the board over MCP: `agtx mcp-serve` exposes the board tools, and the Claude Code plugin brings the `/agtx:brainstorm`, `/agtx:sweep` and `/agtx:oneshot` skills. The last one runs the board without you toward a stated goal: it plans in milestones, starts tasks, answers the workers' questions and merges finished work into the local base branch. The board can be opened on a phone: the `W` key starts a web app, and `agtx serve --tunnel` uses your Tailscale network.
Who it is for. For developers who run several tasks in one repository at once and want to see all their agents on one board without switching terminal tabs.
Good fit when
- Three or four tasks run in a repository at once and the agents need separate branches and directories so edits do not collide
- You want one agent to plan, another to write code and a third to check, without copying context by hand
- An idea needs discussing with an agent, then breaking into tasks and putting on the board with `/agtx:sweep`
- You want to watch agents from a phone and answer their permission requests while away from the computer
Not a fit when
- You run Windows: the install script supports only Linux and macOS, and agent sessions run in tmux
- The project is not in a git repository: each task gets its own worktree, and the board does not work without git
- One agent and one task at a time is enough: then the board only adds setup
- You want a windowed app driven by mouse rather than a board with Vim-style keys: cmux is closer for that
Example request
Let's discuss exporting reports to CSV, and once we agree, break it into tasks and put them on the agtx boardLimitations
- It needs tmux, git and the CLIs of the agents you choose. Agent keys and plans stay yours. The `gh` utility is needed only for pull request work.
- The author marks the orchestrator mode (`agtx --experimental`) as experimental. The `/agtx:oneshot` skill spends many session turns: a full run takes hours, so start with a small goal.
- `oneshot` needs `auto_trust = true`, otherwise tasks stall on trust prompts. Merges go into the local base branch of your working copy, which must have no uncommitted changes. Nothing is pushed to a remote repository.
- The `.agtx/` directory with task working copies should be added to the project's `.gitignore`.
- The mobile board needs a binary built with `--features serve`; the published releases are. While `agtx` is not running, actions from the phone wait in a queue. License Apache-2.0.
How to disable. Delete the `~/.local/bin/agtx` binary and the `.agtx/` directory in your projects, and remove the Claude Code plugin with `claude plugin uninstall agtx`. Drop the server entry with `claude mcp remove agtx`. Settings live in `~/.config/agtx/config.toml`.
FAQ
How does agtx keep tasks apart?
Each task gets its own git worktree, by default in `.agtx/worktrees`, and its own tmux window with an agent. Agents cannot see each other's context and exchange only what lands on the board: plans, diffs and review results.
Can different agents be assigned to different stages?
Yes, the `[agents]` section of `config.toml` sets agents for the `research`, `planning`, `running` and `review` stages. The same section in a project's `.agtx/config.toml` overrides the global one. Context is handed over automatically when the agent changes.
What does the oneshot skill do and where is its limit?
The skill takes a goal, splits it into 4–8 milestones and starts the tasks of the current milestone, running three to six at a time. It answers the workers' questions, and anything that changes the product it writes into `oneshot-state.md` for you. Merges go into the local branch and nothing goes out.
How do I open the board on a phone safely?
The `W` key starts the server and shows a QR code: a phone pairing lasts two minutes and works once. The `s` mode works on your Wi-Fi, the `t` mode through Tailscale from anywhere. Devices are stored with hashed tokens and can be revoked with `agtx serve --revoke` and `--revoke-all`.
How does the void plugin differ from the others?
The `void` plugin starts an ordinary agent session with no prompts or skills, and the task description is prefilled in the input. It fits when you want the board and session management with full human control and no specs.
How do I create my own workflow plugin?
A plugin is described in a single TOML file: commands, prompts and artifacts for each stage. The repository's `plugins/` directory holds ten built-in examples, including `agtx`, `agtx-terse`, `gsd` and `openspec`. The `P` key on the board switches plugins.
Discussion
No questions or reviews yet.
Related
CLI toolsA terminal session manager for Claude Code, Codex, Gemini CLI, OpenCode and other agents: one list with statuses, git worktrees and control from a phone
A skill for messaging between Claude Code, Codex, Gemini CLI and other CLI agents through a shared local SQLite database, written in bash
A portable .agent folder with memory, skills and protocols that plugs into many coding agents and keeps its knowledge when you switch tools
Ten AI agents in tmux panes: a manager hands tasks to seven workers, progress shows on a dashboard, with Claude Code, Codex, Cursor and OpenCode supported
A terminal app for running several Claude Code, Codex, Gemini CLI and Aider sessions in parallel, each in its own tmux session and git worktree
Axe in Go: single-purpose AI agents defined in TOML and run from a terminal, pipes, cron and git hooks, with memory, sub-agents and MCP
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| agtx (this entry) | no | 1,718 | |
| Claude Squad | no | 8,656 | a terminal app for parallel agent sessions in tmux and git worktrees |
| cmux | no | 28,373 | a native macOS terminal built on Ghostty with vertical tabs |
README in short
The repository holds the Rust board sources, an install script, ten built-in workflow plugins with TOML descriptions and skills, plugin manifests for Claude Code and Codex, a Docker image for a sandbox and a set of configs for SWE-bench measurements. The front page opens with an overview of features and a quick start, followed by the idea behind the board, mobile access, skills, configuration and plugin creation.