dag-fleet

Solid

Persistent, budgeted, DAG-ordered runner for parallel `claude -p`, `codex exec`, or `pi -p` workers in tmux. Use ONLY when you need persistence across sessions, per-worker budget caps, dependency ordering, or mixed models/providers per worker. For ad-hoc parallel sub-agents inside a live conversation, use Claude Code's built-in Agent tool instead.

AI & Automation 1 stars 0 forks Updated 4 days ago Apache-2.0

Install

View on GitHub

Quality Score: 80/100

Stars 20%
10
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
80
License 10%
100
Description 5%
100

Skill Content

# Fleet A skill for running parallel `claude -p`, `codex exec`, or `pi -p` workers in tmux with budgets and DAG dependencies. Supports Claude, Codex, and Pi providers — set per-fleet or per-worker. Operator owns all kill / steer / re-direction — there is no auto-restart, no auto-verify, no babysitter loop. ## Prerequisites - **bash >= 4.0** — macOS ships bash 3.2 (from 2007). Install modern bash: `brew install bash` - **flock** — Linux built-in. macOS: `brew install flock` - **tmux** — `brew install tmux` or `apt install tmux` - **jq** — `brew install jq` or `apt install jq` ### macOS quick-start ```bash brew install bash tmux jq flock # Then invoke launch.sh explicitly with bash 4+: /opt/homebrew/bin/bash /path/to/dag-fleet/scripts/launch.sh <fleet-root> ``` If `flock` is unavailable, `launch.sh` will skip locking with a warning. Pass `--no-lock` to suppress the warning. ## When to use this skill (and when NOT to) **FIRST: prefer Claude Code's built-in Agent tool when any of these are true.** It's simpler, faster, and avoids the fleet machinery entirely. - The work fits inside the current conversation - All sub-agents will finish in under 10 minutes - You'll synthesize the results in the same session - You don't need budget caps or dependency ordering **Reach for THIS skill only when ≥1 of these is true:** - **Persistence:** the run will outlive the parent `claude` process (e.g. multi-hour fleet, user closes laptop) - **Per-worker budgets:** you need `max_budget_usd...

Details

Author
quickcall-dev
Repository
quickcall-dev/skills
Created
4 months ago
Last Updated
4 days ago
Language
Shell
License
Apache-2.0

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Listed

fleet

Use when managing multiple Claude Code sessions — "fleet", "spawn workers", "manage sessions", "dispatch task to <project>", "check on workers", "boot a supervisor", parallel work across projects, long-running babysat jobs, or review pipelines. Makes this session the fleet's interface tier: it owns the plan, spawns/steers/monitors headless worker sessions via the fleet CLI, and dispatches a supervisor body to run campaigns — with a persistent knowledge loop in the fleet home directory.

3 Updated 1 weeks ago
exPardus
AI & Automation Solid

suede-codex-fleet

Claude-directed parallel OpenAI Codex CLI worker fleet for bulk generation. Use when a job is high-volume, well-specified, and splits into independent worker-sized tasks (content batches, test generation, bulk refactors) and Codex CLI is installed and logged in. Claude decomposes, briefs, spawns codex exec runs in parallel, and review-gates every output. Workers are always codex exec processes billed to the user's OpenAI subscription — never substitute Claude subagent fan-out on any model, and halt rather than fall back if Codex CLI is unavailable. NOT FOR: multi-lane Claude agents coordinating one complex change (use suede-agent-teams); low-volume, judgment-dense copy Claude should write itself (use suede-copy or johnny-suede-write).

151 Updated 2 days ago
JasonColapietro
Code & Development Solid

worktree-fleet

Independence-validated parallel fleet that runs each worker (claude -p, codex exec, or pi -p) in its own git worktree. Use when tasks touch non-overlapping files and you need merge-safe isolation (each worker on its own branch). For DAG-ordered one-shot workers with budgets, use dag-fleet. For headless iteration with a reviewer loop, use iterative-fleet.

1 Updated 4 days ago
quickcall-dev