πŸ•Έ Conductor V2 Β· fire the fleet

Design the formation. Then fire it.

Conductor V1 watches windows you opened by hand. V2 flips the order: pick a formation, set one purpose, press FIRE β€” and a fleet of Claude Code windows launches into tmux and coordinates on its own.

$ claude mcp add conductor2 --scope user -- node ~/conductor-v2/mcp.js
tmux: conductor2 β€” swarm β€œx402-research” Β· mesh Β· 4 peers Β· fable-5
p1 Β· landscape ← initiator
β€Ί Wrote out/landscape.md (11 players)
β†’ say p2 "see out/landscape.md, your turn on evidence"
p2 Β· evidence
β€Ί Reading out/landscape.md…
β€Ί Pulling primary sources (3 repos, 2 PRs)
p3 Β· red-team
β€Ί Hunting counter-evidence
β†’ say p1 "the 93% claim is unsourced β€” flagging"
p4 Β· numbers
β€Ί out/figures.csv β€” volumes + pricing
β€Ί 8 figures, each with a source URL
The formations

Three shapes. The formation decides who talks to whom β€” and who starts.

πŸ›

Hierarchical

Orchestrator β†’ workers
      β”Œβ”€ ORC ─┐
  β”Œβ”€β”€β”€β”Όβ”€β”€β”€β”¬β”€β”€β”€β”Όβ”€β”€β”€β”
  w1  w2  w3  w4

One orchestrator decomposes the mission, delegates a single task per worker, collects their reports, and synthesizes the final result.

Best when the mission splits into independent chunks.
β›“

Pipeline

Sequential stages
s1 ─▢ s2 ─▢ s3 ─▢ s4
 each stage hands
 off to the next

Stages run in order; each consumes the previous stage's output and hands off to the next. Initiator is the first stage.

Best when there's a natural assembly line β€” recon β†’ audit β†’ verify β†’ report.
πŸ•Έ

Mesh

Peer-to-peer
  p1 ─── p2
   β”‚ β•² β•± β”‚
   β”‚ β•± β•² β”‚
  p3 ─── p4

Equal peers self-organize: each claims a distinct angle, works it, and broadcasts findings to the others. Peer 1 doubles as scribe.

Best when you want breadth β€” sweep a space from several directions at once.
How they coordinate

Two dumb, reliable channels

No message bus, no new infrastructure. A swarm coordinates the way people do: shared files and short pings.

  • β†’ Files β€” a shared swarm directory ~/.conductor2/swarms/<name>/ holds the mission, out/ artifacts, and notes/. Files are the source of truth.
  • β†’ Messages β€” swarm-say <window> "<one line>" for handoffs and pings; anything longer goes in a file with a pointer.
  • β†’ Each window's role briefing is written to disk; the window is kicked off with a one-liner pointing at it β€” long prompts never ride through tmux send-keys.
  • β†’ A baked-in member allowlist means a window can't message outside its own swarm; launch order is receivers-before-initiators so no ping lands on a window that doesn't exist yet.
~/.conductor2/swarms/x402-research/
# the swarm's shared brain mission.md prompts/ # per-agent briefings p1.md p2.md p3.md p4.md out/ # real work products landscape.md figures.csv REPORT.md notes/ # scratch swarm-say # member-scoped ping helper
Presets

Premade swarms β€” fire as-is, or edit the purpose first

πŸ”¬

Deep Research

hierarchical Β· 5 agents

Orchestrator splits a research question across 4 researchers β€” landscape, evidence, red-team (counter-evidence), numbers β€” then synthesizes one cited, decision-grade report.

πŸ“ˆ

Market Bot Management

mesh Β· 3 agents

Three peers each take one trading desk: confirm the bots are alive, audit the last 24h from the ledgers, and propose tuning. Read-only β€” changes go in the report for a human.

πŸ›‘

Web3 & Security

pipeline Β· 4 agents

Sequential review: recon maps the attack surface, the auditor digs line-by-line, the verifier reproduces or kills each finding, the reporter writes a severity-ranked fix list.

The swarm MCP

Plan and fire a fleet from any agent

Conductor V2 speaks MCP over stdio, so any MCP-aware agent can design a swarm, preview it, fire it, and stop it β€” natively. Read tools are free; the two that spawn or kill processes are flagged.

Tool
What it does
Kind
list_formations
The three formations with diagram + when-to-use.
read
list_presets
Premade configs (deep-research, market-bots, web3-security).
read
plan_swarm
Dry run β€” resolve a config into concrete agents + briefings, launch nothing.
read
list_swarms
Live swarms grouped from the managed-window registry.
read
fire_swarm
Launch the fleet β€” N tmux windows, each kicked off with its briefing. All-or-nothing.
spawns
stop_swarm
Kill every window of a swarm. Irreversible β€” confirm first.
kills

Watch a fired swarm from the V1 cockpit too β€” every window is a normal Claude Code session, so the claude-code adapter sees them, grouped by status, problems first.

Get started

Fire your first swarm

Clone V2, register the MCP, and ask any session to plan and fire a fleet.

# clone V2 $ git clone https://github.com/yksanjo/conductor2 ~/conductor-v2 # register the swarm MCP (user scope = everywhere) $ claude mcp add conductor2 --scope user -- node ~/conductor-v2/mcp.js # then, from any session: β€Ί plan a pipeline swarm of 4 to security-review ~/soag-gate, show me the briefings, then fire it