agentleFS
eyhsheneyhshen/multiagent-dispatch/SKILL.md

dispatch

Skill1 starsChanged 5 months agoMITView on GitHub

Launch a hands-off, multi-terminal investigation: decompose one big question into N focused agents running in parallel terminals, coordinate them through files (no clobbering), and synthesize their findings into one combined brief — with the coordinator's poll interval auto-tuned to your project's size. Use when asked to "dispatch agents", "multi-agent investigation", "hands-off analysis", "task several agents in parallel", "fan out terminals", "deep dive with multiple agents", or "coordinate parallel research".

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

6 rules. 0 are common, 5 are distinctive, and 1 is very specific to this project.

  • 0

    Common

    Most of the 43 edited versions we read keep these.

  • 5

    Distinctive

    This author's own choices. Worth a look.

  • 1

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    One coordinator: always include a coordinator agent (optional but default-on).

    line 52
  2. Distinctive:

    Add ~60% to the estimate for any agent doing web research (longer reads, network waits).

    line 237
  3. Distinctive:

    If your fleet is mixed (some code-only, some web), use the shortest estimate for sweep math and the longest for the fallback heartbeat.

    line 239
  4. Distinctive:

    After the first sweep: count how many reports are already DONE or have substantial content.

    line 278
  5. Distinctive:

    All 0 DONE after 90s: agents are still loading context.

    line 279
  6. Very specific:

    When all agents are done, write _SYNTHESIS.md.

    line 304

“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

/fleet — Hands-Off Multi-Terminal Investigation

Quick Start (6 steps)

  1. Invoke /fleet in any terminal — this terminal becomes the coordinator (CEO).
  2. Describe your investigation — what do you want to know thoroughly and in parallel?
  3. Decompose — the skill breaks it into N focused agents + a coordinator plan.
  4. Scaffold — a .fleet/<run-name>/ folder appears in your current project with a protocol, board, and one prompt file per agent.
  5. Launch — open one terminal per agent, paste the one-liner. Agents run hands-off.
  6. Coordinate — the coordinator loops in terminal 1, watching status, routing questions, and writing the synthesis when everyone's done.

Part 1 — Decompose

What makes a good fleet?

Each agent gets one focused question and one writable file. Agents never write into each other's files. This is the invariant that keeps parallel terminals from clobbering each other.

Choosing N:

  • 2–3 agents: small investigations (one codebase area, one decision).
  • 4–6 agents: deep dives (multiple subsystems, architectural questions).
  • 7+ agents: only when each question is truly independent and non-overlapping.

One coordinator: always include a coordinator agent (optional but default-on). It watches the board, routes cross-agent questions, and writes the synthesis. If you skip it, the CEO session (your current terminal) can synthesize manually when all reports land.

Separate code-reading agents from web-research agents. Code readers finish in 5–18 min depending on project size. Web researchers run longer (add ~60% to the estimate). Mixing them? Use the longer estimate for the heartbeat, the shorter for the sweep.

Decomposition prompts to ask yourself

  • Can each question be answered WITHOUT reading what other agents find?
  • Is any agent doing more than one job? Split it.
  • Is there a question that synthesizes the others? That's the coordinator's job, not a peer agent.

Part 2 — Scaffold

The skill creates a per-run folder in your current project. Default path: .fleet/<run-name>/. Override by setting FLEET_DIR before invoking.

Create the run folder

RUN_NAME="<slug-for-this-investigation>"
FLEET_DIR=".fleet/$RUN_NAME"
mkdir -p "$FLEET_DIR"

Files to create

PROTOCOL.md — the single file every agent reads first. Generalizes the single-writer rule.

# Fleet Protocol — <run-name>

Mission: investigate and report. Do NOT edit application code, commit, or push.
The only files you write are your own report file and (coordinator only) the board.

## Single-writer-per-file rule

Every file in this folder has exactly one agent allowed to write it.
Read any file freely. Write only the file(s) assigned to you.

| File | Sole writer |
|---|---|
| `BOARD.md` | coordinator |
| `report-<slug1>.md` | agent 1 |
| `report-<slug2>.md` | agent 2 |
| ... | ... |
| `_SYNTHESIS.md` | coordinator |

## Report header (keep current — coordinator reads it to track progress)

Every report must start with:

<title>

STATUS: IN_PROGRESS | DONE AGENT: <slug> UPDATED: <YYYY-MM-DD HH:MM>


End every report with:

Open questions for other agents

  • @<agent-slug>: <question> (leave blank if none)

Bottom line (3 sentences max)


## Cross-agent questions

Never write into another agent's file. If you need something from another agent,
write it under `## Open questions for other agents` in YOUR report and @-tag them.
The coordinator copies these to BOARD.md. Check BOARD.md periodically for questions
tagged at you — answer in your own report.

