昨天我在掘金发了那篇《Subagent 分工实战:12 万 token 的 Agent 任务拆成 4 个子智能体》,评论区第一个问题就是:"拆完是不是更慢了?"
说实话,第一版确实更慢了。慢到我一度想把这套架构整个删掉。
那篇讲的是怎么拆,这篇讲的是拆完之后踩的坑。同一份任务、同一套代码,我从 47 分钟压到 11 分钟,中间改了五版调度逻辑。如果你正在做多智能体编排,这几个问题你迟早会撞上。
一、先说结论:拆分的收益不在并行,在上下文隔离
我最初拆 subagent 的动机很朴素------12 万 token 的任务塞一个 Agent 里,上下文窗口不够用,模型开始忘事。
第一版架构是这样的:一个 Orchestrator 拿到任务,切成 4 个子任务,分给 4 个 Worker 并行跑,最后汇总。听起来很标准。
跑出来 47 分钟,比不拆还慢 8 分钟。我拉了时间线才看明白:4 个 Worker 里有 3 个在等第 1 个的结果,因为我在切任务时没做依赖分析,子任务之间是串行依赖的,并行了个寂寞。
真正让速度起来的,是我把"并行"这个执念放下之后------每个 subagent 只带自己那一段上下文,跑完把结构化结果交回去,主 Agent 的上下文从头到尾只增长不到 2 万 token。这才是拆分最大的价值。速度是副产品。
二、任务切分:别按字数切,按"可独立验证"切
我第一版的切分逻辑是拿 token 数均分,每段 3 万 token。这个做法错得很彻底。
原因很简单:一份 12 万 token 的代码库分析任务,按字数切会把同一个模块的接口定义和实现切到两个 Worker 里。拿到接口定义的 Worker 不知道实现长什么样,拿到实现的 Worker 不知道调用方怎么用,两个人都只能猜。
我改成按"可独立验证的单元"切:
python
from dataclasses import dataclass, field
@dataclass
class SubTask:
task_id: str
goal: str # 一句话说清要产出什么
inputs: list[str] # 需要哪些文件/片段
depends_on: list[str] = field(default_factory=list) # 依赖哪些 task_id
acceptance: str = "" # 怎么算完成
max_tokens: int = 30000
def plan_subtasks(repo_index: dict) -> list[SubTask]:
tasks = []
for module, info in repo_index.items():
tasks.append(SubTask(
task_id=f"analyze-{module}",
goal=f"分析 {module} 模块的职责边界与对外接口",
inputs=info["files"],
depends_on=[],
acceptance="输出:依赖列表、对外暴露的函数签名、3 个潜在耦合点",
))
# 汇总任务必须显式依赖所有分析任务
tasks.append(SubTask(
task_id="synthesize",
goal="汇总各模块分析,输出整体架构风险清单",
inputs=[],
depends_on=[t.task_id for t in tasks],
acceptance="输出:按严重程度排序的风险清单,每条附证据文件路径",
))
return tasks
关键在 acceptance 这个字段。我第一版没有它,结果 4 个 Worker 交回来的东西格式各异------有的给 Markdown 表格,有的给 JSON,有的干脆写了一篇小作文。汇总 Agent 光是解析就花了 12 分钟。
有了 acceptance 之后,每个 Worker 的产出格式固定,汇总环节从 12 分钟降到 40 秒。
三、依赖图执行:拓扑排序 + 分层并发
有了 depends_on,执行就不能简单 for task in tasks: run(task) 了。我用的是分层拓扑排序,每一层内部并发,层与层之间串行:
python
from concurrent.futures import ThreadPoolExecutor, as_completed
def run_dag(tasks: list[SubTask], run_one, max_workers=4):
remaining = {t.task_id: t for t in tasks}
done: dict[str, dict] = {}
while remaining:
# 找出所有依赖已满足的任务
ready = [t for t in remaining.values()
if all(d in done for d in t.depends_on)]
if not ready:
raise RuntimeError(f"依赖成环或依赖缺失: {list(remaining)}")
with ThreadPoolExecutor(max_workers=max_workers) as pool:
futures = {pool.submit(run_one, t, done): t for t in ready}
for fut in as_completed(futures):
task = futures[fut]
try:
done[task.task_id] = fut.result()
except Exception as e:
done[task.task_id] = {"ok": False, "error": str(e)[:300]}
remaining.pop(task.task_id, None)
return done
if not ready: raise 这一行救过我一次。有一次我在 depends_on 里手写了个 task_id 拼错,循环直接死锁,进程挂了但没报错,我在外面等了二十分钟才发现。现在成环或者依赖缺失会立刻炸出来。
四、Worker 之间的通信:只回传结构化摘要,别回传原文
这是第二个让我提速的地方。
第一版里,Worker 完成任务后把"我读了哪些文件、文件里有什么"原样塞回主 Agent。4 个 Worker 一汇总,主 Agent 的上下文直接冲到 9 万 token,然后它开始忘事------明明前面已经分析过的东西,它又问了一遍。
现在我强制 Worker 只回传固定的三段式结构:
python
def make_result(task: SubTask, findings: list[str], evidence: list[str]) -> dict:
return {
"task_id": task.task_id,
"ok": True,
"summary": " | ".join(findings)[:800], # 结论,最多 800 字
"evidence": evidence[:10], # 证据文件路径,最多 10 条
"tokens_used": 0,
}
summary 截断到 800 字符,evidence 只留路径不留内容。主 Agent 需要细节时可以按路径回查,但它平时不需要------它只需要知道"哪个模块有什么问题"。
改完之后主 Agent 的峰值上下文从 9 万降到 1.8 万,任务完成时间从 47 分钟到 19 分钟。
五、失败处理:单个 Worker 挂了不能拖垮全局
第三版的问题更隐蔽。有个 Worker 因为调用的外部接口超时挂了,我的代码里没有兜住,整个 as_completed 循环抛异常,已经跑完的 2 个 Worker 结果全丢了。
现在每个 Worker 外面包一层,失败就返回一个带 ok: False 的结果,让汇总 Agent 知道"这块没分析到",而不是整个任务失败:
python
def safe_run(task: SubTask, context: dict) -> dict:
try:
return run_worker(task, context)
except TimeoutError:
return {"task_id": task.task_id, "ok": False,
"error": "worker 超时", "summary": "", "evidence": []}
except Exception as e:
return {"task_id": task.task_id, "ok": False,
"error": str(e)[:300], "summary": "", "evidence": []}
汇总环节里我加了一句 prompt:"如果某个子任务 ok=False,必须在风险清单里单独列出未覆盖范围。"这样即使有 Worker 挂了,产出依然是完整可用的,只是多了一条"此处未覆盖"的说明。
六、最后压到 11 分钟,靠的是这三件事
从 47 分钟到 11 分钟,拆开看是这样:
- 拓扑分层并发(而不是盲目并行):47 → 26 分钟
- 结构化回传 + 上下文隔离:26 → 19 分钟
- Worker 级容错 + 汇总格式固定:19 → 11 分钟
最后那 11 分钟里,模型调用占了 9 分钟,剩下 2 分钟是我自己的文件 IO。也就是说,再往上优化得从 prompt 和任务粒度下手了,调度层已经没什么可挤的。
我现在的判断
Subagent 这套东西,最大的坑不是技术实现,是你会不自觉地用单 Agent 的思维去设计多 Agent------总想让每个 Worker 知道所有事,总觉得信息越多越好。
实际上每个 Worker 知道得越少、交付得越规整,整体就越快。我现在写 subagent 的第一件事不是想"它需要什么信息",而是想"它必须交出什么格式的东西"。
如果你也在拆任务,建议先做两件事:给每个子任务写死 acceptance 字段,然后强制 Worker 只回传 800 字以内的摘要。这两处改动加起来不到三十行,但能让你少走我这两天的弯路。