跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
开发与测试

orchestrate

Multi-agent coordination across plan/implement/test/review; fan-out for 3+ workstreams. Triggers "coordinate", "orchestrate", "parallel agents", "fan out", "split work", refactor, "overnight", "autonomous task", "marathon".

darkroomengineering · 已有 AI 审核记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add darkroomengineering/cc-settings --skill orchestrate

技能说明


name: orchestrate description: Multi-agent coordination across plan/implement/test/review; fan-out for 3+ workstreams. Triggers "coordinate", "orchestrate", "parallel agents", "fan out", "split work", refactor, "overnight", "autonomous task", "marathon". context: fork agent: maestro

Multi-Agent Orchestration

Standalone Codex

Skip every Claude heavy-skill marker in this file. Create each bounded worker with spawn_agent, deliver context to a running worker with send_message, trigger another turn for an idle existing worker with followup_task, wait with wait_agent, and stop a current turn with interrupt_agent only when necessary. Never spawn codex-verifier or call codex-run.ts.

Read the live concurrency limit and stay within it. Writers share the working tree unless the live host explicitly offers isolation. Assign non-overlapping ownership and serialize implementer and test-writer phases; only read-only reviewers may overlap. Codex implementers are not promised Claude worktree isolation.

Claude-only marker: standalone Codex must skip this command. mkdir -p ~/.claude/tmp && echo "orchestrate" > ~/.claude/tmp/heavy-skill-active && date -u +"%Y-%m-%dT%H:%M:%SZ" >> ~/.claude/tmp/heavy-skill-active

Phase 1: Research & Feasibility (GO/NO-GO Gate)

Before delegating to agents:

  1. Parse requirements - Break down what needs to happen
  2. Identify workstreams - Which are independent? Which have dependencies?
  3. Assess scope - Is this actually multi-agent work, or simpler than it looks?
  4. Sort into two piles (the Orchestration Tax — your review attention is the serial bottleneck and it doesn't parallelize):
    • Delegate-async — isolated, well-specified work where your judgment lands at the gate (you review the finished result): scaffolding, mechanical refactors, test writing, doc generation, independent file areas. Fan these out.
    • Hold-the-lock — work where the judgment is the work: a subtle bug, an architecture decision, anything that needs your evolving mental model of the system. Parallelizing these doesn't scale output — it thrashes the one serial resource and everything comes back worse. Do them yourself, serially, one at a time.

GO/NO-GO Verdict:

  • GO - 3+ delegate-async workstreams, clear boundaries, agents work independently. Proceed — fan out the first pile only.
  • SIMPLIFY - <3 workstreams, OR the work is mostly hold-the-lock regardless of size. Delegate the isolated bits with direct Agent() calls and keep the judgment-heavy parts yourself.
  • NO-GO - Requirements unclear, scope too large, or high risk of file conflicts. Report and stop.

Do not proceed past this gate without an explicit verdict.

Phase 2: Orchestrate

Delegate to the Maestro agent for multi-agent task orchestration.

The Maestro agent handles: agent selection, parallel execution, workflow coordination, and agent teams.

For simple delegation (1-2 agents), use Agent() directly without invoking this skill.

Verify Subagent Claims Independently

A subagent's "done" is a claim, not a result. Before building on it, committing, or reporting success:

  1. Re-run the briefed verification yourself against the real artifact — the actual build, the actual binary's output, the actual grep sweep. Never forward a subagent's self-reported pass as your own verification.
  2. Check the capability envelope. Subagents may lack tools you assume (a no-Bash implementer cannot run builds or delete files — it will improvise, e.g. zeroing a file instead of removing it, and still report done). Read what the agent says it couldn't do, then absorb the gap yourself: run the deletion, the build, the test.
  3. Re-delegate vs fix solo. A trivial break found during verification (single file, few lines) — fix it solo with a one-line stated reason; round-tripping to a fresh subagent costs more than the fix. Anything that adds scope goes back out as a new, fully-briefed delegation.
  4. Resume, don't respawn. If a subagent's report was cut off or is missing a section, Claude uses SendMessage; standalone Codex uses send_message while it is running or followup_task once idle. A respawn rebuilds its context from nothing and re-does paid work.

Failure mode this section exists to prevent: chaining on an unverified "done" and discovering three phases later that the build never ran.

Standalone Codex orchestration

Follow the native lifecycle at the top of this skill. Keep the number of live agents within the concurrency limit reported by the current Codex session; queue dependent work instead of over-subscribing it. Use spawn_agent for each new bounded workstream and never invoke the Claude-to-Codex bridge.

Claude agent teams and dynamic workflows are Claude-only. Do not try to emulate their APIs in Codex; native agents plus the current concurrency limit are the Codex path for the fan-out guidance below.

When to Fan Out (Teams mode)

Use full parallel team fan-out instead of sequential subagent delegation when:

ScenarioFan out?Why
3+ independent file areasYesMaximum parallelism, isolated context per agent
Frontend + Backend + TestsYesNo file conflicts, clear boundaries
Large codebase analysisYesIndependent context per agent prevents bleed
Competing approachesYesExplore alternatives in parallel before deciding
Sequential dependent workNoUse subagents in sequence; fan-out adds overhead
Quick single investigationNoOverhead not worth it; use /explore directly

Prerequisites for fan-out

Two different mechanisms get confused here, so be explicit about which one you want:

  • Subagent fan-out (Agent calls in one message) needs nothing enabled. This is what cc-settings actually uses, and what the rest of this skill assumes. Each subagent gets its own context window and reports back to you.
  • **A
阅读完整来源 ↗