Runner Multi-Agent Terminal

Coordinate multiple coding agents on one mission while each keeps its native terminal interface.

Source repo
yicheng47/runner
Stars
★ 543
Last updated
today
License
MIT
Primary language
Rust

At a glance

How it runs
Desktop appCLIAgent plugin / skill
Works with
Universal · cross-platformCodex · Claude Code
Cost
Free, no paid service needed
Setup effort
Medium · a few setup steps
You'll need
A supported agent CLI installed separatelymacOS on Apple Silicon or Windows x64Windows 10 version 1809 or laterGit for Windows for Claude Code and pi bash tools on WindowsNode.js for npm-based CLI installationsShell / CLINetwork accessLocal filesystem
Typical use
A developer who wants one coding agent to implement changes and another to review the working-tree diff until no must-fix findings remain.
Not a fit if
  • Teams requiring Linux, Intel Mac, or Windows ARM64 support
  • Teams requiring production-grade stability; the project is currently alpha
  • Users unwilling to install and configure agent CLIs separately
Website
runnersh.dev ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-20latest release v0.20.2 (2026-11-20)+4.0 ★/day over 7 days
Source review
64/100 · Some gaps

What does this agent do, and when should you use it?

Runner is a native desktop application for coordinating Claude Code, Codex, GitHub Copilot CLI, and pi around one development goal rather than leaving them isolated in separate terminals. Users define Roles with a runtime, system prompt, and working directory, combine them into a Crew with one lead, and launch that Crew as a Mission. Every Mission slot runs in its own real PTY, while an append-only, persistent event feed carries messages, signals, and questions that need a human decision. Runner also provides single-agent Chats, split terminal panes, project grouping, session recovery, MCP and skill configuration views, and a runner CLI covering the same core objects. It is built in Rust with gpui-ce, alacritty_terminal, and SQLite, uses no webview, and keeps its application state, chats, and missions on the user's machine.

Runner reads and manages Role, Crew, Project, Chat, Session, and Mission records. Starting a Mission creates one live PTY for each Crew slot and leaves every agent inside its own TUI; members coordinate through the append-only feed and commands such as runner msg post, runner signal, and runner ask. A lead can invoke ask_human to surface a decision in the feed, and the user can answer through the interface or runner mission answer. Individual slots can be stopped, resumed, or restarted without restarting the entire Mission, while surviving sessions can be reattached after an application quit or crash. Settings → MCP and Settings → Skills read each agent's existing configuration files, expose per-agent toggles, and change only the selected entry. The runner command can also create and maintain projects, roles, and crews; launch, inspect, stop, and archive missions; and return JSON for scripts or other agents.

  1. A developer who wants one coding agent to implement changes and another to review the working-tree diff until no must-fix findings remain.
  2. A team assigning Claude Code and Codex different roles on the same task to get cross-provider implementation and review.
  3. An individual running many terminal agents who needs one place to see activity, completion indicators, and human-decision requests.
  4. An engineering team dividing a complex repository among architect, implementer, and reviewer roles while retaining a replayable coordination log.
  5. An automation user who wants to launch missions, follow their feeds, and message a lead from a shell or another agent.
  6. A user who wants a native interface for inspecting and toggling MCP servers and skills across supported agent configurations.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Config files
~/.local/bin
Install notes cover
Windows · macOS · Linux

How do you install or deploy this agent?

Download the latest platform installer from GitHub Releases. The macOS build is a signed and notarized .dmg for Apple Silicon; Windows uses a signed Runner-Setup-…-x64.exe for Windows 10 version 1809 or later. Intel Macs, Windows ARM64, and Linux are unsupported.

Install each agent CLI separately and make it available on PATH, or configure an executable override under Settings → Agents. On Windows, Claude Code and pi's bash tool require Git for Windows; npm-based CLI installations require Node.js.

On first launch, macOS installs runner into ~/.local/bin or a writable /usr/local/bin when that location is already on the login PATH; otherwise, install it from Settings → General → Command line. Windows adds Runner's sidecar directory to the user PATH. Runner also installs its agent skill into ~/.claude/skills/ for Claude Code and ~/.agents/skills/ for Codex, GitHub Copilot CLI, and pi.

How do you use this agent?

In the desktop application, create or select Roles and assign them to named Crew slots; each Crew must have exactly one lead. Enter a goal and start a Mission, then switch between its shared feed and the live terminal for each slot. The seeded pair-coding Crew uses @coder for implementation and fixes and @reviewer for read-only inspection of the working-tree diff.

First check that the CLI can reach the running application:

runner status

List available crews:

runner crew list --json

Start a Mission from a goal file and follow its feed:

mission=$(runner mission start --crew <crew> --goal-file - -q < brief.md)
runner mission feed "$mission" --follow --json
runner mission show "$mission" --json

Message the lead, answer a human question, then stop and archive the Mission:

runner msg post --mission "$mission" --to <lead_handle> "message"
runner mission answer "$mission" <question_id> <choice>
runner mission stop "$mission"
runner mission archive "$mission"

