多个 AI agent 一起干活这事，终于有人用最土的办法做出来了。

squad，一个 Rust 写的命令行工具，让 Claude Code、Gemini CLI、Codex、OpenCode 这几个 CLI agent 直接坐一桌协作。

它的思路特别朴素，没有后台守护进程，全靠 shell 命令加一个 SQLite 数据库传话，每条命令都是一锤子买卖。

玩法也简单，三个终端各开一个：

manager 负责拆任务、派活 worker 负责接活、干活、回报 inspector 在旁边盯着

一句 /squad 就能拉起一整队 AI 帮你打工，多开同角色还会自动编号，worker、worker-2 排好队。

https://github.com/mco-org/squad

mco-org/squad

Source: https://github.com/mco-org/squad

squad

Multi-AI-agent terminal collaboration via simple CLI commands.

squad lets multiple AI CLI agents communicate through shell commands + SQLite.
No daemon, no background processes — every command is a one-shot operation.

English | 简体中文

Claude Code	Gemini CLI	Codex CLI	OpenCode
claude	gemini	codex	opencode

One slash command. Multiple agents collaborating in real-time.

Assign a manager, spin up workers, add an inspector — each in its own terminal, communicating through SQLite.

Install

# Homebrew (macOS)
brew install mco-org/tap/squad

# Windows (GitHub Releases)
# 1. Download squad-x86_64-pc-windows-msvc.zip
# 2. Extract squad.exe to a folder like C:\Tools\squad
# 3. Add that folder to PATH

# Or download another prebuilt binary from GitHub Releases
# https://github.com/mco-org/squad/releases

# Or build from source
cargo install --git https://github.com/mco-org/squad.git

Quick Start

# Install /squad slash command for your AI tools
squad setup

# Initialize workspace in your project
squad init

# In any AI CLI terminal — just use the slash command
/squad manager      # terminal 1
/squad worker       # terminal 2
/squad inspector    # terminal 3

That’s it. Each agent joins, reads its role instructions, and enters a work loop that checks for messages. The manager breaks down your goal and assigns tasks to workers.

Optional tmux Launcher

For Unix-like environments that already use Claude Code, this repo also ships an optional helper script:

scripts/squad-tmux-launch.sh /path/to/project --dry-run

It can:

• read project-local launcher config from .squad/launcher.yaml
• read a task brief from .squad/run-task.md
• generate manager / inspector prompt files under .squad/quickstart/
• start a tiled tmux session and inject /squad commands into Claude panes
• optionally create an isolated git worktree before launching agents

Requirements:

• tmux
• ruby (used to parse launcher.yaml)
• claude

This launcher is intentionally separate from the core Rust CLI. Treat it as optional automation for people who want a repeatable multi-terminal workflow.

Usage Flow

You (human)
  │
  ├── Terminal 1: /squad manager
  │     Manager joins, asks you for the goal,
  │     breaks it into tasks, assigns to workers.
  │
  ├── Terminal 2: /squad worker
  │     Worker joins, checks for tasks via squad receive,
  │     executes assigned work, reports back.
  │
  └── Terminal 3: /squad worker
        Auto-assigned as worker-2 (ID conflict resolved automatically).
        Same behavior — checks, executes, reports.

Multiple agents with the same role get unique IDs automatically (worker, worker-2, worker-3).

Commands

Setup

Install the /squad slash command for your AI tools:

squad setup           # auto-detect and install for all found tools
squad setup claude    # install only for Claude Code
squad setup --list    # show supported platforms

Supported platforms:

Once installed, use /squad <role> (or $squad <role> in Codex) in any project where squad init has been run. Generated slash templates automatically join with their platform client type and the current supported protocol version.

squad init does more than create .squad/: it also appends .squad/ to .gitignore and adds a short squad collaboration section to CLAUDE.md, AGENTS.md, and GEMINI.md when those files do not already contain one. Existing builtin role files stay untouched unless you run squad init --refresh-roles.

How It Works

Agents communicate through a shared SQLite database (.squad/messages.db). Each agent runs in its own terminal and uses CLI commands to send and receive messages.