BOARD.md — coordinator-owned status board.

# Fleet Board — <run-name>

Sole writer: **coordinator**. Agents: read-only.

Started: <date>. Protocol: see `PROTOCOL.md`.

## Roster & status

| Agent | Report file | Status |
|---|---|---|
| 1 · <slug1> | `report-<slug1>.md` | NOT STARTED |
| 2 · <slug2> | `report-<slug2>.md` | NOT STARTED |

## Routed cross-agent questions

(coordinator fills this in during sweeps)

prompt-<n>-<slug>.md — one per investigator agent (coordinator gets one too). Template:

You are the **<Role Name>** for the <project-name> investigation.
READ-ONLY — do not edit code, commit, or push.
First read `<FLEET_DIR>/PROTOCOL.md` and follow it exactly.
Your sole writable file is `<FLEET_DIR>/report-<slug>.md`.

## Why you exist
<One paragraph: what pain or question this agent resolves for the person reading the synthesis.>

## What to investigate
<Specific, anchored questions. Reference files by path. Include any known starting points.>

## Method
<How to approach it. Any verification requirements (e.g. "verify every claim against source before writing").>

## Deliverable
Write `report-<slug>.md` per the PROTOCOL structure. Keep STATUS current.
End with open questions and a 3-sentence bottom line.

Coordinator prompt template:

You are the **Coordinator** for the <project-name> fleet.
READ-ONLY for application code — you never edit it, commit, or push.
First read `<FLEET_DIR>/PROTOCOL.md`. Your writable files are ONLY `BOARD.md` and `_SYNTHESIS.md`.

## Your loop
Use the `/loop` skill. Each cycle:
1. Read STATUS headers of all reports. Update the roster in BOARD.md.
2. Scan each report's `## Open questions for other agents`. Copy new @-tagged questions to BOARD.md.
3. Sleep <computed sweep interval>s between sweeps.
4. When ALL reports read `STATUS: DONE`, write `_SYNTHESIS.md` and stop.

## Synthesis structure (see Part 6 of the fleet skill)
<Fill in the synthesis sections relevant to your investigation.>

Part 3 — Measure project size (run at fleet start)

files=$(git ls-files | wc -l | tr -d ' ')
loc=$(git ls-files '*.py' '*.ts' '*.tsx' '*.js' '*.jsx' '*.go' '*.rb' '*.rs' \
  '*.java' '*.c' '*.cpp' '*.html' '*.css' | xargs wc -l 2>/dev/null | tail -1 | awk '{print $1}')
loc=${loc:-0}
echo "FILES: $files | LOC: $loc"

Part 4 — Launch

Emit one line per agent terminal. Use --dangerously-skip-permissions for a fully hands-off run (no permission prompts).

Terminal 1 (coordinator):  claude --dangerously-skip-permissions
  → Read .fleet/<run-name>/prompt-coordinator.md and execute it fully using the /loop skill.

Terminal 2 (agent 1):  claude --dangerously-skip-permissions
  → Read .fleet/<run-name>/prompt-1-<slug>.md and execute it fully.

Terminal 3 (agent 2):  claude --dangerously-skip-permissions
  → Read .fleet/<run-name>/prompt-2-<slug>.md and execute it fully.

... (one line per additional agent)

Note: launch investigator agents first, then the coordinator. If you skip the coordinator, any session can run synthesis manually — see Part 6.


Part 5 — Coordinate with a dynamic loop interval ★

This is the headline fix over the naive approach. A flat 20-minute sweep interval is 10× too coarse for a small project. The coordinator's interval must scale with project size and recalibrate from live data.

Step A — Bucket the project

BucketConditionExpected per-agent wall-clock (code read)
small<200 files OR <20k LOC~5 min (300s)
medium200–800 files OR 20–80k LOC~10 min (600s)
large>800 files OR >80k LOC~18 min (1080s)

Add ~60% to the estimate for any agent doing web research (longer reads, network waits).

If your fleet is mixed (some code-only, some web), use the shortest estimate for sweep math and the longest for the fallback heartbeat.

Step B — Compute sweep interval

sweep_s = clamp( round(0.33 × shortest_expected_seconds), 60, 270 )
heartbeat_s = clamp( longest_expected_seconds, 300, 3600 )

The 270s ceiling keeps Claude's prompt cache warm. The prompt cache TTL is ~5 minutes (300s). Staying under 270s means each sweep hits cached context — faster and cheaper. The heartbeat can exceed 300s (cache miss is acceptable there).

ScheduleWakeup clamps to [60, 3600] — respect this. Pass the computed delaySeconds with a one-line reason naming the estimate.

Step C — Worked example