Inside a Mission, agents can use the inherited mission and handle context directly:

runner msg post --to <handle> "message"
runner signal <type>
runner ask --human <prompt> --choices <a,b,...>

Use --json for automation. Exit status 0 means success, 1 means Runner refused the operation, 2 indicates a usage or reference error, 3 means the application is not running, and 5 means a sandbox blocked the local connection.

What are this agent's strengths and limitations?

Pros
  • Each agent retains a real PTY and its native TUI instead of being reduced to a generic chat adapter.
  • The Mission feed is an append-only, persistent, replayable event log, and running sessions can survive an application quit or crash.
  • Claude Code, Codex, GitHub Copilot CLI, and pi can participate in the same Crew, allowing mixed-runtime workflows.
  • The desktop interface and runner CLI cover Roles, Crews, Missions, Sessions, Chats, and Projects for use by people, scripts, and agents.
  • The MCP and Skills panes work with agents' existing configuration files and are documented to modify only the selected entry.
  • Its local native stack uses Rust, gpui-ce, alacritty_terminal, and SQLite without a webview.
Limitations
  • The project is explicitly labeled alpha and actively shipping, so adopters must accept pre-release stability and change risk.
  • Platform support is limited to Apple Silicon macOS and Windows x64; Linux, Intel Macs, and Windows ARM64 are unsupported.
  • Agent CLIs must be installed separately, and some runtimes bring additional account requirements; GitHub Copilot CLI requires a Copilot subscription.
  • GitHub Copilot CLI and pi run natively on Windows but have not yet been smoke-tested there.
  • Runner does not surface approval and question dialogs for Codex; pi provides that capability only through extensions.
  • Missions use Bypass permission mode by default, which teams may need to change to meet their security policy.

How does this agent compare with similar options?

Compared with opening unrelated terminals for several agents, Runner adds reusable Roles, Crews with a designated lead, a shared event feed, persistent Missions, and an ask_human decision path while preserving each agent's real terminal UI. It is not tied to one model vendor: Claude Code, Codex, GitHub Copilot CLI, and pi can share a Crew, although their supported features are not identical.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Runner Multi-Agent Terminal This agent 64 · Some gaps Desktop appFree ★ 543 today Rust Codex · Claude Code
amux Agent Control Plane 51 · Major gaps Self-hosted serviceFree + model costs ★ 566 today Rust Codex · Claude Code
zerostack 69 · Some gaps CLIFree + model costs ★ 1.8k 2d ago Rust OpenAI API · Claude API
pitwall 81 · Good — ★ 22 today Go Codex · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
64/ 100 5-point scale 3.2 / 5
This review covers the source as of Nov 08, 2026. The project has shipped 7 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 13/29
Reliability 8/14
Adaptability 14/18
Convention 14/18
Effectiveness 10/13
Verifiability 5/8
Why each dimension lost points
Trust13 / 29 · 2.2/5

The evidence says Runner hosts each CLI agent in its own PTY, keeps sessions and history on the machine, allows MCP/Skills entries to be disabled per agent, and makes file browsing read-only. Nightly and release instructions also keep publication or installation as separate actions. AGENTS.md directs development checks to isolated directories and away from pre-existing sessions. Deductions: the product starts real CLI agents, runs a background daemon, and offers remote control, while this sample does not fully describe permission boundaries, sensitive-data protection, or outbound data paths. Cargo.lock is not included, limiting dependency-security review, and recovery guidance is sparse.

Reliability8 / 14 · 2.9/5

The README, AGENTS.md, CLI entry point, and workflows give a coherent account of the Rust desktop app, runnerd, CLI, and PTY responsibilities; CI lists formatting, Clippy, tests, and generated-reference checks across platforms. The CLI entry point reports invalid isolation settings and startup failures. Deductions: the README calls Linux beta and notes limited hardware and distribution validation. CI uses an Ubuntu 22.04 container for Linux Rust jobs, while product documentation mentions a trial on an Ubuntu 26.04 ARM64 VM; the sample does not explain the coverage gap.

Adaptability14 / 18 · 3.9/5

The README targets developers coordinating multiple terminal coding agents and describes crews, missions, real terminals, the CLI, supported agents, platform variation, and linked guides. It states boundaries such as read-only file browsing, Linux beta, and private-beta remote control. Deductions: this sample gives only an overview and external guide links for agent-specific capabilities, resource needs, and audiences beyond developers; the sampled skills cover issue, nightly, and release workflows rather than every product interaction.

Convention14 / 18 · 3.9/5

The repository separates architecture, user guides, feature specs, implementation plans, and test records, with README navigation. It includes an MIT LICENSE, named author, workspace version, and release/nightly procedures. Install and development commands cover macOS, Windows, and Linux, and examples show crew and mission CLI use. Deductions: the sample does not include a complete user installation page, FAQ, or full changelog; the README labels the product Alpha, and notes a historical GPL version period. A maintainer and community channels are named, but response expectations and broader maintenance commitments are not specified.

