agentleFS
Sagargupta16Sagargupta16/foreman/skills/dispatch/SKILL.md

dispatch

Skill1 starsChanged 12 days agoMITView on GitHub

Splits a task into subtasks, hands each one to a foreman agent type (scout, mechanic, researcher, builder, writer, reviewer, verifier, architect, debugger, specialist) and picks Haiku, Sonnet, Opus or Fable for each by the kind of work, then runs them in dependency waves, integrates the results and verifies once. Starts from task templates (feature, bugfix, refactor, migration, research, review, docs) and checks every plan with a script before any agent starts. Use when the user asks to split, break down, delegate, orchestrate or parallelize a task, says "use agents", "use subagents" or "fan this out", asks which model should do which part, or gives a task with several independent parts across many files, sources or questions. A one-unit task is done inline instead.

45 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use edge-detection, odds-analysis and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • noahowshSkill

    edge-detection

    Comparing a tennis model's probability with the market: no-vig close, expected value at the best available price, closing line value, fractional Kelly sizing, and the checks that separate an estimated edge from noise. Use when the user has a probability and wants to know whether a price is better than fair, how large a stake is reasonable, or whether an edge is real. Requires a probability the user trusts. Do not use for fetching prices: see odds-explorer. Do not use for devig math alone: see odds-analysis. Do not use for historical testing: see backtesting.

    Also in 4 projects that use this

  • noahowshSkill

    odds-analysis

    Odds math for two-way tennis markets: American to implied probability, margin, devigging (multiplicative, power, Shin), no-vig fair odds, consensus across books, favorite-longshot bias, and expected value of a price. Use when the user asks what a price implies, how to remove the vig, what the true probability is, or how to compare books. Do not use for fetching or comparing live prices: see odds-explorer. Do not use for deciding a bet against a model: see edge-detection.

    Also in 4 projects that use this

  • agiprolabsSkill

    walk-forward-validation

    Walk-forward validation framework for trading strategies and ML models with time-series-aware splits, overfit detection, and regime-aware validation

    Also in 4 projects that use this

  • Yahmez3Skill

    backtesting

    Use when backtesting a trading strategy — evaluating a signal series against historical price data and computing performance metrics (Sharpe, Sortino, max drawdown, CAGR, win rate, expectancy). Triggers on "backtest this strategy", "what's the Sharpe on X", "run a walk-forward test", or "compare strategies A and B". Produces equity curves, trade logs, and tear sheets.

    Also in 4 projects that use this

  • ffsshhttiikkSkill

    feature-engineering

    Machine learning feature engineering

    Also in 4 projects that use this

  • varun29ankuSSkill

    orchestrate

    This skill should be used when the user asks to 'orchestrate a task', 'break down work into parallel agents', 'coordinate subtasks', 'run agents in parallel', or mentions 'multi-agent'. Decomposes complex tasks into tracked subtasks, dispatches parallel subagents, and coordinates until completion.

    Also in 4 projects that use this

  • +3 more from noahowsh

The file

We split this skill into the rules it gives an agent

7 rules. 0 are common, 3 are distinctive, and 4 are very specific to this project.

  • 0

    Common

    Most of the 43 edited versions we read keep these.

  • 3

    Distinctive

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Keep the default unless a signal in references/routing.md moves the subtask a tier up or down.

    line 114
  2. Very specific:

    Launch one wave: Every subtask of the wave goes out in ONE message: one Agent call each, with subagent_type set to the subtask's agent …

    line 135
  3. Distinctive:

    Verify once: Run the project's own check (tests, type check, build or lint, whichever the repo uses) one time here, read the full diff …

    line 173
  4. Distinctive:

    Run the project's full check per agent.

    line 220
  5. Distinctive:

    Put a secret's value in a brief.

    line 221
  6. Very specific:

    Read 2026-11-04, ideas paraphrased: code.claude.com docs sub-agents.md (model resolution order, plugin agent fields, nesting depth), …

    line 230
  7. Very specific:

    Read 2026-11-12, ideas paraphrased, no text copied: affaan-m/ECC (MIT, d2ef268) agents/code-reviewer.md (proof for high-severity findings), …

    line 261

“Common” is measured: kept by at least 6 in 10 of the 43 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

dispatch

You are the foreman. You plan the work, launch the agents, read every result and own the final answer. Agents do subtasks; they never commit, push, merge or launch agents of their own. The plan is checked by a script before anything runs, because the mistakes that sink multi-agent work (two agents editing one file, a missing dependency, a model picked by habit) are mechanical and easy to catch early.

This skill runs its turn on Sonnet (model: sonnet above). By foreman's own routing rule, following a written procedure is Sonnet work; the judgement calls go to subtasks: design to the architect and debug to the debugger, both on Opus, and a unit too tangled to split to the specialist on Fable. In a measured run the coordinating session was 98% of the cost, so this is where the saving is.

Task: $ARGUMENTS

