为什么你的 Subagent 拆完反而更慢?我把 12 万 token 的任务重做了一遍

昨天我在掘金发了那篇《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 字以内的摘要。这两处改动加起来不到三十行,但能让你少走我这两天的弯路。

相关推荐
颜进强11 分钟前
微信小微AI-接入模式与开通准备|两种模式选错,后面全白干——小微接入的隐藏门槛
前端·ai编程·全栈
htzyl20614 分钟前
CSS中,`:has()` 能帮你删掉的 4 类 JS
前端·css
verohh19 分钟前
(四)配置驱动与动态渲染——从固定页面到可组合的前端架构
前端
颜进强23 分钟前
认识小微|一句话就能直接调起你小程序的微信 AI,多数人第一眼就理解错了
前端·ai编程·全栈
锐影用AI做小程序30 分钟前
uni-app X + Spring Boot 做在线工具站:6 个真实踩坑与解法
前端
掘金挖土30 分钟前
前端手摸手跑路之 AI 应用开发(十二)
前端·后端
颜进强31 分钟前
微信里冒出一个新 AI 入口,我们把接入它的每一步坑都写下来了
前端·ai编程
不要试图纠正别人31 分钟前
178 个 IPC 通道不可怕,可怕的是 preload 里那一行
前端·electron
bai27334 分钟前
Node 22 里的等待:从回调到 Promise,一次上传流程的最小记录
前端