Terminal 1 (manager)          Terminal 2 (worker)          Terminal 3 (worker-2)
┌─────────────────────┐      ┌─────────────────────┐      ┌─────────────────────┐
│ /squad manager       │      │ /squad worker        │      │ /squad worker        │
│                      │      │ (auto-ID: worker)    │      │ (auto-ID: worker-2)  │
│                      │      │                      │      │                      │
│ squad task create    │─────>│ squad receive worker │      │                      │
│   manager worker     │      │                      │      │                      │
│   "task-a" "details" │      │                      │      │                      │
│                      │      │                      │      │                      │
│ squad task create    │──────────────────────────────────>│ squad receive         │
│   manager worker-2   │      │                      │      │   worker-2           │
│   "task-b" "details" │      │                      │      │                      │
│                      │      │                      │      │                      │
│ squad receive manager│<─────│ squad task complete  │      │                      │
│                      │      │   worker <task-id>   │      │                      │
│                      │      │   "done A"           │      │                      │
│                      │      │                      │      │                      │
│                      │<──────────────────────────────────│ squad task complete   │
│                      │      │                      │      │   worker-2 <task-id> │
│                      │      │                      │      │   "done B"           │
└─────────────────────┘      └─────────────────────┘      └─────────────────────┘

All messages flow through SQLite — no daemon, no sockets, no background processes.

Message Flow

Agents should prefer squad task ... when assignment state matters, and keep squad send / squad receive as the fallback path for freeform coordination. Agents use squad receive --wait to block until messages arrive:

Agent joins
  → squad receive <id> --wait          ← blocks until a message arrives
  → receives task from manager
  → squad task ack <id> <task-id>
  → executes the task
  → squad task complete <id> <task-id> --summary "done: summary..."
  → squad receive <id> --wait          ← blocks again for next message

squad receive <id> (without --wait) checks once and returns immediately, useful for scripting or manual checks.

ID Auto-Suffix

When multiple agents join with the same ID, squad automatically assigns unique IDs:

squad join worker --role worker --client codex --protocol-version 2
# → Joined as worker

squad join worker --role worker --client opencode --protocol-version 2
# → ID 'worker' was taken. Joined as worker-2

This is handled server-side (atomic INSERT OR IGNORE), so even simultaneous joins from different terminals are safe.

Agent Capability Metadata

squad join can optionally record agent capability metadata:

squad join worker --role worker --client codex --protocol-version 2

• If --client or --protocol-version is omitted, the database stores NULL.
• squad agents shows client/protocol details in human-readable output using the effective fallback view, so legacy rows appear as client: unknown, protocol: 1.
• squad agents --json exposes client_type_raw, protocol_version_raw, effective_client_type, effective_protocol_version, supports_task_commands, and supports_json_receive.
• In the current phase, supports_task_commands and supports_json_receive are both derived from the effective protocol version, with support enabled at protocol >= 2.

Role Templates

Roles are .md files in .squad/roles/ that define agent behavior. Three are built in:

• manager — breaks down goals, assigns tasks, coordinates review
• worker — executes tasks, reports results
• inspector — reviews code, sends PASS/FAIL verdicts

Create custom roles by adding .md files to .squad/roles/:

echo "You are a database specialist..." > .squad/roles/dba.md
squad join db-expert --role dba

If the builtin role templates in .squad/roles/ drift from the bundled defaults, run squad init --refresh-roles to refresh only manager.md, worker.md, and inspector.md. Custom role files are left untouched.

Team Templates

Teams are YAML files in .squad/teams/ that define which roles are needed:

# .squad/teams/dev.yaml
name: dev
roles:
  manager:
    prompt_file: manager
  worker:
    prompt_file: worker
  inspector:
    prompt_file: inspector

View a team’s setup instructions:

squad team dev

Broadcast

Send a message to all agents at once:

squad task create manager worker --title "auth-module" --body "implement auth module with JWT"
squad task ack worker <task-id>
squad task complete worker <task-id> --summary "JWT auth shipped"
squad send --task-id <task-id> inspector worker "please handle follow-up edge cases"
squad receive worker --json
squad send manager @all "API contract changed, update your implementations"

Requirements

• Rust 1.77+ (for building)
• macOS or Linux

License

MIT

鸟哥 | 蓝鸟会🕊️ (@NFTCPS): 不会画架构图，但又得给老板/同事讲清楚系统长啥样？这事现在真不用愁了。

Archify 这个东西，你拿大白话把系统描述一遍，它直接给你生成一张好看的架构图，还支持工作流、时序、数据流、状态机这几种。

我觉得最香的几点： 1️⃣ 一键切深色浅色，不用来回导两张图 2️⃣ PNG 能直接复制，粘到