crew

A Claude Code skill for running a fleet of AI agents: the premium model coordinates, cheaper subscription and local models do the volume.

crew turns your Claude Code session into the coordinator of an agent fleet. It owns strategy, briefs, review, and verification, and never writes volume itself. The reference pipeline:

• Coordinator — Claude Code (premium subscription). Strategy, spec review, verification, merge.
• Spec-writer — a pi agent on a flat-rate subscription (GLM, Codex). Writes the verbatim-executable plan.
• Builder — a local model (self-hosted, OpenAI-compatible). Transcribes the plan into code.

Each worker runs in a visible, addressable pane. The skill is coordinator doctrine only.

Why

• A premium subscription is metered; flat-rate pools and a local model are free at the margin. crew spends premium tokens on judgment only — strategy, the plan, review, verification — and pushes token volume down to the cheaper tiers. Most inference ends up on hardware you own.
• A local model transcribes a detailed plan well and reasons poorly on open-ended work. A verbatim-executable plan removes the room to improvise, so the local typist stays faithful to the design.
• The claim is bounded: sovereignty over inference volume and privacy, not judgment. The coordinator is still a rented frontier model, and the crew cannot run without it. As local models get better at judgment, that layer thins.

The doctrine in five rules

1. One default pipeline, one fork. Coordinator → spec-writer → builder → coordinator verifies. The only fork is can the deliverable be verbatim-planned? Coding work usually can; knowledge work (analysis, research, browser-driven work) cannot and takes the flat-rate knowledge lane, never the local typist. Anything else is an exception, and exceptions surface.
2. Every dispatch announces itself. A one-line ROUTE: statement before any tokens burn, so the human vetoes cheaply and up front.
3. Deviations ask first. Local server down, design work that can't be spec'd, a typist stuck twice — the coordinator stops and asks with a recommendation. It never silently promotes work to a metered pool.
4. Completion is push, not pull. Every briefing ends with a report-back line that lands in the coordinator's pane. A background watchdog exists only to catch dead agents.
5. DONE is a signal to verify, never a claim to accept. Git log against the plan, tests re-run by the coordinator, behavioral checks, screenshots for UI.

            ┌─────────────────────────────────────────────┐
            │  COORDINATOR (premium — judgment only)      │
            │  strategy · briefs · review gate · verify   │
            └──────┬───────────────────────────▲──────────┘
                   │ brief                     │ DONE/BLOCKED (push)
            ┌──────▼──────────┐         ┌──────┴──────────┐
            │  SPEC-WRITER    │  plan   │  BUILDER        │
            │  (flat-rate)    │────────▶│  (local, free)  │
            │  verbatim plan  │  gate   │  transcribes    │
            └─────────────────┘         └─────────────────┘

Substrates

The doctrine carries no multiplexer commands. SKILL.md is substrate-agnostic; each file in substrates/ supplies the verbs for one multiplexer:

• substrates/herdr.md — herdr, a purpose-built agent multiplexer with semantic per-pane agent-status detection.
• substrates/cmux-tmux.md — cmux plus a small tmux hook that gives each surface its own persistent session (GUI crash doesn't kill work; reattach over ssh). Dead-agent detection is timeout-based here rather than semantic.

The doctrine transfers to any pane-based setup (tmux, zellij) with a wait-for-output wrapper you write yourself.

What you need

• A pane-based multiplexer (herdr, or cmux + tmux).
• An agent CLI that pins models per invocation (the reference uses pi). Every dispatch pins provider/model explicitly, because CLI defaults drift.
• Three model tiers, filled into the table at the top of SKILL.md:
  • premium — the coordinator's own subscription
  • flat-rate — subscription-included pools (spec-writing, research)
  • local — a self-hosted OpenAI-compatible server (builds, and the only lane allowed to touch private data)

Without a local server the flat-rate pool builds too; you lose the free, private build lane.

Install

# 1. Your multiplexer — install per its own README:
#    herdr:       https://github.com/ogulcancelik/herdr
#    cmux:        https://github.com/manaflow-ai/cmux ; then substrates/cmux-tmux.md (tmux hook)
# 2. This skill (Claude Code):
git clone https://github.com/igor/crew-skill
cp -r crew-skill ~/.claude/skills/crew

Edit the Your stack table in SKILL.md to match your providers. The skill activates when the session runs inside a supported multiplexer.

Validation

Cold-read scenario evals: fresh agent sessions were each given only the skill text plus one scenario, and their routing decisions checked against intended behavior.

Scenario	Expected behavior	Result
Routine, well-specified build	Route line → spec → local build → verify ladder	pass
Taste-driven design exploration	Blocking ask before any dispatch	pass
Private-data task	Every stage local, stated not asked	pass
Local server down, plan ready	Park the plan, ask with alternatives	pass
Tiny fix, spec not worth delegating	Visible "SPEC: writing myself" line, build still local	pass
Browser-driven analysis (Playwright)	Knowledge lane: flat-rate generation, no local model, no blocking ask	pass

Anatomy

Section (SKILL.md)	What it gives you
Routing	The two lanes (verbatim-planned vs knowledge work), equipped archetypes, the ROUTE: line, deviation and hard-override rules
Surface topology	One workspace, panes then tabs, coordinator-owned teardown
Dispatch	The hire pattern: labeled pane per agent, watchdog per dispatch
Completion	The push-based DONE/BLOCKED protocol
Briefing templates	Spec-writer, builder, researcher — self-contained, copy-paste
Review gate	What the coordinator checks before any plan reaches a builder
Verification ladder	The steps after every DONE; delegate the capture, never the verdict
Failure playbook	Real incidents and their fixes

License

MIT © 2026 Igor Schwarzmann