swarm-work

Dispatch parallel worker agents with dependency-aware batching and test gating.

4|1|Updated Mar 8, 2026
One-click install
npx skills add https://github.com/MaxGzLi/claudeorc --skill swarm-work
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: swarm-work
Source: https://github.com/MaxGzLi/claudeorc/tree/main/skills/swarm-work
Command: npx skills add https://github.com/MaxGzLi/claudeorc --skill swarm-work

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Coordinating implementation tasks across multiple contributors and worktrees is error-prone and slow when done manually, especially when tasks have dependencies and require tests after each integration step. Swarm-work automates dispatch, isolated execution, merging, and test gating so maintainers can safely scale parallel work without corrupting the main tree.

Core Features & Use Cases

  • Dependency-aware batching: Parses a plan, builds a dependency graph, and runs only tasks whose dependencies are satisfied.
  • Worktree isolation and parallel execution: Dispatches up to five worktree-isolated worker agents per batch so each task runs in its own branch and environment.
  • Safe integration and test gating: Retries failed workers once, merges branches sequentially with --no-ff, runs detected test suites after each batch, and stops on conflicts or persistent failures.
  • Use case: Ideal for executing implementation plans like adding authentication, utilities, or config loaders where tasks specify files, acceptance criteria, and explicit dependencies.

Quick Start

Run the swarm-work skill with the path to your plan file to execute tasks in isolated worktrees, run tests after each batch, and receive a final completion report.

Frequently Asked Questions about swarm-work

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I execute repository implementation plans with parallel isolated git worktrees?

Dispatch parallel worker agents to execute implementation plans using dependency-aware batching and worktree isolation, running up to five concurrent workers per batch to safely scale parallel work without corrupting the main tree.

How does dependency graph parsing work for parallel task execution?

Dependency graph parsing builds a task hierarchy from your implementation plan, ensuring only tasks with satisfied dependencies are dispatched in isolated worktrees, preventing execution errors and integration conflicts during parallel batch execution.

Can I run test suites automatically after merging parallel git branches?

Yes, automatic test command detection runs detected test suites after each batch of tasks is merged sequentially using --no-ff, stopping the process immediately upon test failures or merge conflicts to protect repository stability.

What happens when a parallel worker fails during worktree execution?

When a worker fails during worktree execution, the system retries that specific worker once, then stops the entire process if the failure persists, preventing persistent errors from corrupting the main tree during sequential git merges.

Do I need a specific plan format to use dependency-aware batching?

You need a repository-level implementation plan that explicitly lists tasks, file targets, dependencies, and acceptance criteria, which the dependency graph parser uses to dispatch isolated worktree workers and batch tests.

What is the best way to coordinate contributors across multiple git worktrees without manual errors?

Automating dispatch, isolated execution, sequential --no-ff merges, and test gating is the best way to coordinate parallel work, eliminating manual errors and safely scaling contributions across multiple worktrees without corrupting the main tree.