10. 高级 Workflow 模式

什么时候需要高级模式

  • 任务有条件分支(根据中间结果走不同路径)
  • 需要对抗验证(一个 Agent 写,另一个找茬)
  • 需要预算控制(成本上限)
  • 需要多模态(同时用代码搜索 + 文档搜索 + 网页搜索)

模式 1:对抗验证(Adversarial Verify)

适用:不能容忍错误的关键任务(代码评审、安全审计、事实核查)。

const claims = [/* 待验证的论断 */]
const votes = await parallel(
  claims.map(c => () =>
    parallel([
      () => agent(`尝试反驳这个论断:${c}`, {schema: VERDICT}),
      () => agent(`尝试反驳这个论断:${c}`, {schema: VERDICT}),
      () => agent(`尝试反驳这个论断:${c}`, {schema: VERDICT})
    ])
  )
)
// 3 票里 ≥2 票未反驳才算通过
const survived = votes.filter(v => v.filter(x => !x.refuted).length >= 2)

为什么有效:单个 Agent 容易遗漏,3 个独立 Agent 找不同角度的问题,通过率显著提升。

模式 2:多视角评审(Judge Panel)

适用:方案选择(架构选型、UI 设计、算法取舍)。

// 阶段 1:生成 3 个独立方案
const proposals = await parallel([
  () => agent("从性能优先的角度设计 X", {schema: PROPOSAL}),
  () => agent("从可维护性优先的角度设计 X", {schema: PROPOSAL}),
  () => agent("从用户友好优先的角度设计 X", {schema: PROPOSAL})
])

// 阶段 2:多角度评分
const scores = await parallel(
  proposals.map(p => () =>
    parallel([
      () => agent(`从性能角度评分:${p}`, {schema: SCORE}),
      () => agent(`从可维护性角度评分:${p}`, {schema: SCORE}),
      () => agent(`从教学价值角度评分:${p}`, {schema: SCORE})
    ])
  )
)

// 阶段 3:综合出最终方案
const final = await agent(
  `综合 3 个方案的优势,产出最终设计:${JSON.stringify(proposals)}`,
  {schema: FINAL_DESIGN}
)

模式 3:循环直到耗尽(Loop-Until-Dry)

适用:探索型任务(找 bug、列风险、查兼容性问题)。

const allFindings = []
let dryCount = 0
const seen = new Set()

while (dryCount < 2 && budget.remaining() > 50_000) {
  const found = await agent("在这个代码库里找潜在的并发 bug", {schema: FINDINGS})
  const fresh = found.bugs.filter(b => !seen.has(b.id))
  if (fresh.length === 0) {
    dryCount++
  } else {
    dryCount = 0
    fresh.forEach(b => seen.add(b.id))
    allFindings.push(...fresh)
  }
}
return allFindings

关键:用 seen set 去重,而不是 allFindings,否则被否决的会反复出现。

模式 4:流水线 + 验证(Pipeline with Verify)

适用:批量内容生成(出题、生成文档)。

const items = [/* 10 个章节 */]

const results = await pipeline(
  items,
  item => agent(`为章节 ${item} 出 3 道练习题`, {schema: QUIZ}),
  quiz => parallel([
    () => agent(`审核难度递进:${quiz}`, {schema: REVIEW}),
    () => agent(`审核答案准确性:${quiz}`, {schema: REVIEW})
  ]).then(reviews => ({quiz, reviews}))
)

const passed = results.filter(r =>
  r.reviews.filter(x => x.pass).length >= 1
)

模式 5:工作树隔离(Isolation: worktree)

适用:多个 Agent 同时修改文件且会冲突的场景。

const agents = [
  agent("重构模块 A", {isolation: "worktree"}),
  agent("重构模块 B", {isolation: "worktree"}),
  agent("重构模块 C", {isolation: "worktree"})
]
const results = await parallel(agents.map(a => () => a))
// 之后人工合并各 worktree 的改动

注意:worktree 创建有 200-500ms 开销,不要滥用,只在确实需要隔离时用。

模式 6:预算感知(Budget-Aware)

适用:成本敏感任务(批量跑实验)。

while (budget.total && budget.remaining() > 100_000) {
  const result = await agent("...")
  process(result)
  log(`已用 ${budget.spent()} / ${budget.total}`)
}

Workflow 调试技巧

1. 阶段化日志

每个阶段都 log():

phase('调研')
log('开始调研...')
const data = await agent(...)
log(`拿到 ${data.length} 条结果`)

2. 失败重试粒度

  • 单个 Agent 失败:让它自己重试
  • 阶段失败:保存中间结果,手动接续
  • 不要从头跑整个 Workflow

3. Schema 校验失败

如果 Agent 输出不符合 schema,别让 Workflow 自动重试——大概率还是同样的输出。先打印原始结果,看哪里出问题,调整 prompt 或 schema。

4. 中间结果落盘

import fs from 'fs'
fs.writeFileSync('debug-stage1.json', JSON.stringify(data))

Workflow 设计反模式

反模式为什么坏
每个阶段都并行不必要的复杂度
嵌套 3 层 parallel难以调试,token 暴增
没有 dry 条件的循环可能无限循环
一个 Agent 干太多事拆成多个更稳

给教师的高级 Workflow 案例

案例 1:批量初评 + 教师复核

// 阶段 1:批量初评(便宜模型)
const initial = await pipeline(
  studentAssignments,
  a => agent(`给这份作业初评:${a}`, {model: 'haiku'})
)

// 阶段 2:只对可疑的(代码跑不通、风格严重问题)用贵模型复核
const flagged = initial.filter(r => r.needsReview)
const reviewed = await parallel(
  flagged.map(r => () => agent(`复核:${r}`, {model: 'sonnet'}))
)

return { initial, reviewed }

案例 2:出题 + 对抗验证

// 3 个 Agent 各出 10 道题
const drafts = await parallel([
  () => agent("出 10 道关于 X 的题", {schema: QUIZ}),
  () => agent("出 10 道关于 X 的题", {schema: QUIZ}),
  () => agent("出 10 道关于 X 的题", {schema: QUIZ})
])

// 合并去重
const merged = mergeAndDedupe(drafts)

// 3 个 Agent 验证每题
const verified = await parallel(
  merged.map(q => () =>
    parallel([
      () => agent(`验证正确性:${q}`, {schema: VERIFY}),
      () => agent(`验证难度:${q}`, {schema: VERIFY}),
      () => agent(`验证清晰度:${q}`, {schema: VERIFY})
    ]).then(vs => ({q, pass: vs.filter(x => x.pass).length >= 2}))
  )
)

return verified.filter(v => v.pass).map(v => v.q)

下一步