Baton

What is Baton?

Baton is a terminal-native application for running multiple AI coding agents in parallel. It orchestrates agent runs across isolated git workspaces, so each task can execute without interfering with other tasks.

Its core purpose is to reduce coordination overhead while you review and integrate agent output. Baton provides status monitoring for each workspace, diff-based review of changes, and git-aware controls such as branching, Pull Requests, and per-workspace file browsing.

Key Features

• Worktree isolation for parallel tasks: Each workspace is backed by a real git worktree and its own branch, intended to prevent agent runs from stepping on each other (no stashing/switching conflicts between workspaces).
• Multi-agent orchestration with CLI-native execution: Run terminal AI coding agents in full terminal sessions (not a simplified wrapper). The site lists support for Claude Code, Codex, OpenCode, and Gemini CLI, as well as “any CLI agent.”
• Workspace monitoring and status badges: Labeled status badges indicate when an agent is waiting for input, has completed successfully, or encountered an error. Workspaces are grouped in a dashboard so you can see where attention is required.
• Git-aware change review: A Monaco-powered diff viewer shows what each agent changed, supports split and unified diff modes, and includes rollback for individual files before opening a PR. It also supports comparing against branches, not only main.
• Built-in workspace management: Create workspaces quickly from an idea (branch name, title, and description generated automatically). Archive finished workspaces, and batch stop/archive/delete multiple workspaces.
• Templates, search, and browsing: Save shell commands and agent prompts as reusable templates, perform fuzzy file search and full-text content search (fzf + ripgrep), and browse commit history and file history with per-commit diffs.
• Terminal and editor workflow: Multiple terminal tabs per workspace with pane splitting, searchable output with highlighting, and Shift+Enter for multi-line input. The editor includes git blame, plus a Monaco-based file viewer.
• Git GUI actions and PR creation: Fetch/pull/rebase/push and open Pull Requests to GitHub or GitLab from the app with a single click (as described on the page).
• Agent presets and custom commands: Define multiple agent CLI presets with varying launch modes, flags, and custom startup scripts. Configure custom agent commands that run via terminal tools.
• MCP server support: Agents can launch new Baton workspaces, run tasks in parallel, and update workspace titles/descriptions directly from the conversation (via an integrated MCP server).

How to Use Baton

1. Launch Baton and start by describing what you want built.
2. Baton creates an isolated workspace using a dedicated git worktree and branch, then starts the agent immediately.
3. Use the dashboard and status badges to see whether an agent is done, errored, or waiting for input.
4. When changes are ready, open the diff viewer to review what the agent modified, roll back any unwanted individual files, and then open a Pull Request from the app.
5. As you complete tasks, archive finished workspaces to keep the workspace sidebar organized.

Use Cases

• Parallel feature development with isolated branches: Create separate workspaces for multiple coding tasks so each agent run operates in its own git worktree, then review and PR each task when complete.
• Review-first agent output for safer PRs: Use the Monaco diff viewer (split/unified) to inspect per-agent changes file-by-file, roll back specific files, and then open a PR once you’re satisfied.
• Handling agent prompts that require input: Monitor “input” status badges when an agent is waiting on you, then respond and continue without switching back and forth through tabs.
• Investigating why code changed: Use git blame and commit history views inside Baton to trace line changes to commits, and inspect file history with diffs (including line-level stats and follow-rename tracking via git history behavior).
• Reusing proven commands and prompts: Save shell commands and agent prompts as templates, then run them in different workspaces from the toolbar.

FAQ

Which AI coding agents does Baton support?

The site explicitly lists Claude Code, Codex (Codex CLI), OpenCode, and Gemini CLI, and also states that Baton can run any CLI agent.

How does Baton avoid merge conflicts between agent runs?

Baton isolates each workspace as its own git worktree with a separate branch. The page describes this as preventing agent runs from interfering with each other, avoiding the need for stashing/switching between tasks.

What does the “input” status mean?

In the workspace monitoring UI, an input badge indicates the agent is waiting for your input.

Can I review changes before opening a PR?

Yes. Baton includes a diff viewer to review what each AI agent changed and allows rolling back individual files before opening a Pull Request.

Does Baton work as a terminal-based tool?

Yes. The product is described as “built around the terminal,” emphasizing CLI-native agent execution and terminal features like tabs, pane splits, and searchable output.

Alternatives

• Local git + manual agent runs with separate branches: You can run agents yourself per branch/worktree, then manually review diffs and open PRs; this typically lacks Baton’s centralized monitoring dashboard and built-in diff/blame/workspace management.
• Integrated IDE features for AI assistants: IDE-based AI tooling can offer agent chat and code suggestions within the editor, but may not provide the same worktree-isolated parallel execution model and terminal-centric multi-agent workflow described for Baton.
• Task/agent orchestration tools without git worktree isolation: General orchestration platforms can coordinate multiple agent runs, but Baton’s emphasis is on using real git worktrees and branches per task to keep agent outputs separated for review.
• Version-control-focused review workflows (diff + PR tools): Code review tools help inspect changes and manage PRs, but they generally don’t combine this with parallel AI agent execution and workspace-level status tracking.