orchestrate skill
✓ VerifiedDecomposes complex tasks into model-tiered multi-agent plans and executes them using parallel independent workstreams.
- GitHub stars
- 8
- Files
- 3
- Last commit
- Oct 28, 2026
- License
- MIT
- Allowed tools
- —
What does the orchestrate skill do?
orchestrate decomposes complex tasks into model-tiered multi-agent plans and executes them using parallel independent workstreams.
Summary generated from the skill's SKILL.md.
About the orchestrate skill
Breaking down large, multi-faceted projects into structured, multi-agent workflows is what this skill enables. It is designed for developers facing tasks that require simultaneous research, architectural planning, and code implementation across different parts of a codebase. Instead of tackling a massive request in one go, an agent uses this skill to decompose the work into specific subtasks categorized as research, implementation, planning, or synthesis.
To optimize efficiency, the skill assigns specific models to different roles: Haiku handles research and exploration, Opus manages complex planning and trade-offs, and Sonnet executes general-purpose implementation. The process relies on a strict one-owner-per-file discipline to prevent merge conflicts by grouping subtasks into independent, parallel tracks. Once the subagents complete their assigned work, the orchestrator reviews the outputs, runs verification commands like tests or linters, and performs the final synthesis and git operations. This approach is intended for complex fanning out of work rather than single-feature updates or simple task breakdowns.
What an agent can do with it
- 1Conducting parallel market researchA developer can request a comparison of multiple competitors to generate a single synthesized report.
- 2Executing codebase-wide refactoringYou can trigger a large-scale renaming operation that touches multiple directories simultaneously using independent implementation tracks.
- 3Integrating new system componentsAn agent can manage a full lifecycle from initial research and design to parallel coding and final verification.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the orchestrate skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the orchestrate skill in Plugin
/plugin marketplace add mgiovani/cc-arsenal /plugin install cc-arsenal@cc-arsenal-marketplace
Install the orchestrate skill in Claude Code
~/.claude/skills/orchestrate/SKILL.md
$ npx degit mgiovani/cc-arsenal/skills/orchestrate ~/.claude/skills/orchestrateInstall the orchestrate skill in Claude Code (project)
.claude/skills/orchestrate/SKILL.md
$ npx degit mgiovani/cc-arsenal/skills/orchestrate .claude/skills/orchestrateInstall the orchestrate skill in Codex
~/.agents/skills/orchestrate/SKILL.md
$ npx degit mgiovani/cc-arsenal/skills/orchestrate ~/.agents/skills/orchestrateInstall the orchestrate skill in Gemini CLI
~/.gemini/skills/orchestrate/SKILL.md
$ npx degit mgiovani/cc-arsenal/skills/orchestrate ~/.gemini/skills/orchestrateInstall the orchestrate skill in Claude.ai
npx degit mgiovani/cc-arsenal/skills/orchestrate orchestrate && zip -r orchestrate.zip orchestrate # claude.ai → Customize → Skills → + → Create skill → Upload a skill → orchestrate.zip
Automated checks
Ran Nov 15, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work · What to fix for more points
- Source repository linked and reachablemgiovani/cc-arsenal/skills/orchestrate is public and reachablegithub.com/mgiovani/cc-arsenal/tree/HEAD/skills/orchestrate ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-10-28github.com/mgiovani/cc-arsenal/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/mgiovani/cc-arsenal/blob/HEAD/skills/orchestrate/ ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/mgiovani/cc-arsenal/blob/HEAD/skills/orchestrate/ ↗Pass
- SKILL.md follows the Agent Skills formatthe description does not say when to use the skillgithub.com/mgiovani/cc-arsenal/blob/HEAD/skills/orchestrate/ ↗Finding
SKILL.md
View on GitHubOrchestrate
Turn a task into a model-tiered multi-agent plan, run it, and synthesize the result yourself.
Task
$ARGUMENTS
Step 0: Is orchestration warranted?
Before decomposing anything, check whether the task genuinely splits into 2+ independent pieces of real work. A task confined to one file, needing just one command, or with a single obvious fix, doesn't need a plan or a subagent: do it directly and say so in one line. Below that bar, spawning, tracking, and merging subagents costs more than the work itself, and a fabricated multi-phase plan for a one-line change is worse than no plan.
If it passes this bar, continue to Step 1.
Step 1: Decompose
Break the task into subtasks. For each, state its concrete input, its expected output, and classify it as one of:
| Classification | Covers |
|---|---|
| research | exploration, search, finding code or facts, reading, gathering information; no code written |
| implementation | writing or editing code, config, or content |
| planning | architecture/design decisions, non-trivial trade-off calls |
| synthesis | merging multiple subagents' outputs into one final deliverable |
Step 2: Model table (model is required, never inherited)
| Classification | subagent_type | model | Why |
|---|---|---|---|
| research | Explore | haiku | cheap, good at search/find/read; use haiku for every research subtask, even if spawned as general-purpose |
| planning | Plan | opus | best reasoning for architecture/trade-offs |
| implementation | general-purpose (or the repo's own agent) | sonnet | balance of cost and capability |
| synthesis | n/a (orchestrator itself) | n/a | never delegate the final merge |
Every spawn call MUST set model explicitly. An unset model silently inherits the
caller (often the most expensive model available) and defeats the whole point of
tiering. Treat a missing model field as an incomplete call, not a default to fill in
later.
Step 3: Parallelize with strict file ownership
Group subtasks into independent tracks: a track is independent if it shares no file or directory with any other track. Before spawning, write down the ownership map (track → files/dirs it will touch) and confirm no two tracks overlap. Two agents editing the same file is a merge conflict you caused, not one you'll resolve later: split the map instead of hoping it works out.
Spawn every independent track's subagent(s) in parallel: multiple Task calls in the
same turn. Sequential subtasks (B depends on A's output) run one after another in the
same session, passing A's actual output forward, never a paraphrase of it.
Step 4: Orchestrator does the synthesis and the git
Once every track reports back:
- Review each subagent's actual diff or output: don't take a subagent's self-report on faith.
- Merge/synthesize the final deliverable yourself. Never spawn a subagent to do the final merge.
- If the task touched code, run the project's real verification commands (test/lint/
build): discover them from the repo, don't assume
npm testormake testexist. - Any git operation (commit, push) is the orchestrator's job alone: no subagent commits.
Portability: no Task/subagent tool available
Run the exact same Step 1-4 structure yourself, inline, sequentially, in dependency order: research tracks first, then planning, then implementation, then your own synthesis. Nothing about the plan's correctness depends on subagents existing; they're a speed optimization, not a requirement.
Worked examples
Research sweep (independent, parallel research tracks)
Task: "Research current pricing for 4 competitors, write a comparison table."
- 4 research subtasks (one per competitor), each
Explore/haiku, no shared file: spawn all 4 in the same turn. - Orchestrator synthesizes the 4 reports into the comparison table itself.
Codebase-wide refactor (independent, parallel implementation tracks)
Task: "Rename Invoice to Bill across models/, api/, tests/, docs/."
- One research subtask first (
Explore/haiku): grep every reference, return the full list. - 4 implementation subtasks, one per directory, each
general-purpose/sonnet, ownership map ={models/, api/, tests/, docs/}with zero overlap. - Orchestrator runs the test suite, reviews all 4 diffs, commits once, alone.
Mixed build (research → plan → parallel implementation → synthesis)
Task: "Add a new payment provider integration."
- 1 research subtask (
Explore/haiku): find the existing provider abstraction and its test patterns. - 1 planning subtask (
Plan/opus): design the new provider's interface against what research found. - 2-3 parallel implementation subtasks (
sonnet) against the approved plan, one per component (client, tests, config), each with a distinct file scope. - Orchestrator integrates, verifies, commits.
Output format
Report the subtask list with each classification and model, the parallel groupings actually run, and the synthesized result. If Step 0 concluded orchestration wasn't warranted, say so in one line and do the work directly instead: no plan needed for that case.
Usage
/orchestrate Research current pricing for 4 payment competitors and write a comparison table
/orchestrate Rename the Invoice model to Bill everywhere in the codebase
/orchestrate Add support for a new payment provider (client + tests + config)
Files in this skill
3orchestrate skill questions
How do I install the orchestrate skill in Claude Code?
Run npx degit mgiovani/cc-arsenal/skills/orchestrate ~/.claude/skills/orchestrate. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the orchestrate skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
When should I use the orchestrate skill?
Use it for tasks large enough to fan out across multiple independent workstreams, such as research sweeps or codebase-wide refactors. Do not use it for single well-scoped features or pure task breakdown without execution.
How are different models assigned to subtasks?
Tasks are mapped by classification: Haiku is used for research/exploration, Opus for planning/architecture, and Sonnet for implementation and general-purpose tasks.
How does the skill handle potential merge conflicts between agents?
It uses a strict one-owner-per-file discipline where subtasks are grouped into independent tracks that share no files or directories.