agtx

🏄🏼‍♂️ agtx

The terminal-native agentic development environment for 10x productivity.

A blackboard for coding agents - One shared board. A fleet of agents. Add tasks, delegate to multiple coding agents running in parallel and let different models collaborate on the same task with automatic session switching and context awareness, e.g. Codex planning, Claude implementing, Grok review.

---

Features

• Supported Agents:  Claude Code Codex Grok Cursor OpenCode Antigravity Gemini CLI Copilot pi
• Parallel Multi-agent task lifecycle: Configure different agents per workflow phase — e.g. Grok for research, Claude for implementation, Codex for review — with automatic agent switching and context handover.
• Multi-project Kanban board: Manage agent sessions across all projects via a single TUI without leaving your terminal.
• Vim-native Keybindings: Control the board and agent sessions with your Vim-powered muscle memory.
• Mobile support: Press W and scan the QR for an installable web app with the board, task details, diffs and the agent's live terminal — including a keyboard, so you can answer a permission prompt without going back to your desk. Over your wifi, or from anywhere via your tailnet. See Mobile.
• Orchestrator agent (experimental): A dedicated agent that autonomously manages your kanban board via MCP — delegates to coding agents, advances phases, checks for merge conflicts.
• Oneshot skill: Give a coding agent session a goal with /agtx:oneshot and it runs the whole board unattended — plans the work in milestone waves, starts tasks, unblocks the workers, judges Review, and merges each task. See Oneshot Skill.
• Brainstorm & Sweep skills: Capture ideas and push them to the board from any coding agent session — /agtx:brainstorm to explore freely, /agtx:sweep to decompose and create tasks with one confirmation step.
• Spec-driven plugins: Plug in GSD, Spec-kit, OpenSpec, BMAD, Superpowers and more — fully customizable. Ddefine your own workflow via a single TOML file. See Plugins how to create a plugin.

[!NOTE] Just need a plain coding-agent session-manager with full human-in-the-loop control and no spec-driven skill execution and orchestration on advancing tasks?

Choose the void plugin and enjoy agtx as a batteries included multi-agent session-manager.

Quick Start

# Install
curl -fsSL https://raw.githubusercontent.com/fynnfluegge/agtx/main/install.sh | bash

# Run in any git repository
cd your-project && agtx

[!NOTE] Add .agtx/ to your project's .gitignore to avoid committing worktrees and local task data.

# Install from source — `serve` adds the mobile board (`W`), and the
# published binaries are built with it
cargo build --release --features serve
cp target/release/agtx ~/.local/bin/

Updating

agtx checks GitHub once a day for a newer release and shows ⬆ 0.2.8 [u] in the board header when there is one. Press u for the details and one key to install it, or from a shell:

agtx update          # download, verify and replace this binary in place
agtx update --check  # report only; exits 1 when an update is available
agtx --version

Requirements

• tmux — agent sessions run in a dedicated tmux server
• gh (optional) — GitHub CLI for PR operations

Usage

Key	Action
h/l or ←/→	Move between columns
j/k or ↑/↓	Move between tasks
o	Create new task
R	Enter research mode
↩	Open task (view agent session)
Ctrl+f	Open the task popup fullscreen; press again to return to windowed mode
m	Move task forward in workflow
r	Resume task (Review → Running) / Move back (Running → Planning)
p	Next phase (Review → Planning, cyclic plugins only)
d	Show git diff
x	Delete task
/	Search tasks
P	Select spec-driven workflow plugin
,	Open the config editor
?	Show every keyboard shortcut
u	Update agtx (only shown when a new release is available)
W	Serve the board to a phone (QR pairing, device list)
O	Toggle orchestrator agent (--experimental)
e	Toggle project sidebar
q	Quit

Press o to create a new task. The wizard guides you through:

1. Title — enter a short task name
2. Plugin — select a workflow plugin (auto-skipped if only one option)
3. Prompt — write a detailed task description with inline references

The agent is configured at the project level via config.toml (not per-task).

When writing a task description, you can reference files, skills, and other tasks inline:

Key	Action
# or @	Fuzzy search and insert a file path
/	Fuzzy search and insert an agent skill/command (at line start or after space)
!	Fuzzy search and insert a task reference (at line start or after space)

Each task runs in its own tmux window with a dedicated coding agent. The session persists across the entire task lifecycle — you can open the task popup at any time to see live agent output, or press Ctrl+f to open it fullscreen inside agtx.

• Persistent context: The agent's full conversation history is preserved across Planning → Running → Review
• Resume from Review: Moving a task back to Running simply reconnects to the existing session — no re-initialization needed
• Inline view: Press ↩ on any active task to open a scrollable tmux view inside the TUI
• Fullscreen: Press Ctrl+f to expand the task popup inside agtx. Press Ctrl+f again for windowed mode or Ctrl+q to return to the board.
• Auto merge-conflict resolution: When a Review task becomes idle, agtx checks for merge conflicts with the default branch using a non-destructive virtual merge (git merge-tree). If conflicts are detected, the agent is automatically sent the /agtx:merge-conflicts skill to resolve them and re-commit

Why agtx? - The blackboard model

Most AI coding tools give you one agent, one task, one terminal. agtx is built on a different and much older idea: the blackboard system.

A blackboard system is an approach where a common knowledge base — the blackboard — is iteratively updated by a diverse group of specialist knowledge sources, starting from a problem specification and ending with a solution. Each specialist writes a partial solution to the blackboard when the state on the board matches what it can contribute.

— after Blackboard system, Wikipedia (CC BY-SA)

That architecture was designed for problems that are too ill-defined for a single solver and too interdependent to split cleanly up front. Shipping software with coding agents is exactly that problem, so agtx implements the model directly:

The dependency graph gives the blackboard its structure. Tasks references they build on, forming a graph of partial solutions - agtx holds downstream tasks until their dependencies reach Review or Done, then carries the relevant diffs and artifacts into the dependent task's context.

        ┌───────────────────────────────────────────────────────────┐
        │  CONTROL     orchestrator agent · phase gates · dep graph │
        └─────────────────────────────┬─────────────────────────────┘
                                      │
        ┌─────────────────────────────▼─────────────────────────────┐
        │                       THE BLACKBOARD                      │
        │     backlog  →  planning  →  running  →  review  →  done  │
        │   dependency graph · specs · plans · diffs · reviews      │
        └────▲─────────▲─────────▲─────────▲─────────▲─────────▲────┘
             │         │         │         │         │         │
        ┌────┴───┐ ┌───┴───┐ ┌───┴───┐ ┌───┴───┐ ┌───┴───┐ ┌───┴───┐
        │ Claude │ │ Codex │ │Gemini │ │Cursor │ │ Grok  │ │  ...  │
        └────────┘ └───────┘ └───────┘ └───────┘ └───────┘ └───────┘
           KNOWLEDGE SOURCES — one git worktree + tmux window each

Blackboard model	In agtx