Skip to content
Back to search

planning-multi-agent-strategy

Use when about to dispatch three or more agents for one task, start a Workflow, fan out subagents, or split a large task across models or external workers (GLM, Qwen, Codex, Kimi, DeepSeek) - before the first dispatch, and whenever choosing a model, effort level or executor for delegated work.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lucoile--planning-multi-agent-strategy/badge.svg)](/listings/lucoile--planning-multi-agent-strategy)

HTML

<a href="/listings/lucoile--planning-multi-agent-strategy"><img src="/api/listings/lucoile--planning-multi-agent-strategy/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/lucoile/planning-multi-agent-strategy ~/.claude/skills/planning-multi-agent-strategy

Then add a pointer to `~/.claude/CLAUDE.md` so the skill is loaded reliably, not only when its description happens to match:

# Multi-agent work

Before dispatching 3 or more agents or external workers for one task, or starting any Workflow, load the `planning-multi-agent-strategy` skill and follow it: send the strategy table and wait for my reply before the first dispatch.
For 1 or 2 dispatches, pick model and effort from that skill's routing table without pausing.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 148 lines
  1. ---
  2. name: planning-multi-agent-strategy
  3. description: Use when about to dispatch three or more agents for one task, start a Workflow, fan out subagents, or split a large task across models or external workers (GLM, Qwen, Codex, Kimi, DeepSeek) - before the first dispatch, and whenever choosing a model, effort level or executor for delegated work.
  4. ---
  5. # Planning Multi-Agent Strategy
  6. The user approves the strategy once, before anything starts, so they never
  7. have to interrupt a run to correct the model, the effort or the breakdown.
  8. For routing and for when to dispatch, this skill takes precedence over the
  9. model-orchestration delegation defaults. That plugin still supplies the
  10. worker machinery (`~/.claude-workers/<name>/run`, the `worker-dispatch` agent).
  11. ## Does the gate apply?
  12. Count the dispatches the WHOLE task will need (Claude subagents + external
  13. workers), not the dispatches in this turn. A row marked x5 is five. Re-sends
  14. after a failed audit do not count.
  15. - **3 or more, or any Workflow:** follow steps 1-6. The gate in step 4 applies.
  16. - **1 or 2:** pick executor and effort from the routing table, say each choice
  17. in one line (naming the provider if a worker gets the data), and dispatch.
  18. No pause. Still audit any worker result yourself.
  19. ## Steps
  20. 1. **Break the task down.** List subtasks, what depends on what, what runs in
  21. parallel, which files each one owns, and where results get audited. A file
  22. that several subtasks depend on gets exactly one owning row.
  23. 2. **Check which executors exist.** `grep -L PASTE_YOUR_API_KEY_HERE ~/.claude-workers/*/settings.json` lists
  24. plugin workers that have a key (a worker without one is not usable, and
  25. none are usable unless `command -v claude` finds the CLI);
  26. `command -v <cli>` for each entry under Other CLIs. Only these are usable.
  27. 3. **Fill in the strategy table** (format below). Every cell is required.
  28. 4. **Send the table and end your turn.** Until the user replies to the table:
  29. no Agent call, no Workflow, no worker command, and no file changes toward
  30. the task (no branch, no installs, no shared helpers). Reading is fine.
  31. If the user edits rows, re-send the changed rows and end your turn again.
  32. 5. **Dispatch exactly as approved.** Every Claude subagent, whether an Agent
  33. call or a Workflow `agent()`, passes the row's `model` AND `effort`.
  34. Workers get the row's command. No rows added, merged or re-routed.
  35. Where an orchestrator row sits between dispatch rows, split the Workflow
  36. into one script per stage and do the orchestrator row between them.
  37. 6. **Audit and escalate.** Audit each result against its criteria.
  38. - First failed audit: send the same executor back with specific fixes.
  39. Findings from a later row (a review, a design check) sent back to the
  40. row that made the change are this same kind of re-send.
  41. - Second failed audit of the same subtask: you may escalate it ONE step
  42. up the ladder, once, without asking. Only the failing copy of an xN row
  43. moves. The new executor repairs the existing output. Tell the user in
  44. one line when it happens and list it in the final report.
  45. - Ladder: worker -> `sonnet` -> `opus` -> orchestrator; `haiku` -> `sonnet`.
  46. A row moving from a worker to a Claude model takes the Effort in its
  47. routing row. A row already on a Claude model may instead go one effort
  48. step up (`low` -> `medium` -> `high`) on the same model.
  49. - Anything else needs the user's yes first: a second escalation of the
  50. same subtask, new work discovered mid-run, dropping or reverting a row,
  51. changing any other row. Propose it as a single table row and keep the
  52. already-approved rows running while you wait.
  53. The final report states what ran against the approved table and every
  54. escalation made.
  55. ## Strategy table (the message you send in step 4)
  56. ```
  57. | # | Subtask | Executor | Model | Effort | Why (routing row) |
  58. |---|---------|----------|-------|--------|-------------------|
  59. | 1 | Map auth module, 12 files | subagent | haiku | low | mechanical, read-only search |
  60. | 2 | Design new session flow | orchestrator | - | - | design |
  61. | 3 | Implement handlers (x3) | worker codex | (codex) | - | build, well-specced |
  62. | 4 | Check against Figma | subagent | sonnet | medium | tools, needs connector |
  63. | 5 | Audit each result from 3 | orchestrator | - | - | audit |
  64. | 6 | Review whole change | subagent | opus | high | review |
  65. Runs: 1 -> 2 -> 3 (three in parallel) -> 4, 5 -> 6
  66. Leaves this machine: handler code and spec to OpenAI (codex)
  67. Workers skipped as not configured: none
  68. Approve, edit rows, or change tiers?
  69. ```
  70. One row per subtask; parallel copies of the same subtask share a row with a
  71. count, and each worker row gets its own audit row. For workers, Model is the
  72. worker's model, or its name in brackets if unknown, and Effort is `-`. If a
  73. worker named in the routing row was not found in step 2, name it on the
  74. "Workers skipped" line with what was used instead.
  75. ## Routing table
  76. Use the first row whose scope matches. Where a cell lists several workers,
  77. use the first one found in step 2; if none is found, use the fallback.
  78. "orchestrator" means do it yourself. Effort applies whenever the executor is
  79. a Claude model, including a fallback or an escalation.
  80. | Row | Scope of subtask | First choice | Fallback (no worker found) | Effort |
  81. |---|---|---|---|---|
  82. | integrate | Security-sensitive, irreversible, or final integration of the pieces | orchestrator | n/a | n/a |
  83. | design | Architecture, design, task breakdown, writing specs for other rows | orchestrator | n/a | n/a |
  84. | review | Independent review of the whole change | `opus` | n/a | high |
  85. | audit | Checking one delegated result against its criteria | orchestrator | n/a | n/a |
  86. | tools | Needs in-session tools (connectors, browser) | `sonnet` | n/a | medium |
  87. | ambiguous | Implementation or debugging with no clear spec | `opus` | n/a | high |
  88. | analysis | Read-only analysis that needs judgment: code audits, findings lists, root-cause | `sonnet` | n/a | medium |
  89. | build | Well-specced implementation, tests, refactors, tooling setup | `codex`, `glm`, `qwen` | `sonnet` | medium |
  90. | read | Token-heavy reading with a factual answer: large docs, logs, research sweeps | `glm`, `qwen` | `sonnet` | low |
  91. | write-up | Notes, summaries and docs written from finished results | `sonnet` | n/a | low |
  92. | mechanical | Search, rename, formatting, bulk edits | `haiku` | n/a | low |
  93. `read` is for answers stated in the source; if the answer has to be inferred,
  94. it is `analysis`. If no row matches, use the closest and write "closest: <row>" in the Why
  95. cell. A spec written in a `design` row makes the work that follows it
  96. well-specced (`build`).
  97. When a wrong result would be costly to detect later: on a Claude row, raise
  98. effort one step, up to `high`; on a worker row, use the fallback Claude model
  99. instead of the worker. Say so in the Why cell. Use `xhigh` or `max` only when the user
  100. asks for it in their reply to the table.
  101. Every worker row needs an `audit` row. Any task with 3+ dispatches that
  102. changes code needs a `review` row.
  103. ## Dispatch commands
  104. | Executor | Command | Limits |
  105. |---|---|---|
  106. | Claude subagent | Agent tool with `model` and `effort` | - |
  107. | Plugin worker (`glm`, `qwen`, any dir under `~/.claude-workers/`) | From the orchestrator, via Bash: `~/.claude-workers/<name>/run -p "<spec>"`, adding `--permission-mode acceptEdits` only when the subtask edits files. Inside a Workflow script, use the `model-orchestration:worker-dispatch` agent at `haiku`, `low` | No in-session tools, no effort setting, at most 8 running at once |
  108. | Other CLIs: `codex` | Edits files: `codex exec -s workspace-write -C <repo> "<spec>"`. Read-only: `codex exec -s read-only -C <repo> "<spec>"`. Add `-o <file>` to capture the final message | Same limits. Never `--dangerously-bypass-approvals-and-sandbox`. Flags checked against codex-cli 0.170.0 |
  109. Add a row here for each further standalone CLI. Worker specs are
  110. self-contained: paths, acceptance criteria, files owned, "return a summary
  111. with file paths".
  112. ## What counts as approval
  113. Only the user's reply to the strategy table.
  114. | Thought | Reality |
  115. |---|---|
  116. | "They said go fast / there's a deadline" | The table is one message. An interrupted run costs more time. |
  117. | "They said 'I trust you' / 'just run with it'" | Said before they saw the table. It is not approval of the table. |
  118. | "They're away, the pause will stall the work" | They chose this gate knowing that. Send the table and end the turn. |
  119. | "They already asked for a workflow" | That picks the tool, not the routing. |
  120. | "I'll describe the plan in prose and start" | Prose plus dispatch gives them nothing to edit. Table, then stop. |
  121. | "A branch and shared helpers are only setup" | They are file changes toward the task. After approval. |
  122. | "Sonnet at medium for everything is safe" | Each row gets its own routing row. Uniform tiers mean the table was skipped. |
  123. | "The worker might not be worth the audit overhead" | The routing table already decided. Follow it or raise it in the table. |