Project: ~177 files / ~21k LOC (a typical small web app)

Bucket: FILES < 200 → SMALL → expected ~5 min (300s) per code-reading agent.

sweep = clamp(round(0.33 × 300), 60, 270) = clamp(99, 60, 270) = 99s ≈ 100s

heartbeat = clamp(300, 300, 3600) = 300s

vs. the naive flat 1200s → ~12× too coarse. An agent that finishes in 4 minutes would wait up to 20 minutes for the next coordinator sweep. With a 100s interval, worst-case lag is 100s.

Medium project (400 files / 40k LOC): sweep = clamp(round(0.33 × 600), 60, 270) = clamp(198, 60, 270) = 198s ≈ 3 min heartbeat = 600s

Large project (1000 files / 100k LOC): sweep = clamp(round(0.33 × 1080), 60, 270) = clamp(356, 60, 270) = 270s (cache ceiling) heartbeat = 1080s

These numbers are re-computed per project from the size measurement. Never hardcode them.

Step D — Calibrate from live data

Take the first sweep at ~90s regardless of bucket — it's cheap and reveals whether agents are faster or slower than estimated.

After the first sweep: count how many reports are already DONE or have substantial content. Recompute the interval from observed velocity:

  • All 0 DONE after 90s: agents are still loading context. Keep estimated interval.
  • 1+ DONE after 90s: agents are fast. Tighten interval toward 60s.
  • STATUS headers haven't changed after 2 sweeps: agents are slow or stalled. Widen toward the heartbeat.

The estimate is a seed. Live data wins.

Coordinator loop (paste into coordinator prompt)

Use the /loop skill with self-paced timing. Each cycle:

1. Read STATUS headers of all report files.
2. Update the roster table in BOARD.md.
3. Scan `## Open questions for other agents` in each report. Route new @-tagged questions to BOARD.md.
4. Schedule next wake with:
   - First sweep: ~90s (calibration)
   - Subsequent sweeps: <computed sweep_s>s
   - Fallback heartbeat: <computed heartbeat_s>s
5. When ALL reports read STATUS: DONE → write _SYNTHESIS.md → stop loop.

Part 6 — Synthesize

When all agents are done, write _SYNTHESIS.md. If the coordinator ran, it writes this automatically. If it was skipped, any session can write it:

Read .fleet/<run-name>/prompt-coordinator.md and write the synthesis now.
All reports are DONE — skip the loop, go straight to _SYNTHESIS.md.

_SYNTHESIS.md structure

# Synthesis — <run-name>
Written by: <coordinator or manual>. Date: <date>.
Sources: <list report files>

## 1. TL;DR — one decisive sentence per agent stream

- **<agent 1 slug>:** <finding>
- **<agent 2 slug>:** <finding>
...

## 2. Conflicts and cross-findings

Where agents disagree or reinforce each other. These are often the highest-value insight.
Surface tensions explicitly — don't smooth them over.

## 3. Recommended next-step sequence

A single ordered list, spanning all streams, with effort tags (S/M/L).
This is a judgment call — integrate all findings, don't just list them.

Part 7 — Customize (what YOU own)

Fleet supplies the engine. You supply the domain knowledge:

Your responsibilityFleet's responsibility
What questions to askHow to decompose, scaffold, coordinate
How to prompt each agent for your codebaseThe single-writer protocol
Which files/paths to investigateThe dynamic loop interval
What the synthesis should emphasizeThe synthesis structure

Example: filling in a prompt

Template (blank):

## What to investigate
<Specific, anchored questions. Reference files by path.>

Filled for a Python/FastAPI project:

## What to investigate
1. Trace every entry point in `app/routers/` — what input is rejected before the LLM sees it?
2. Check `prompts/extract_facts.txt` — is there a ranked capture hierarchy, or a flat list?
3. Verify: does `app/fact_merge.py` preserve human-written notes across resets? Anchor to file:line.

Everything outside these filled-in sections is reusable across projects without change.


Troubleshooting

Agent wrote into the wrong file: The single-writer rule was violated. Stop that agent's terminal. The coordinator can note the conflict in BOARD.md. Manually recover the overwritten content from git history if needed.

Coordinator never launched: Synthesis falls to the CEO session. Run: Read .fleet/<run>/prompt-coordinator.md and write the synthesis now. All reports are DONE.

Agent stalled (STATUS stuck at IN_PROGRESS for 2+ sweeps): Coordinator notes it in BOARD.md. The human can check that terminal or restart the agent.

Agents finishing faster than expected: Recalibrate — tighten the sweep interval toward 60s so synthesis isn't delayed.

ScheduleWakeup rejects the interval: The tool clamps to [60, 3600]. If your computed value is outside this range, clamp it yourself before passing.

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.