Claude Dynamic Workflow 深度解析

发布时间：2026 年 5 月 28 日随 Claude Opus 4.8 一同推出，目前处于 Research Preview 阶段。

---

目录

1. 背景：一次架构级的升级
2. 什么是 Dynamic Workflow
3. 子 Agent 的底层原理
4. Dynamic Workflow 如何调度 Agent
5. 为什么叫"Dynamic"——与传统 Workflow 的区别
6. 使用指南
7. 运行时约束与费用
8. 总结

---

一、背景：一次架构级的升级

使用过 Claude Code 的开发者都熟悉这样一个痛点：当任务规模足够大（比如审计一个有几百个文件的代码库），Claude 会开始"迷失"——它既是工人又是指挥官，每一步的工具调用结果都要写回自己的上下文窗口，随着任务推进，200K token 的上下文越来越满，推理质量开始下降，最终在任务完成之前"撑不住"。

Dynamic Workflows 是 Anthropic 在 2026 年 5 月 28 日随 Claude Opus 4.8 推出的解决方案，它从根本上改变了 Claude 处理大规模任务的架构。

---

二、什么是 Dynamic Workflow

一句话定义：Dynamic Workflow 是一段由 Claude 自动编写的 JavaScript 编排脚本，由独立运行时在后台执行，通过调度数十至数百个并行子 Agent 来完成大规模任务。

你只需用自然语言描述任务，Claude 会：

1. 分析任务的规模与结构，自动生成 JavaScript 编排脚本
2. 将脚本提交给独立的 Workflow 运行时执行
3. 运行时调度大量并行子 Agent 分工协作
4. 所有中间结果存储在脚本变量中，不占用主对话的上下文
5. 最终将汇总结果返回给你

典型使用场景：

• 跨数十万行代码的大规模库迁移（从启动到 PR 合并全自动）
• 全量代码库安全审计（扫描所有 API 端点的鉴权检查）
• 深度研究（/deep-research，跨多个来源并行搜索并交叉验证）
• 大型重构后的全量不变量验证
• 多角度方案规划（并行起草多个方案后综合择优）

---

三、子 Agent 的底层原理

理解 Dynamic Workflow，必须先理解子 Agent 是如何被"召唤"出来的。

3.1 Agent 的本质

每一个 Agent（包括子 Agent）就是一次独立的 Claude API 调用，拥有自己的：

• 独立上下文窗口（200K token，全新的，不含父对话历史）
• 独立工具权限列表
• 独立执行循环（推理 → 工具调用 → 结果写回 → 再推理）

父子 Agent 之间的唯一通信渠道，是一个名为 Agent 的工具（Tool）的调用与返回。

3.2 "Agent 工具"的调用机制

Claude 本身运行在一个推理循环里：

接收上下文 → 生成思考 + Tool Call → 执行工具 → 结果写回上下文 → 继续推理...

Agent 就是其中一个工具，和 ReadFile、BashExec 地位相同。当 Claude 判断某个子任务适合委托时，它生成如下的 Tool Call：

{
  "tool": "Agent",
  "input": {
    "prompt": "扫描 src/routes/user.ts，找出所有缺少鉴权检查的端点，返回行号和函数名",
    "tools": ["ReadFile", "Grep"],
    "model": "claude-opus-4-8"
  }
}

Claude Code 的运行时（内部对应 AgentTool.tsx）接到这个调用后：

1. Fork 出一个新的执行上下文（类比操作系统的 fork）
2. 以 prompt 为首条消息，发起一次全新的 Claude API 请求
3. 子 Claude 拥有自己的推理循环，可以调用被授权的工具
4. 子 Agent 内部的所有中间步骤永远不传回父 Agent
5. 子 Agent 的最终输出，作为 Agent 工具的返回值，写入父 Agent 上下文

用图示意：

父 Agent 上下文
┌────────────────────────────────────────────┐
│ [用户] 帮我审计所有 API                     │
│ [Claude 思考] 需要并行扫描多个文件...        │
│ [Tool Call] Agent("扫描 user.ts")          │
│                  │                          │
│         ┌────────▼───────────┐             │
│         │  子 Agent 上下文    │             │
│         │  [读文件][Grep]...  │  ← 全程隔离 │
│         │  [结论：第42行缺失] │             │
│         └────────────────────┘             │
│ [Tool Result] "第42行缺失鉴权"  ← 只收结论  │
│ [Claude 继续推理]...                        │
└────────────────────────────────────────────┘

3.3 内置的三种子 Agent 类型

Claude Code 内置了三种子 Agent，主 Claude 会根据任务性质自动路由：

类型	用途	默认模型
Explore	只读的文件发现与代码搜索	Haiku（速度快、省钱）
Plan	收集上下文后生成策略方案	Opus
General-purpose	既要探索又要修改的通用任务	Opus

---

四、Dynamic Workflow 如何调度 Agent

普通子 Agent 机制虽然强大，但规模受限——父 Claude 的上下文窗口会随着每个子 Agent 的返回结果不断膨胀，最终成为瓶颈。

