Skip to content
Skills Library
AI & agents · Planning

workflow-wave-dispatch

/workflow-wave-dispatch

Sequential-wave dispatch for multi-agent work with cross-task dependencies. Use when planning multi-step work, fixing parallel-dispatch order, or gating waves on verification.

Licence
MIT
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Sequential-wave dispatch for multi-agent work with cross-task dependencies. Use when planning multi-step work, fixing parallel-dispatch order, or gating waves on verification.

Original author description

Sequential-wave dispatch for multi-agent work with cross-task dependencies. Use when planning multi-step work, fixing parallel-dispatch order, or gating waves on verification.

How it works

  1. When to Use This Skill
  2. Wave Structure
  3. Scheduling Heuristics
  4. Schema-Constrained Agents Under Rate-Limit Storms
  5. Gate Failure: Roll Back, Don't Paper Over
  6. Shared Mechanics (owned by wave-based-dispatch)
  7. Quick Reference
  8. Related
Original SKILL.md headings · 161 lines, 1,216 words
SKILL.md preview
---
name: workflow-wave-dispatch
description: Sequential-wave dispatch for multi-agent work with cross-task dependencies. Use when planning multi-step work, fixing parallel-dispatch order, or gating waves on verification.
user-invocable: false
allowed-tools: Read, Glob, Grep, TodoWrite
created: 2026-04-24
modified: 2026-09-02
reviewed: 2026-09-02
---

# Workflow Wave Dispatch

Sequential waves, not parallel fan-out, when the work has real
dependencies. This skill is the **workflow-side scheduling view**: which
waves exist, what order they run in, and what to do when a gate fails.

The **dispatch discipline** — the per-wave gate set, the research-before-WO
gate, the ~10-line inline-fix threshold, the stable shared-file exclusion
list, and Return Contract reuse — lives in
`agent-patterns-plugin:wave-based-dispatch`. This skill does not restate it;
it schedules around it.

## When to Use This Skill

| Use this skill when… | Use the alternative when… |
|----------------------|---------------------------|
| Enumerating the waves and their ordering for a dependent landing | You need the per-wave gate set / dispatch discipline — use `agent-patterns-plugin:wave-based-dispatch` |
| Deciding what to do when a wave's gate fails | Briefing the agents *inside* a wave — use `agent-patterns-plugin:parallel-agent-dispatch` |
| Scheduling a research probe ahead of the implementation waves it unblocks | A tool holds an exclusive lock and the wave must pre-dump it — use `agent-patterns-plugin:exclusive-lock-dispatch` |

`parallel-agent-dispatch` is the right call inside a wave. Waves are the
layer above it — they answer "which agents run together, in what order"
before `parallel-agent-dispatch` answers "how each agent is briefed."

## Wave Structure

```
Wave 1 (research)
  └── Single agent or small fan-out → artefacts in tmp/
      └── Gate: artefacts exist, agent returned a clean contract

Wave 2 (foundation)
  └── Parallel fan-out against wave-1 artefacts
      └── Gate: build green, tests green, tracker advanced

Wave 3 (extension)
  └── Parallel fan-out referencing wave-2 types/APIs
      └── Gate: smoke recipes pass, clean tree

Wave N …
```

Each wave is itself a `parallel-agent-dispatch` call. This skill covers
wave **scheduling**: which waves exist, what gates between them, what to
do when a gate fails. The gate *set* itself is the six-gate table in
`agent-patterns-plugin:wave-based-dispatch` § Six-Gate Verification Table.

## Scheduling Heuristics

- Put the **lock-holder** (Ghidra, migration, bulk taskwarrior) alone in
  its wave. See `agent-patterns-plugin:exclusive-lock-dispatch`.
- Put the **research wave** before any implementation wave that depends
  on its artefacts (the research-before-WO gate in
  `agent-patterns-plugin:wave-based-dispatch` explains why the downstream
  WO's *size* collapses once the probe lands).
- Put **foundation** (new types, new APIs, new files that others will
  import) in the earliest implementation wave.
- Put **extensions** (new call sites, new tests, new docs) in later
  waves.
- Inside a single wave, fan out to the widest safe parallelism that
  `parallel-agent-dispatch` allows.

## Schema-Constrained Agents Under Rate-Limit Storms

Schema-constrained `agent()` calls — agents bound to a `StructuredOutput`
schema — are **fragile under rate-limit storms** (issue
[#1463](https://github.com/laurigates/claude-plugins/issues/1463)). A
rate-limit hit that occurs *before* the agent emits its `StructuredOutput`
is reported as a hard parse failure: the caller receives no partial output
and the agent's work is unrecoverable from the schema path, even when
substantial work was done inside the agent's context window.

**Why this matters at the wave layer.** A wide wave of schema-bound agents
(e.g. 8–10 concurrent structured-output extractors) creates a rate-limit
storm risk. If the storm wipes half the wave, the gate fails and the
orchestrator has no partial results to salvage — unlike a plain `agent()`
call where the worktree holds the work.

**Blast-radius containment** — apply at wave-scheduling time:

| Heuristic | Guidance |
|-----------|----------|
| Wave size | Cap schema-bound waves at **≤ 5 concurrent agents** — the same ceiling `parallel-agent-dispatch` § Concurrent Rate-Limit Risk sets for `[1m]`-context parents (measured on Opus 4.7; schema-bound agents need it most because a cut-off leaves no partial result, #1463). Fable 5.1 parents run 1M context by default, so the hazard applies; not re-measured on Fable 5.1 — keep the cap until a run shows the storm no longer occurs, then raise with evidence |
| Stagger | Add **~30 s between launches** in the same wave to spread the token-request window |
| Wave splits | If the fan-out genuinely needs >5 schema-bound calls, dispatch in sequential sub-waves of ≤ 5 — gate each sub-wave before launching the next |
| Retry shape | On a rate-limit partial failure, recovery-dispatch only the failed agents (not the whole wave) — the successful siblings' outputs are valid |

For concurrency caps, wave-splitting mechanics, and the recovery-dispatch
routine for rate-limited agents, see
`agent-patterns-plugin:parallel-agent-dispatch` § Concurrent rate-limit risk
and its `references/failure-recovery.md` § Concurrent rate-limit risk —
recovery-dispatch routine. (Named, not path-linked: a relative path into
another plugin is dead for anyone who installed only one of the two —
`.claude/rules/skill-consolidation.md` § 2.) Do not duplicate that guidance
here.

## Gate Failure: Roll Back, Don't Paper Over

Every wave ends with a gate (the six-gate set lives in
`agent-patterns-plugin:wave-based-dispatch`). No brief for wave N+1 is
written before wave N's gate passes.

A gate failure **rolls back to "fix in place, retry the gate"** — never
to "dispatch wave N+1 and paper over the failure." If the wave as a whole
is un-recoverable, revert it and re-brief.

Whether a returned issue is fixed inline or filed as a follow-up WO for
the next wave is the ~10-line inline-fix threshold — see
`agent-patterns-plugin:wave-based-dispatch` § The ~10-Line Inline-Fix
Threshold.

## Shared Mechanics (owned by `wave-based-dispatch`)

These are defined once in `agent-patterns-plugin:wave-based-dispatch` and
referenced — never restated — when scheduling waves:

| Mechanic | Where |
|----------|-------|
| Per-wave gate set | § Six-Gate Verification Table |
| Research-before-WO gate | § The Research-Before-WO Gate |
| Inline-fix vs follow-up WO | § The ~10-Line Inline-Fix Threshold |
| Stable shared-file exclusion list across waves | § Stable Shared-File Exclusion List |
| Return Contract reuse | `parallel-agent-dispatch` § Return Contract |

## Quick Reference

### Orchestrator Checklist (scheduling)

- [ ] Waves enumerated with explicit dependencies identified
- [ ] Research wave scheduled first if any scope depends on tool output
- [ ] Lock-holder isolated in its own wave
- [ ] Foundation scheduled before extensions
- [ ] A gate defined for every wave boundary (set per `wave-based-dispatch`)
- [ ] No brief for wave N+1 written until wave N's gate passes
- [ ] Gate failure → fix in place and retry, never dispatch-over

### Common Scheduling Mistakes

| Mistake | Correct Approach |
|---------|-----------------|
| Bundling "decompile X, then implement Y" in one wave | Split into a research wave + an implementation wave |
| Dispatching wave N+1 after a gate failure to "patch over it" | Fix in place, retry the gate; revert and re-brief if unrecoverable |
| Scheduling extensions before the foundation they import | Foundation in the earliest implementation wave, extensions later |
| Running the lock-holder concurrently with its consumers | Lock-holder alone in its wave; downstream reads pre-dumped artefacts |
| Enforcing the wave boundary by discipline alone | Express it as a `parallel()` barrier |

## Related

- `agent-patterns-plugin:wave-based-dispatch` — the dispatch discipline and the shared between-wave gate set this skill schedules around
- `agent-patterns-plugin:parallel-agent-dispatch` — intra-wave dispatch contract
- `agent-patterns-plugin:exclusive-lock-dispatch` — pre-dump pattern for lock-contending waves
- `agent-patterns-plugin:agent-teams` — implicit-team / SendMessage mechanics that waves sit on top of
- `tools-plugin:cli-smoke-recipes` — smoke-gate mechanics between waves
- `.claude/rules/parallel-safe-queries.md` — empty-result exit codes inside gates

> Evidence: a six-wave landing shipped six dependent work-orders in one
> day with zero merge conflicts and exactly one inline fix. Earlier
> attempts without wave discipline produced two-day cycles dominated by
> re-work when later WOs broke earlier interfaces.

Versions

The database has no other skills named workflow-wave-dispatch.

Database snapshot: 13.11.2026 · package version 2d6987d1501c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100parallel-wave
    Default way of working for ALL parallel work in this project (several agents at once, tracks in worktrees, orchestration through the work queue). Use it every time work is to be split across several agents or tracks, also when the user just says "next wave", "run in parallel" or…
  • 90wave-based-dispatch
    Sequential-wave dispatch for WO chains where output of one feeds the next, shared locks, or shared files prevent fan-out. Use when planning dependent multi-WO landings.
  • 100orchestrate
    Analyzes task dependencies, builds a wave execution plan, and runs specialist agents in parallel and sequential waves to complete a complex multi-agent task. Use when a task spans multiple domains and needs coordinated multi-agent execution.
  • 100wave-executor
    Execute a wave-based plan by spawning parallel agents per wave, enforcing merge gates, and building self-contained per-agent prompts from wave document rows. Use when asked to: run the plan, execute the plan, start the waves, launch agents, execute wave N, run wave execution.…
  • 90coordinating
    Use when three or more agents work toward one goal, when independent tasks need parallel dispatch, or when dependent tasks need ordered waves.
  • 100multi-agent-dispatch
    Coordinate multi-agent work in any repo - the Owner may name who does what. dispatch.py ask sends one worker to read or write text with no branch or review; dispatch.py run does author, review and draft PR with any named author and reviewer among OpenCode free models, Codex and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.