🎯 今日核心问题
- 三种分工拓扑,在「可调试性 / 延迟 / 成本 / 质量」上各是什么脾气?
- 为什么 Pipeline 看起来最土,却常常是生产环境最该选的那个?
- 辩论式什么时候真能提升质量,什么时候只是三倍费用买了个热闹?
📖 精读提纲
【一】Supervisor:中心调度 + 专家池
一个 Supervisor Agent 持有全局目标,每次决定「下一步交给谁、给它什么任务、要不要停」。专家之间不说话,只跟 Supervisor 说话。这是最像人类团队的结构,也是最灵活的:路径可以动态变化,专家可以增删,Supervisor 还能在专家失败时改派。
代价很清楚:Supervisor 自己是单点。它的上下文里要装全局目标、每个专家的一句话能力描述、以及所有已完成子任务的摘要。全局越复杂,Supervisor 越容易忘事、越容易反复派同一个任务(循环)。所以 Supervisor 模式的工程重点全在「状态摘要」上,D3 专门解决。
【二】Pipeline:固定流水线
DAG 写死在代码里,A → B → C,谁也别想改。听起来死板,但它带来三个别人换不来的东西:可预测的延迟(每段都有 SLA)、可单测(每个节点输入输出固定)、可断点续跑(每段产出落库,挂了从断点起)。只要业务流程稳定,Pipeline 的运维成本最低。
死穴是不处理例外。中间某段遇到契约外的输入,它没有「改道」的能力,只能把错误向上抛。所以 Pipeline 每一段外面必须有 D5 那套重试与熔断,而不是指望上游聪明。
【三】辩论式:多个 Agent 独立作答再交锋
让 N 个 Agent 用不同视角独立作答,然后互相看答案并反驳,最后收敛。它在判断类任务(事实核查、方案选型、合规判定)上确实有增益,因为错误常来自单一盲区,分歧能把盲区暴露出来。经验上 3 个 Agent 两轮辩论的准确率明显高于单 Agent。
但它是三种模式里最贵、最难调的:N 个 Agent × R 轮 + 一个裁判,token 是 N·R 线性放大;而且辩论容易「共识化」——几个模型都不愿反驳别人,第二轮就统一口径,白花钱。要让它有用,必须强制「每人先独立作答、不得看别人的答案」,并且要求反驳必须引用具体证据。
【四】选型决策表
不要按「哪个高级」选,按四个维度选:
- 业务路径是否稳定:稳定选 Pipeline,不稳定选 Supervisor。
- 子任务能否并行:能并行且互相独立(三个竞品各自调研),用 fans-out 并行即可,不需要辩论。
- 答案是否「对错明确」:是(核查、判定),辩论有价值;否(创作、总结),辩论基本无效。
- 出了问题要不要能定位到具体一步:要,就别用辩论,因为你无法解释最终答案来自哪个 Agent。
实战建议:先用 Pipeline 落地,把不稳定处替换成 Supervisor 的一个决策节点,辩论只在个别关键判断上做局部增强。三种模式不是三选一,是可以嵌在一个系统里的三种零件。
💻 代码示例
用同一个接口把三种拓扑统一起来,上层调用方不感知拓扑差异,替换拓扑不用改业务代码。
public interface AgentTopology {
TopologyResult run(String taskId, String objective);
}
/** 1. Pipeline:DAG 写死,段与段之间落库,可断点续跑 */
@Service
@RequiredArgsConstructor
public class PipelineTopology implements AgentTopology {
private final StageStore stageStore; // 每段产出持久化
private final Map<String, SpecialistAgent> specialists;
@Override
public TopologyResult run(String taskId, String objective) {
String cursor = stageStore.lastDoneStage(taskId); // 支持续跑
for (String stage : List.of("extract", "analyze", "compose")) {
if (cursor != null && cursor.compareTo(stage) >= 0) continue;
String upstream = stageStore.loadUpstream(taskId, stage);
String out = specialists.get(stage)
.execute(new SubTask(taskId, stage, objective, upstream));
stageStore.save(taskId, stage, out); // 先落库,再前进
}
return new TopologyResult(stageStore.load(taskId, "compose"), "PIPELINE");
}
}
/** 2. Supervisor:调度器持有状态,是否并行由调度器决定 */
@Service
@RequiredArgsConstructor
public class SupervisorTopology implements AgentTopology {
private final SupervisorAgent supervisor;
private final SpecialistRegistry registry;
private final Executor pool;
@Override
public TopologyResult run(String taskId, String objective) {
SupervisorState state = SupervisorState.fresh(objective);
for (int turn = 0; turn < 8 && !state.finished(); turn++) {
Dispatch d = supervisor.next(state);
if (d.isFanOut()) { // 一次派多个,并行执行
List<CompletableFuture<SubTaskResult>> fs = d.tasks().stream()
.map(t -> CompletableFuture.supplyAsync(
() -> registry.get(t.agent()).execute(t), pool))
.toList();
CompletableFuture.allOf(fs.toArray(CompletableFuture[]::new)).join();
fs.forEach(f -> state.record(f.join()));
} else {
state.record(registry.get(d.agent()).execute(d.single()));
}
supervisor.compress(state); // 关键:每轮压一次状态
}
return new TopologyResult(state.finalAnswer(), "SUPERVISOR");
}
}
/** 3. Debate:强制独立作答 → 互评 → 裁判收敛 */
@Service
@RequiredArgsConstructor
public class DebateTopology implements AgentTopology {
private final List<ChatModel> debaters; // 不同模型或不同温度
private final ChatModel judge;
private final Executor pool;
@Override
public TopologyResult run(String taskId, String objective) {
// 第一轮必须并行独立,彼此不可见
List<CompletableFuture<String>> fs = debaters.stream()
.map(m -> CompletableFuture.supplyAsync(() -> m.chat(
"你是独立评审。给出结论并列出支撑证据,不要假设他人意见。\n"
+ objective), pool))
.toList();
CompletableFuture.allOf(fs.toArray(CompletableFuture[]::new)).join();
List<String> answers = fs.stream().map(CompletableFuture::join).toList();
// 第二轮互评,必须有具体分歧点
String joined = IntStream.range(0, answers.size())
.mapToObj(i -> "【评审" + (i + 1) + "】\n" + answers.get(i))
.collect(Collectors.joining("\n\n"));
String prompt = "下面是同一问题的独立结论。请判定最终答案:\n"
+ "1) 逐条列出分歧点;2) 判断哪一方证据更强并说明理由;\n"
+ "3) 若证据都不足,明确输出 INSUFFICIENT,不要和稀泥。\n" + joined;
return new TopologyResult(judge.chat(prompt), "DEBATE");
}
}
三种实现共用 AgentTopology 接口,切换拓扑就是在 Spring 里换一个 Bean。注意 DebateTopology 第一轮必须是独立的 CompletableFuture 并行分支,禁止把前面的答案塞进后面的提示词——一旦泄露,辩论就退化成复读。
✏️ 今日动手
用 W3 的财报分析任务做对比实验:同一目标分别用 Pipeline 和 Debate 各跑 3 次,记录①总耗时、②总 token、③结论是否一致、④若一致,分歧是否在第二轮才消解。把表格填进笔记。你会看到一个典型结果:财报分析这种有客观数据可查的任务,辩论的边际收益接近零,因为分歧点本可以用一次工具调用(查数)解决。
🔖 明日预告
三种拓扑里最难写对的是 Supervisor——难的不是派活,是「记住已经干了什么」。明天进入实现细节:调度器的状态机长什么样、专家池怎么注册、怎么防止它无限派活。