README.md · README · 92 lines
  1. # planning-multi-agent-strategy
  2. A Claude Code skill that makes the orchestrator show you its plan before a
  3. large multi-agent task starts: which subtasks it will dispatch, to which model
  4. or external worker, and at what effort. You approve or edit that table once,
  5. and the run then follows it.
  6. It exists because the alternative is interrupting a run halfway to say "that
  7. subtask didn't need the biggest model" or "don't split it that way".
  8. ## What it does
  9. - **Gate.** For a task that needs 3 or more dispatches, or any Workflow, Claude
  10. sends a strategy table and ends its turn. Nothing is dispatched and no files
  11. change until you reply. For 1 or 2 dispatches it picks from the routing table
  12. and proceeds without pausing.
  13. - **Routing table.** Eleven named rows (`design`, `review`, `build`, `read`,
  14. `mechanical`, ...) map the scope of a subtask to an executor and an effort
  15. level, with a Claude fallback when no external worker is available.
  16. - **External workers.** Rows can route to headless workers on other providers
  17. (GLM, Qwen, and others set up under `~/.claude-workers/`) and to standalone
  18. CLIs such as Codex. The table says what data leaves your machine and to whom.
  19. - **Bounded escalation.** After a second failed audit of a subtask, Claude may
  20. move it one step up the ladder, once, and must tell you. Anything more needs
  21. your yes.
  22. Example of the message you get before anything starts:
  23. ```
  24. | # | Subtask | Executor | Model | Effort | Why (routing row) |
  25. |---|---------|----------|-------|--------|-------------------|
  26. | 1 | Map auth module, 12 files | subagent | haiku | low | mechanical, read-only search |
  27. | 2 | Design new session flow | orchestrator | - | - | design |
  28. | 3 | Implement handlers (x3) | worker codex | (codex) | - | build, well-specced |
  29. | 4 | Audit each result from 3 | orchestrator | - | - | audit |
  30. | 5 | Review whole change | subagent | opus | high | review |
  31. Runs: 1 -> 2 -> 3 (three in parallel) -> 4 -> 5
  32. Leaves this machine: handler code and spec to OpenAI (codex)
  33. Workers skipped as not configured: none
  34. Approve, edit rows, or change tiers?
  35. ```
  36. ## Install
  37. ```bash
  38. git clone https://github.com/lucoile/planning-multi-agent-strategy ~/.claude/skills/planning-multi-agent-strategy
  39. ```
  40. Then add a pointer to `~/.claude/CLAUDE.md` so the skill is loaded reliably,
  41. not only when its description happens to match:
  42. ```markdown
  43. # Multi-agent work
  44. Before dispatching 3 or more agents or external workers for one task, or starting any Workflow, load the `planning-multi-agent-strategy` skill and follow it: send the strategy table and wait for my reply before the first dispatch.
  45. For 1 or 2 dispatches, pick model and effort from that skill's routing table without pausing.
  46. ```
  47. ## External workers (optional)
  48. The skill works with Claude subagents alone. Worker rows fall back to a Claude
  49. model when no worker is found.
  50. - **Plugin workers** (`glm`, `qwen`, ...) are headless Claude Code instances
  51. pointed at another provider's Anthropic-compatible endpoint, one directory
  52. each under `~/.claude-workers/<name>/` with a `run` wrapper. The skill expects
  53. the layout created by the `model-orchestration` plugin, and takes precedence
  54. over that plugin's delegation defaults for routing. It needs the `claude` CLI
  55. on your PATH.
  56. - **Codex** is used through `codex exec` if `command -v codex` finds it.
  57. ## Make it yours
  58. The routing table is one person's preferences. Edit `SKILL.md` directly:
  59. - Reorder or replace the workers in the `build` and `read` rows.
  60. - Change the gate threshold (3 dispatches) in "Does the gate apply?" and in
  61. your `CLAUDE.md` pointer.
  62. - Add a row under "Dispatch commands" for any other standalone CLI.
  63. ## How it was tested
  64. Written test-first: three baseline runs without the skill all dispatched
  65. immediately (4, 5 and 22 agents) with a prose plan and near-uniform model
  66. choices. With the skill, the same scenarios sent the table and stopped, and a
  67. 2-dispatch task proceeded without a pause. The wording of the escalation rule
  68. was revised after those runs and has not been re-tested.
  69. ## License
  70. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.