Dynamic Workflow 的解法是：把编排逻辑从 Claude 的脑子里搬进 JavaScript 脚本。

4.1 运行时原语（Runtime Primitives）

Workflow 运行时向脚本注入了一套专用 API，核心是 agent() 函数，以及用于控制执行流的 parallel()、pipeline()、phase()：

// 这是 Claude 自动生成的编排脚本（真实可查看）

// 第一阶段：并行扫描所有路由文件
const results = await parallel([
  agent({
    prompt: "扫描 src/routes/user.ts，找出缺少鉴权的端点",
    tools: ["ReadFile", "Grep"],
    schema: {
      type: "object",
      properties: { issues: { type: "array" } }
    }
  }),
  agent({
    prompt: "扫描 src/routes/admin.ts，找出缺少鉴权的端点",
    tools: ["ReadFile", "Grep"],
  }),
  agent({
    prompt: "扫描 src/routes/payment.ts，找出缺少鉴权的端点",
    tools: ["ReadFile", "Grep"],
  })
]);

// 第二阶段：对抗性验证——另起一批 Agent 挑战上面的结论
const verified = await agent({
  prompt: `以下是初步扫描结果：${JSON.stringify(results)}
           请逐条验证，排除可能的误报，给出最终确认清单`,
  tools: ["ReadFile"],
});

每一个 agent() 调用，背后就是一次独立的 Claude API 请求。脚本本身运行在沙箱环境中，不能直接操作文件系统，只能通过这些原语来启动子 Agent，由子 Agent 代为执行真实操作。

4.2 对抗性验证（Adversarial Verification）

Dynamic Workflow 内置了一个重要的质量保障机制：在主任务 Agent 完成工作后，系统可以再调度一批独立的验证 Agent 专门挑战、质疑前者的结论，只有经过交叉验证的结果才会最终上报。这使得输出的可信度远高于单次运行。

4.3 完整架构层次图

你的提示词
    │
    ▼
┌──────────────────────────────────────────────────┐
│  主 Claude（Orchestrator）                        │
│  · 接收你的需求，分析任务规模                      │
│  · 动态生成 JavaScript 编排脚本                    │
│  · 等待运行时执行完毕                              │
│  · 只看最终汇总报告                                │
└──────────────────┬───────────────────────────────┘
                   │ 提交脚本
                   ▼