Read first

  • references/routing.md: kinds of work, when to move a subtask up or down a model tier, what the top tier is for, the failure ladder
  • references/decompose.md: how to split, file ownership, waves, the plan JSON fields
  • references/briefs.md: the brief each agent gets, shaped by model tier, and the return block each agent sends back
  • references/integrate.md: after each wave, the final check, the report, the run log
  • references/workflow.md: when a plan is too big for one session, compile it into a Workflow script

The plan tool is ${CLAUDE_SKILL_DIR}/scripts/plan.py (Python 3.12+, standard library only). The commands below say python3; on Windows use python or py when python3 is not found. With no Python at all, apply the rules in references/decompose.md by hand and say so.

Procedure

  1. Qualify. Delegation is not free: Anthropic measured multi-agent runs at about 15 times the tokens of a chat. Do the task inline, say "one unit, doing it inline" and stop using this skill when any of these hold:
signalwhy it stays inline
one file, or every part edits the same filenothing to parallelize; ownership cannot be split
fewer than about five tool calls in totalthe briefs cost more than the work
each part needs the previous part's full contexthandoffs lose the detail that matters
you could not tell a wrong answer from a right onean unchecked agent result is a guess

One unit, but hard (a root cause nobody has reproduced, a design that cannot be undone, a long chain where each step needs the last): do not do it on this turn's model. Plan it as a single solve subtask for the specialist, check it and launch it. This turn runs on Sonnet, and that work is what the top tier is for.

More than 20 subtasks, or the user asked for a workflow ("use a workflow", "orchestrate this"): plan and check as usual, then compile the plan per references/workflow.md and offer the Workflow run. Wait for the user's yes; Workflows need their explicit opt-in.

  1. Pick a template. List them:
python3 "${CLAUDE_SKILL_DIR}/scripts/plan.py" templates

Match on what the task does to what: a failure to explain is bugfix, the same change across many files is migration, a question across sources is research. Project templates in .claude/foreman/templates/ show as project. Nothing fits: write a custom plan with the same fields.

  1. Start the plan from the template with the user's words verbatim:
python3 "${CLAUDE_SKILL_DIR}/scripts/plan.py" new feature --task "<the user's request>"

Fill it in per references/decompose.md: a goal per subtask in terms of this task, owns for every subtask that writes, reads, after, and a verify you can actually check. Expand each fan_out step into one subtask per unit (build-api, build-ui) and delete the hint. Drop a step whose skip_when holds, delete the hint, and say which steps you dropped. When you do not know the files yet, run the map subtask first and fill the rest from its result: a plan can be checked in two passes.

  1. Route. Each kind has a default agent, model and effort:
python3 "${CLAUDE_SKILL_DIR}/scripts/plan.py" routes

Keep the default unless a signal in references/routing.md moves the subtask a tier up or down. Any change of agent or model gets a why field in the subtask, one line. Fable is the top tier and the exception: at most two subtasks in a plan, for a unit that cannot be split (solve) or work that already beat opus.

  1. Check the plan and show the user the table it prints:
python3 "${CLAUDE_SKILL_DIR}/scripts/plan.py" check - <<'EOF'
{ "task": "...", "template": "feature", "subtasks": [ ... ] }
EOF

Fix every error and rerun until result: ok. Read every warning and act on it or say why not. Pass the plan on stdin as shown. Never write a plan file inside the user's repo: a plan too long for stdin goes to the system temp folder and is deleted when the run ends. If the user asked to see the plan first, stop here and wait for their go.

  1. Launch one wave. Every subtask of the wave goes out in ONE message: one Agent call each, with subagent_type set to the subtask's agent (foreman:builder), model set to its model, effort set to its effort, description set to its id exactly, and the brief from references/briefs.md as the prompt. Model and effort are columns of the table plan.py check printed; take them from there, never from memory of the agent file: a project route or a rerun changes them, and the agent file does not know. On Claude Code before 2.1.292 the Agent tool has no effort; leave it out there. The description is how a captured run finds its subtask in the log.

    Agents start in the background unless the call asks to wait. Where the reports come back decides which model integrates them, because this skill's Sonnet model holds only for the current turn:

    • The Agent tool has a run_in_background parameter (claude -p, the Agent SDK, or a session with fork mode off): set it to false on every call of the wave. Your next action depends on every report, so each call waits and returns its agent's report, and you integrate in this turn. Left unset, the agents start in the background here too.
    • It has no such parameter, or a call returns only that the agent was launched. Interactive terminal, VS Code and desktop sessions keep subagents in the background, and their reports arrive as notifications in later turns, which run on the session's model. In a measured run that moved integration onto Opus and cost more than the agents. Do not poll, relaunch or guess a result: end the turn with the plan table and one line saying the wave is running, and continue from step 7 when the reports arrive. Tell the user once that integration here runs on the session's model, and that /model sonnet for the run, or CLAUDE_CODE_FORK_SUBAGENT=0 in settings, keeps it on Sonnet.
  2. Integrate the wave per references/integrate.md: read every return block, check that changed paths sit inside each subtask's owns, carry the results the next wave needs into its inputs, and send a failed subtask up the ladder.
  3. Repeat steps 6 and 7 until the last wave returns.
  4. Verify once. Run the project's own check (tests, type check, build or lint, whichever the repo uses) one time here, read the full diff yourself, and weigh the verifier's verdicts. A red check is fixed here in the main session, not by relaunching every lane.
  5. Log the run, before the report. The report is your last message, so a step after it gets skipped. Add each subtask's outcome to the plan JSON (status, attempts, final_model, final_effort, verified, failure_reason in one line for a subtask that did not finish, and tokens and duration_ms when the Agent result showed them) plus "coordinator": the model you are running on, and append it to the run log:
python3 "${CLAUDE_SKILL_DIR}/scripts/plan.py" log - <<'EOF'
{ "task": "...", "template": "feature", "coordinator": "<your model>", "subtasks": [ ... ] }
EOF
`plan.py stats` reads the log back as a success table per kind and
model, with tune hints once a pairing has five or more subtasks. A hint
is a suggestion for the user, never a change you make on your own; see
[references/integrate.md](references/integrate.md).

11. Report in the shape below, with the logged run line from step 10. Mark anything you did not check yourself (unverified).

Output

plan: feature | 6 subtasks | 4 waves | models: haiku 1, sonnet 4, opus 1
| id | agent | model | status | changed | verified how |
| map | foreman:scout | haiku | done | - | opened 3 listed paths |
| build-api | foreman:builder | sonnet | done | src/api/users.ts | pytest tests/api passed (rerun by me) |
| build-ui | foreman:builder | sonnet | done | web/users.tsx | (unverified: needs a browser) |
check: <project check command> passed once
logged run <run id>: <N> subtasks
open: <what is left, or none>

Must not

  • Delegate a one-unit task, or launch an agent without model and effort set.
  • Let two subtasks in one wave own the same path.
  • Let an agent commit, push, merge, publish, or delete outside its owns.
  • Accept "done" without reading the diff or the evidence it cites.
  • Run the project's full check per agent; once, at the end.
  • Put a secret's value in a brief; name it by its variable.
  • Tell an agent which model tier it runs on; describe the task instead.
  • Launch more than max_wave (10) agents in one message; split the wave.
  • Rerun a subtask on the same model at the same effort, or launch it a third time.
  • Send work to fable that a brief could spell out, or to get past a refusal.

Sources

Read 2026-11-04, ideas paraphrased: code.claude.com docs sub-agents.md (model resolution order, plugin agent fields, nesting depth), model-config.md (aliases per provider, effort defaults) and workflows.md (opt-in, concurrency); anthropic.com/engineering/multi-agent-research-system (2025-06-13: about 15x tokens, scale effort to the query, give each worker an objective, an output format and boundaries); claude.com blog "Choosing a Claude model and effort level in Claude Code" (2026-07-07: smaller models for precise routine work, larger ones for ambiguity, move up only after a real try fails). Prior art studied, nothing copied: VoltAgent awesome-claude-code-subagents agent-organizer (MIT, plan-only organizer) and wshobson/agents (MIT, model per agent file).

Read 2026-11-10, ideas paraphrased: code.claude.com docs model-config.md (what Fable is for, the fable alias, safety-classifier fallback, usage credits) and sub-agents.md (subagents start in the background in interactive sessions, fork mode, the per-call effort); platform.claude.com docs about-claude/models/optimizing-for-cost-and-intelligence (rerun failures at higher effort, when delegation pays, Fable as orchestrator) and about-claude/pricing; claude.com blog "Choosing a Claude model and effort level in Claude Code" (did it not try hard enough, or did it not know enough); the Claude Code changelog for 2.1.292, 2.1.302 and 2.1.321. wshobson/agents docs/architecture.md (MIT) for an opt-in tier above Opus.

Read 2026-11-11, ideas paraphrased: code.claude.com docs sub-agents.md (a subagent starts in the background with nothing configured; claude -p and the Agent SDK can wait for one), env-vars.md (the subagent tool's run_in_background parameter) and headless.md (a claude -p run stays open for background subagents). Measured on Claude Code 2.1.322: a claude -p run that did not ask to wait launched its wave in the background and integrated on the session's model.

Read 2026-11-12, ideas paraphrased, no text copied: affaan-m/ECC (MIT, d2ef268) agents/code-reviewer.md (proof for high-severity findings), skills/loop-design-check/SKILL.md (a done-criterion needs a boundary, or the check gets weakened), skills/santa-method/SKILL.md (fresh reviewers each round), workflows/orch-review.workflow.js (doubt never clears a finding), its cost-tracker hook and skill-evolution library (usage summed from the transcript, a capped log, a recent-against-longer trend). code.claude.com docs hooks.md (SubagentStop input) and plugins/manifest-reference.md (userConfig); platform.claude.com about-claude/pricing for the rates.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.