如何用 1 个 Claude Agent 运行 10 个其他 Agent · 9 步集群循环

你给 Claude 一条指令。十个 Agent 同时开始工作。二十分钟后你回来，看到十个已完成的分支，每个都经过测试和审查。

这不是幻想中的设定，也不是第三方工具。这是 Claude Code 内置的模式，称为动态工作流（Dynamic Workflows），其中单个主导 Agent 可以在一个会话中规划并扩展出数十个甚至数百个并行子 Agent，同时有一个评分者（grader）将每个子 Agent 的结果打回去修改，直到其结果通过门槛。

但陷阱在于：如果错误地启动十个 Agent，你会得到十个相互冲突的差异（diff）、一个被污染的上文，以及花费比并行节省的时间更多的时间来合并混乱。一个有效的集群与一个自相矛盾的集群之间的区别在于主导 Agent 运行的循环。以下是 9 个步骤。

1. 选择一项真正能展开的任务

只有当工作能拆分成独立部分时，集群才有帮助。

这一步决定了集群是有益还是有害。当任务自然分解成互不依赖的片段时，子 Agent 才有价值：每个模块的文档、跨多个独立文件的迁移、跨几十种组合的基准测试。如果各个部分纠缠在一起，十个 Agent 只会互相干扰。

好的集群任务 vs 不好的集群任务
好："为所有 12 个模块生成文档"（每个模块独立）
好："将 30 个文件从旧 API 迁移到新 API"
不好："构建一个功能，其中每一层都依赖于上一层"
经验法则：如果你说不出 3 个以上真正独立的片段，就用一个 Agent

✓ 只有当工作真正可以分开时，你才召集集群

2. 让主导分解工作

主导在生成任何子 Agent 之前，先将任务分解为原子化的子任务。

主导 Agent 的首要任务不是生成工作线程，而是分解。它将任务拆分为离散的子任务，每个子任务都有明确的输入、输出和验收标准。好的子任务是原子化的：有界文件、明确的可交付件、可独立验证。这种分解保证了并行的安全性。

要求主导进行分解
"你是主导。将此任务分解为独立的子任务。
对于每个子任务：它负责的文件、确切的可交付件、
以及如何验证它已完成。现在不要生成任何子 Agent。
先给我看分解结果。"

✓ 现在任务变成了一组清晰、独立的单元，而非一个整体

3. 在任何人开始生成之前批准计划

审查分解结果。错误的依赖关系将在后面变成合并地狱。

这是你的一个人工检查点，也是最重要的一个。分解计划决定了并行运行的内容。如果主导弄错了依赖关系，两个 Agent 会修改同一个东西，你会遇到集成冲突。在批准调度之前，务必阅读计划。

计划中需要检查什么： 任何两个子任务是否触及相同的文件？（不应该。）每个可交付件是否可独立验证？依赖关系是否正确？现在修正计划只需要一条消息。后面修正混乱的合并可能需要一个小时。

✓ 你在依赖关系变成合并冲突之前就发现了它们

4. 给每个工作线程它自己的工作树

隔离是阻止十个 Agent 互相覆盖的关键。

如果你的子 Agent 并行写入文件，它们需要隔离，否则会互相覆盖。Git 工作树（worktree）给每个 Agent 提供自己的检出（checkout），位于自己的分支上，因此它们可以同时工作而不触及相同的工作目录。当每个 Agent 完成后，其分支就可以干净地合并了。

隔离每个 Agent
# 添加到每个子 Agent 的前置元数据
isolation: worktree

# Claude Code 为每个 Agent 提供一个新的工作树
# 并在 Agent 完成后自动清理它
# 十个 Agent，十个分支，零文件冲突

✓ 十个 Agent 同时工作，绝不触及相同文件

5. 展开集群

现在主导调度工作线程，并行进行。

计划批准并且隔离设置好后，主导进行调度。对于少量 Agent，主导直接生成子 Agent。对于需要大规模展开的工作，动态工作流让主导在一个会话中规划并运行数十到数百个子 Agent。每个子 Agent 在自己的上下文窗口中运行，只返回其结果，因此主导的上下文保持干净以便协调。

调度集群
"计划已批准。为每个子任务调度一个子 Agent，并行进行，
每个在自己的工作树中。每个 Agent 只获得它需要的上下文，
并返回一个结果摘要。在所有 Agent 报告完成之前不要合并任何东西。"

最佳点： 三到五个并发 Agent 适合大多数日常工作。只有当任务真正需要大规模展开时（例如基准测试套件、跨许多独立文件的编辑）才推到数十或数百个。超过最佳点后，你会花更多时间合并摘要，而不是节省时间。

✓ 整个集群现在同时工作，各自隔离

6. 用钩子（Hook）把关每个结果

任何工作线程的输出只有在通过你的不可协商条件后，才能被合并回来。

十个 Agent 意味着有十次机会让某些东西溜过去。SubagentStop 钩子在子 Agent 完成时立即运行，并强制执行你的不可协商条件，然后主导才被允许将结果合并回来：测试通过、差异中没有秘密、没有超出范围的文件写入。它是确定性的，因此它检查每一个 Agent，而不是大多数。

.claude/settings.json // 把关每个 Agent
{
  "hooks": {
    "SubagentStop": [{
      "command": "npm run test && npm run lint"
    }]
  }
}

# 每个子 Agent 的工作在合并前都被检查
# 一个坏的 Agent 不能悄悄地污染结果

✓ 每个工作线程的输出在允许接近你的主分支之前都经过验证

7. 评分结果并打回较弱的

一个独立的评分者根据评分标准对每个结果进行评分，如果未达标则强制修订。

这一步将集群从“快但粗糙“变成“又快又好“。一个独立的评分者根据评分标准对每个子 Agent 的结果进行评分，并将任何未达标的自动打回去修订，直到它们通过。你只需定义一次“好“的标准，集群就会自动自我修正，无需你手动审查所有十个。

设定标准
"根据以下评分标准对每个子 Agent 的结果进行评分：
- 存在更改的测试并通过
- 遵循 CLAUDE.md 中的约定
- 没有遗留的 TODO 或占位符代码

将任何未达标的结果打回给它的 Agent 进行修订。
重复直到每个结果都通过。"

✓ 弱的结果会自动修订，而不是落到你头上

8. 让主导进行合并，而非工作线程

主导是集成层。工作线程绝不集成自己的工作。

有一个错误会毁掉集群：要求子 Agent 集成自己的工作。这样做会导致重复和冲突。主导是集成层。它收集已评分并通过的结果，并以受控的顺序合并它们，就像技术负责人从团队中收集工作，而不是每个工程师各自向主分支推送。

仅主导合并
"只有你，主导，进行合并。收集通过的分支，并按依赖顺序集成。
每次合并后，运行完整的测试套件后再进行下一个。
如果两个结果冲突，不要猜测，停下来告诉我。"

✓ 一个 Agent 负责集成，因此合并保持干净有序

9. 将整个集群保存为一个命令

将整个循环打包，这样你用一个词就能触发集群。

一旦循环正常工作，就将其打包。Claude Code 已经内置了一个批处理技能（batch skill），它可以将一个大的变更拆分成多个工作树隔离的子 Agent，每个子 Agent 打开一个拉取请求（pull request），你可以将你自己的这个 9 步循环版本包装成一个可复用的技能或斜杠命令。设置一次之后，“运行这个集群“就变成了一个触发器。

.claude/skills/swarm/SKILL.md // 你的循环，一个触发器
# /swarm : 分解、隔离、调度、评分、合并
1. 检查任务是否真正能展开
2. 分解为独立的子任务
3. 向我展示计划，等待批准
4. 给每个 Agent 自己的工作树
5. 并行展开集群
6. 用 SubagentStop 钩子把关每个结果
7. 根据评分标准评分，修订弱的
8. 主导按顺序合并通过的结果

✓ 整个 9 步集群现在从一个命令运行

为什么循环比集群本身更重要

任何人都可以生成十个 Agent。大多数人集群产生混乱的原因是跳过了结构：没有分解、没有隔离、没有评分、没有单一集成者。十个不受管理的 Agent 只是十种制造合并冲突的方式。循环才是将一群乌合之众变成团队的关键。

• 分解加上你的批准意味着工作被干净地拆分，而非杂乱无章
• 工作树意味着十个 Agent 永远不会互相覆盖
• 钩子加上评分者意味着每个 Agent 的质量是被强制执行的，而非仅凭希望
• 单一主导集成者意味着合并保持干净，而不是变成堆积
• 命令意味着你一次性设置好，然后用一个词运行集群

诚实的结论： 运行 10 个 Agent 本身并不令人印象深刻——它很容易，而且通常是一团糟。运行 10 个 Agent，并且它们返回一个干净、经过测试、合并好的结果，才是真正的技能。这项技能在于循环，而不在于集群。