Effectiveness10 / 13 · 3.8/5

The product offers reusable roles and crews, parallel missions, a shared feed, separate terminals, and a CLI to coordinate multiple coding agents. Sessions remain visible in their own TUIs, and the CLI supports JSON output for scripts. Deductions: the sample does not quantify gains over a single-agent workflow, operating costs, or the cost of resolving multi-agent conflicts; real agents, a daemon, and multiple terminals also add resource and setup overhead.

Verifiability5 / 8 · 3.1/5

README claims can be cross-checked against AGENTS.md vocabulary and architecture, CLI examples, the Cargo workspace, entry-point code, and CI workflows. Platform support and Linux validation limits are stated, and CI lists concrete commands. Deductions: many user-visible capabilities remain README claims because this sample omits their implementation and platform-specific results; this review is based only on supplied static material and does not claim execution or independent reproduction.

Risks and how to mitigate them
  • This is an Alpha product. Linux is marked beta with limited hardware and distribution coverage; remote control is a private beta currently limited to mainland China.
  • Runner starts real CLI agents and keeps a background daemon running. Check each agent's own permissions, sign-in state, and working directory before use.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision 47cd529012f1 New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/runner.svg)](https://followagents.com/en/agents/runner)
<a href="https://followagents.com/en/agents/runner"><img src="https://followagents.com/badge/runner.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.20.2 Runner 0.20.2
    Release notes excerpt
    Runner 0.20.2 is a feature release for macOS, Windows and Linux on top of 0.20.1. It brings git worktrees into the app, reads Codex's status from Codex's own terminal reports, and finishes the fix for remote control dropping and the app hanging. New - Git worktrees in the app. When you start a local chat, terminal or mission inside a Git repository, a Checkout control in the launcher's Location row lets you stay in the main checkout, pick an existing worktree, or choose New worktree… to create a linked worktree under .worktrees/ from a new branch and a base branch. In the si …
    View on GitHub ↗
  2. v0.20.1 Runner 0.20.1
    Release notes excerpt
    Runner 0.20.1 is a bug-fix release for macOS, Windows and Linux on top of 0.20.0. It delivers mission messages to more agents mid-turn, adds macOS line-editing keys in the terminal and git worktrees in the runner CLI, and fixes a crash and an app-wide hang. New - Mission messages reach more agents mid-turn. Messages from the mission inbox now reach a working Codex, pi, Antigravity or OpenCode member during its turn, as they already did for Claude Code, instead of waiting until the turn ends. GitHub Copilot CLI, Cursor and Grok still receive them when idle. (#1369) …
    View on GitHub ↗
  3. v0.20.0 Runner 0.20.0
    Release notes excerpt
    Runner 0.20.0 is a feature release for macOS, Windows and Linux on top of 0.19.9, with first-run setup, a git Changes view with Split diffs, and one theme picker for the app and its terminals. New - First-run setup. A fresh install now opens on Setup instead of an empty launcher. It lists the agents Runner found, installs Claude Code, Codex, GitHub Copilot CLI and pi through npm when it is available, opens a terminal to finish sign-in, and offers a Pair coding starter crew built from your installed agents, two different ones when you have them. Start your first chat crea …
    View on GitHub ↗

FAQ

Does Runner host my code or mission state in the cloud?
The documented architecture runs and persists Runner's settings, chats, and missions on the local machine and uses no webview. Individual agent CLIs may still contact their configured model providers.
Will quitting Runner terminate active agents?
No. Sessions can outlive the application, and Runner reattaches to sessions that are still running on the next launch. It also warns before quitting while work is in flight.
Can one Crew mix Claude Code and Codex?
Yes. Different Crew slots may use different runtimes—for example, Claude Code as the coder and Codex as the reviewer. Both are documented as primary agents.
Is MCP required?
No. Runner can display and toggle existing MCP server configurations, but MCP is not documented as a prerequisite for Missions, Chats, or CLI control.
What permission mode do Missions use?
Missions default to Bypass permission mode. Accept-edits and Default are available through settings, although the exact supported modes vary by agent.
Is Runner Multi-Agent Terminal free?
Yes. Runner Multi-Agent Terminal is free to use and does not need a paid service.
Is Runner Multi-Agent Terminal open source?
Yes. The source code is on GitHub (yicheng47/runner) under the MIT licence.
Is Runner Multi-Agent Terminal still maintained?
Yes. The latest commit on GitHub is from 2026-11-20, within the last 30 days. The latest release is v0.20.2 (2026-11-20).
Who makes Runner Multi-Agent Terminal?
Runner Multi-Agent Terminal is published on GitHub by the account yicheng47. FollowAgents has not verified which person or company is behind that account.
What is Runner Multi-Agent Terminal's official website?
The project's GitHub repository lists https://runnersh.dev/ as its website. That link is set by the repository owner; the source code itself is on GitHub (yicheng47/runner).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts