affaan-m/ecc

claude-devfleet

Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports. Use when dispatching parallel coding agents across isolated worktrees and tracking their reports.

All-time #1983 Trending #2681 First seen May 19, 2026
8-week activity · all time api

Installation

$ npx skills add affaan-m/ecc --skill claude-devfleet

Similar popular skills

Related neighbors and high-traction skills in the same topics — useful to compare before installing.

Also in this package

Other skills from affaan-m/ecc · top by installs.

npx skills add affaan-m/ecc

Browse all from affaan-m/ecc

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Repository health

Stars 254.3K
License LICENSE
Default branch main
Open issues 54
Status Active

Skill metadata

Parsed from SKILL.md frontmatter.

Declared agents claude-code
More metadata
origin
community

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 6,216 B
  • docs SUMMARY.md 288 B

History

  1. First seen on skills.sh
  2. First recorded snapshot · 7,840 installs

SKILL.md

Claude DevFleet Multi-Agent Orchestration

When to Use

Use this skill when you need to dispatch multiple Claude Code agents to work on coding tasks in parallel. Each agent runs in an isolated git worktree with full tooling.

Setup

The DevFleet server is a separate project, not bundled with ECC. Install and run it from its repository first: <https://github.com/LEC-AI/claude-devfleet>;

Then connect the running instance via MCP:

claude mcp add devfleet --transport http http://localhost:18801/mcp

Before first use, verify the process listening on port 18801 is the DevFleet binary you installed (see SECURITY.md on localhost MCP servers).

How It Works

User → "Build a REST API with auth and tests"
  ↓
plan_project(prompt) → project_id + mission DAG
  ↓
Show plan to user → get approval
  ↓
dispatch_mission(M1) → Agent 1 spawns in worktree
  ↓
M1 completes → auto-merge → auto-dispatch M2 (depends_on M1)
  ↓
M2 completes → auto-merge
  ↓
get_report(M2) → files_changed, what_done, errors, next_steps
  ↓
Report back to user

Tools

Tool Purpose
plan_project(prompt) AI breaks a description into a project with chained missions
create_project(name, path?, description?) Create a project manually, returns project_id
createmission(projectid, title, prompt, dependson?, autodispatch?) Add a mission. dependson is a list of mission ID strings (e.g., ["abc-123"]). Set autodispatch=true to auto-start when deps are met.
dispatchmission(missionid, model?, max_turns?) Start an agent on a mission
cancelmission(missionid) Stop a running agent
waitformission(missionid, timeoutseconds?) Block until a mission completes (see note below)
getmissionstatus(mission_id) Check mission progress without blocking
getreport(missionid) Read structured report (files changed, tested, errors, next steps)
get_dashboard() System overview: running agents, stats, recent activity
list_projects() Browse all projects
listmissions(projectid, status?) List missions in a project

Note on waitformission: This blocks the conversation for up to timeoutseconds (default 600). For long-running missions, prefer polling with getmission_status every 30–60 seconds instead, so the user sees progress updates.

Workflow: Plan → Dispatch → Monitor → Report

  1. Plan: Call planproject(prompt="...") → returns projectid + list of missions with dependson chains and autodispatch=true.
  2. Show plan: Present mission titles, types, and dependency chain to the user.
  3. Dispatch: Call dispatchmission(missionid=<firstmissionid>) on the root mission (empty dependson). Remaining missions auto-dispatch as their dependencies complete (because planproject sets auto_dispatch=true on them).
  4. Monitor: Call getmissionstatus(missionid=...) or getdashboard() to check progress.
  5. Report: Call getreport(missionid=...) when missions complete. Share highlights with the user.

Concurrency

DevFleet runs up to 3 concurrent agents by default (configurable via DEVFLEETMAXAGENTS). When all slots are full, missions with autodispatch=true queue in the mission watcher and dispatch automatically as slots free up. Check getdashboard() for current slot usage.

Examples

Full auto: plan and launch

  1. plan_project(prompt="...") → shows plan with missions and dependencies.
  2. Dispatch the first mission (the one with empty depends_on).
  3. Remaining missions auto-dispatch as dependencies resolve (they have auto_dispatch=true).
  4. Report back with project ID and mission count so the user knows what was launched.
  5. Poll with getmissionstatus or get_dashboard() periodically until all missions reach a terminal state (completed, failed, or cancelled).
  6. getreport(missionid=...) for each terminal mission — summarize successes and call out failures with errors and next steps.

Manual: step-by-step control

  1. createproject(name="My Project") → returns projectid.
  2. createmission(projectid=projectid, title="...", prompt="...", autodispatch=true) for the first (root) mission → capture rootmissionid.

createmission(projectid=projectid, title="...", prompt="...", autodispatch=true, dependson=["<rootmission_id>"]) for each subsequent task.

  1. dispatchmission(missionid=...) on the first mission to start the chain.
  2. getreport(missionid=...) when done.

Sequential with review

  1. createproject(name="...") → get projectid.
  2. createmission(projectid=projectid, title="Implement feature", prompt="...") → get implmission_id.
  3. dispatchmission(missionid=implmissionid), then poll with getmissionstatus until complete.
  4. getreport(missionid=implmissionid) to review results.
  5. createmission(projectid=projectid, title="Review", prompt="...", dependson=[implmissionid], auto_dispatch=true) — auto-starts since the dependency is already met.

Guidelines

  • Always confirm the plan with the user before dispatching, unless they said to go ahead.
  • Include mission titles and IDs when reporting status.
  • If a mission fails, read its report before retrying.
  • Check get_dashboard() for agent slot availability before bulk dispatching.
  • Mission dependencies form a DAG — do not create circular dependencies.
  • Each agent runs in an isolated git worktree and auto-merges on completion. If a merge conflict occurs, the changes remain on the agent's worktree branch for manual resolution.
  • When manually creating missions, always set auto_dispatch=true if you want them to trigger automatically when dependencies complete. Without this flag, missions stay in draft status.