┌──────────────────────────────────────────────────┐
│  Workflow 运行时（JS 沙箱）                       │
│  执行脚本中的循环、分支、变量存储逻辑             │
│                                                   │
│   parallel([                                      │
│     agent("扫 user.ts")    ──→  [子 Claude #1]   │
│     agent("扫 admin.ts")   ──→  [子 Claude #2]   │
│     agent("扫 payment.ts") ──→  [子 Claude #3]   │
│   ])                                              │
│                                                   │
│   results 存入脚本变量  ←  子 Claude 们返回结论    │
│                                                   │
│   agent("对抗性验证")      ──→  [子 Claude #4]   │
│                                                   │
│   final_result = verified                         │
└──────────────────┬───────────────────────────────┘
                   │ 返回最终结果
                   ▼
             主 Claude 上下文
           （只接收这一条最终结果）

---

五、为什么叫"Dynamic"——与传统 Workflow 的区别

5.1 传统 Workflow：静态节点编排

以 n8n、Dify、LangGraph、Zapier 为代表的传统工作流工具，核心特征是：

[节点A] → [节点B] → [条件分支] → [节点C]
                              ↘ [节点D]

• 流程图运行前由人工预先定义，结构固定
• 每个节点是什么、如何连接，全部人工配置
• 运行时只是按图索骥地执行
• 本质：人写逻辑，机器执行

5.2 "Dynamic"的核心含义

Dynamic Workflow 中"动态"体现在两个层面：

层面一：编排脚本由 AI 实时生成

你描述需求 → Claude 理解任务 → Claude 动态写出最适合该任务的编排脚本 → 脚本被执行。不需要人来画流程图。

层面二：编排结构随任务规模自适应

即使对于同一个任务描述，Claude 每次生成的脚本也可能不同：

• 代码库有 100 个文件 → Claude 生成 10 路并行的脚本
• 代码库有 10000 个文件 → Claude 生成分批 + 递归汇总的脚本

编排结构本身会根据任务的实际情况自动调整。

5.3 三种模式的全面对比

	传统 Workflow（n8n/Dify）	普通 Agent 调子 Agent	Dynamic Workflow
谁设计编排	人（可视化拖拽）	Claude（逐轮推理）	Claude（一次性生成脚本）
编排结构	运行前固定	运行时动态决定	运行前生成、运行时固定
中间状态存放	平台数据库	Claude 上下文窗口	脚本变量（不进任何 Claude 上下文）
规模瓶颈	取决于人设计的节点数	受 200K 上下文限制	最多 1000 个 Agent
可重复运行	是（流程图不变）	否	是（脚本可保存复用）
适合任务类型	固定流程的自动化	小型多步骤任务	大规模、结构事先未知的任务

5.4 继承与升维的关系

Dynamic Workflow 并非颠覆传统 Workflow，而是继承并升维：

传统思想	Dynamic Workflow 中的体现
编排即代码	脚本就是流程定义，可版本控制、可复用
节点隔离	每个子 Agent 有明确输入输出，内部过程不泄漏
并行/串行控制	parallel()、pipeline()、phase() 是 DAG 调度的 AI 版本
新增：自生成能力	不再需要人画图，Claude 理解任务后自动生成最合适的图

---

六、使用指南

6.1 环境要求

• Claude Code v2.1.154 或更高版本
• 付费计划（Max、Team、Enterprise 默认开启；Pro 需在 /config 手动启用）
• 支持平台：CLI、Desktop App、VS Code 插件、Amazon Bedrock、Google Vertex AI、Microsoft Foundry

6.2 三种触发方式

方式一：在提示词中包含 “workflow” 关键词（最直接）

Run a workflow to audit every API endpoint under src/routes/ for missing auth checks

Claude Code 会高亮该词，Claude 随即为这个任务生成编排脚本。如果这次不想触发，按 Option+W（macOS）或 Alt+W（Windows/Linux）可取消。

方式二：开启 Ultracode 模式（最激进）

/effort ultracode

Ultracode = xhigh 推理力度 + 对每个实质性任务自动触发工作流。Claude 自主判断是否需要启动工作流，一个请求可能连续触发多个工作流（先理解代码、再执行修改、再验证结果）。当前会话结束后自动复位。

方式三：运行内置工作流（最简单）

/deep-research What changed in the Node.js permission model between v20 and v22?

/deep-research 是 Anthropic 内置的深度研究工作流，并行搜索多个角度，交叉验证来源，生成带引用的报告。

6.3 审批与监控

运行前 Claude Code 会展示计划阶段（phases）并请求确认：

• Yes, run it：直接启动
• View raw script：先查看脚本再决定
• No：取消

运行时随时可用 /workflows 查看进度：

按键	操作
↑ / ↓	选择阶段或 Agent
Enter / →	钻取查看 Agent 的提示词、工具调用和结果
p	暂停 / 恢复
x	停止选中的 Agent 或整个工作流
r	重启选中的 Agent
s	将脚本保存为可复用命令

6.4 保存为可复用命令

运行成功后，按 s 保存脚本：

• 保存到 .claude/workflows/（项目级，随 Git 共享给团队）
• 保存到 ~/.claude/workflows/（个人级，所有项目可用）

之后直接用 /命令名 运行，还可以通过 args 传入动态参数：

> Run /audit-routes on src/routes/payments/

---

七、运行时约束与费用

7.1 硬性约束

约束	数值	原因
最大并发 Agent 数	16 个（低配机器更少，取 min(16, CPU核数-2)）	控制本地资源占用
单次运行最多 Agent 数	1000 个	防止失控循环
工作流脚本本身	不能直接操作文件系统/Shell	只有子 Agent 才能读写执行
运行中用户输入	不支持中途干预	如需分阶段确认，需拆成多个工作流

7.2 费用提醒

Dynamic Workflow 会显著增加 Token 消耗，因为同时运行大量子 Agent。官方建议：

先用小范围测试（比如一个目录而不是整个仓库），确认效果后再扩大规模。/workflows 视图实时显示每个 Agent 的 Token 用量，可随时中止已完成的部分不会丢失。

另外，脚本中每个 agent() 调用如果未指定 model 参数，会继承会话的当前模型。在大规模工作流中，建议对验证阶段等关键 Agent 显式指定模型：

agent({
  prompt: "验证以上结论",
  model: "claude-opus-4-8",  // 显式指定，避免会话模型切换影响结果
  tools: ["ReadFile"]
})

---

八、总结

架构演进的三个阶段

传统 Workflow  →  人是架构师，机器是工人
普通 Agent     →  机器既是架构师又是工人，但规模受上下文限制
Dynamic Workflow → 机器是架构师（生成脚本），脚本调度大量工人（子 Agent）

核心价值

Dynamic Workflow 解决的不是"Claude 能不能完成这个任务"，而是"Claude 能不能在不崩溃的情况下完成大规模任务"。通过把编排逻辑搬进脚本，中间状态不再占用上下文窗口，任务规模从"几十步"扩展到了"数小时乃至数天的持续运行"。

子 Agent 本质是一次新的 Claude API 调用，父 Agent 通过调用 Agent 工具来触发它；Dynamic Workflow 把"调度逻辑"从 Claude 的上下文搬进了 JavaScript 脚本，由脚本决定什么时候调 agent()、调多少个、怎么并行，从而突破了上下文窗口的规模瓶颈。

---

参考资料：

• Introducing Claude Opus 4.8 - Anthropic
• Orchestrate subagents at scale with dynamic workflows - Claude Code Docs
• Subagents in the SDK - Claude Code Docs
• Ch 8. Spawning Sub-Agents - Claude Code from Source