从写代码到盯不过来
先讲个真事。我朋友老王,资深后端,前阵子迷上了用 AI Agent 给自己当小弟。最开始一个:帮我写个接口。后来他越玩越嗨——代码评审一个、单测一个、部署一个、写文档一个,群里还蹲着个「有问题随时喊我」的万能助手。
某天他猛地发现,自己不是在上班,是在「带团队」:十几个 Agent 同时在线,每个干完活都「叮」一声@他,等他看结果、做决策、再回指令。他算了一下,光是「盯进度 + 判断该不该采纳」这件事,就已经占满了他全部注意力。
模型能力一点问题没有,瓶颈悄然挪了位置:多任务的天花板,已经从「模型能不能做」变成了「人能不能盯得住」。一个人,注意力带宽就那么宽,盯不过来十几个并发任务,这是生理极限,不是努力就能解决的。
10/31 DeepSeek 开源的 Super-agent 架构与研究原型之所以当周刷屏,正是因为它碰到了这个真问题:当 Agent 数量上去之后,人该怎么「管」,而不是「陪」。(注:开源与内部持续运行属于公开报道事实;下文对其内部机制的解读为基于公开信息的架构推演,具体实现细节以官方口径为准,文中标注「待核实」之处请留意。)
双层架构调度与执行
DeepSeek 这套思路的核心,其实就一句话:把「调度」和「执行」解耦。
打个最接地气的比方——餐厅后厨。Router 是店长/排单员,站在出餐口,手里一张总单,知道哪桌点了什么、哪个菜卡住了、哪个师傅闲着。Worker 是后厨各个档口:切配、炒菜、蒸箱、甜品,各自守着自己的灶台。
店长不炒菜,档口不直接接客人的单。客人(任务)先汇总到店长,店长拆单、派单,档口只管把分配给自己的那道菜做出来。这层「谁接单、谁干活」的分离,就是双层架构的精髓。
落到 Agent 上,就变成两层:上层 Router 全局协调,下层 Worker 各自独立上下文并行干活。下面分两块说。
Router 如何全局协调
Router 是整支 Agent 小队的「大脑兼调度员」。它手里握着全局视图:当前有哪些任务、各自什么状态、彼此有没有依赖、哪个 Worker 现在空闲、哪条链路卡死了。
它做三件事:
- 收口
:所有任务入口统一归 Router,不让 Worker 互相直接喊话,避免「群聊炸锅」式的信息风暴。 - 决策
:按优先级、依赖关系、资源占用,决定先派谁、后派谁、要不要合并。 - 兜底
:某个 Worker 长时间没回音,Router 能感知并重派,而不是让任务石沉大海。
关键是 Router 维护一份单一、一致的全局状态。这听起来平淡,却是多 Agent 不乱套的命门——一旦人人都能改全局状态,系统就会陷入「我看的是旧地图」的混乱。把全局状态收口到一个人(Router)手里,复杂度一下子可控了。
Worker 独立上下文
Worker 这一层,最被低估的设计是四个字:独立上下文。
每个 Worker 只拿到 Router 给它的任务说明书(task spec),在自己封闭的上下文里干活,看不到别的 Worker 在聊什么、在想什么。干完,把结果回给 Router,自己的中间过程留在本地。
为什么要这么「隔离」?因为上下文是会「串味」的。如果所有 Agent 共享一条超长对话,A 的困惑会污染 B 的判断,C 的临时结论会被 D 当成既定事实,最后整条链路越跑越歪。隔离之后,每个 Worker 都是「干净启动」,并行才真正安全——你完全可以同时跑十个 review Worker,它们互不干扰。
这也解释了为什么它能「并行」还不崩:上下文独立 = 故障隔离。一个 Worker 跑飞了,影响范围被锁死在它自己那口锅里。
事件驱动被动感知
光有调度还不够。如果 Worker 只会「等人@才动」,那本质上还是人在驱动,注意力瓶颈没破。DeepSeek 这套的巧思在第三点:事件驱动 + 被动感知。
系统订阅了一堆事件流——群聊消息、代码提交、CI 跑挂的告警、Issue 更新。Worker 不是「被点名才干活」,而是像一位坐在团队频道里、没人@也一直在听的老工程师。频道里飘过一句「登录接口又抖了」,他没被@,但耳朵竖着,默默记下一笔。
这就是「被动感知」:Agent 持续监听环境信号,而不是被动等待指令。把「人盯着」这件事,变成了「系统在听」。
两级过滤找缺陷
但群聊是噪声海,不能每条都当圣旨。所以紧跟着是两级过滤,这也是它「无人@也能找缺陷」的关键:
- 第一级( cheap filter)
:用关键词、模式、相关性快速过一遍——这条消息跟我有关吗?像不像在描述一个 bug?无关的直接丢弃,成本极低。 - 第二级( deep check)
:对过了第一级的「可疑信号」,再做一次深一点的判断——这个缺陷我能不能在后台复现?是不是已知模式的变种?值得才真正起一个后台任务去复现。
只有两级都过,系统才会在后台悄悄拉起一个复现任务。整个过程对群里的人是「无感」的:你没@它,它也没跳出来刷存在感,但转头你发现「诶,这个潜藏的缺陷已经被它扒出来了」。
具体「复现」走的是内部沙箱还是影子环境、过滤阈值怎么定,属于实现细节,待核实;但「两级漏斗 + 后台静默消化」这个工程范式,是多 Agent 落地里反复被验证的套路。
这就叫被动感知 + 主动消化:耳朵一直开着(被动),但只把值得的事偷偷办了(主动)。
存算分离长跑不失控
前面讲的都是「聪明」,但一个要长期自治跑着的系统,光聪明不够,还得「稳」。第四点是工程保障:存算分离。
传统做法是 Agent 把「世界状态」揣在自己进程内存里——聊到哪了、任务到哪步了、上下文堆了多长。问题是一旦这个进程崩了,世界就失忆了,重启得从头来。
存算分离的做法是:状态(上下文、任务进度、记忆)放进外部存储,计算(Agent 的推理、执行)变成相对无状态的活儿,现用现取、用完写回。Worker 崩了?没关系,从外部存储把状态读回来,接着干。
类比一下:不是把文档存在浏览器标签页里(关了就没),而是存在云端,标签页崩了重开一个就行。对「长时间自治运行」来说,这是地基级的保障。
Watchdog 外部看门狗
光有存算分离,还不够——万一某个 Worker 陷入死循环、或者开始一本正经胡说八道呢?这时候需要 Watchdog(看门狗)。
Watchdog 是一个独立在系统之外的监控进程:它盯着所有 Worker 的心跳、耗时、输出异常。发现谁卡死、谁狂转、谁跑偏,它有权直接 kill 掉并拉起重启。
重点在「外部」二字。看门狗必须站在被监控对象之外,否则被监控的那个一旦失控,会把看门狗一起带走——这就像你不能让保安和银行金库锁在同一个房间里。Super-agent 研究原型里这种「外部监督进程」的设计,是经典操作系统和分布式系统里「监督进程(supervisor)」思想的回响。
Watchdog 的具体触发规则与重启策略,待核实;但「用一个独立于业务之外的进程兜底业务」是久经考验的工程老智慧。
一段能跑的 asyncio 代码
说了这么多,不如撸段代码把味道找回来。下面这段用 Python 3.10+ 的 asyncio,模拟「Router 派发事件给多个独立上下文 Worker + 一级过滤」的核心思想。你可以直接跑。
import asyncio
import random
# 环境:Python 3.10+
class Worker:
"""一个拥有独立上下文的 Worker。"""
def __init__(self, name):
self.name = name
self.context = {} # 每个 Worker 各自的上下文,互不干扰
asyncdef handle(self, event):
# 在独立上下文中处理事件(这里用 sleep 模拟耗时工作)
await asyncio.sleep(random.uniform(0.1, 0.3))
self.context[event["id"]] = "done"
print(f"[{self.name}] 处理事件 {event['id']} -> {event['type']} "
f"(本 Worker 上下文键数={len(self.context)})")
def _level1_filter(event):
"""一级过滤:只关心 type 在白名单里的事件。"""
return event["type"] in {"bug", "review"}
asyncdef router(events, workers):
"""Router:全局协调,把事件派发到空闲 Worker。"""
worker_cycle = iter(workers)
tasks = []
for ev in events:
# 两级过滤之第一级:无关噪声直接丢弃
ifnot _level1_filter(ev):
print(f"[Router] 事件 {ev['id']} 是噪声,一级过滤丢弃")
continue
# 通过过滤,派发给下一个 Worker(轮转,体现全局调度)
w = next(worker_cycle)
tasks.append(asyncio.create_task(w.handle(ev)))
# 并行等待所有派发任务完成
await asyncio.gather(*tasks)
# 模拟群聊事件流:无人 @ 也能被系统感知
events = [
{"id": 1, "type": "chat"}, # 闲聊噪声 -> 丢弃
{"id": 2, "type": "bug"}, # 潜在缺陷 -> 派发
{"id": 3, "type": "review"}, # 代码评审 -> 派发
{"id": 4, "type": "chat"}, # 闲聊噪声 -> 丢弃
{"id": 5, "type": "bug"}, # 潜在缺陷 -> 派发
]
workers = [Worker("W1"), Worker("W2"), Worker("W3")]
asyncio.run(router(events, workers))
输出解读(顺序因异步调度略有不同,逻辑一致):
[Router] 事件 1 是噪声,一级过滤丢弃
[Router] 事件 4 是噪声,一级过滤丢弃
[W2] 处理事件 2 -> bug (本 Worker 上下文键数=1)
[W3] 处理事件 3 -> review (本 Worker 上下文键数=1)
[W1] 处理事件 5 -> bug (本 Worker 上下文键数=1)
你看,三件事发生了:第一,chat 这类噪声被 Router 在入口就摁掉,Worker 根本不会被吵到;第二,三个 Worker 各自的 context 互不串门,谁也不看谁的「草稿纸」;第三,asyncio.gather 让它们并行跑,router 始终握着全局派发权。把这几行换成真实的 LLM 调用和事件总线,就是一套迷你版多 Agent 编排的骨架。
给个人的三点启发
写到这里,最想说的其实是一句「反直觉」的话:所谓「AI 自己修 Bug」,并没有什么魔法,它只是把老工程师都懂的系统设计,用到了 Agent 编排上。
具体三层启发,条条都来自经典计算机系统工程:
1. 分工(Division of Labor):别让一个 Agent 又当调度又当执行。Router 管「派」,Worker 管「干」,职责切干净,复杂度才降得下来。 2. 异步(Asynchrony):别串行等。能并行的并行,能后台消化的后台消化,事件来了就处理,不阻塞主链路。 3. 事件(Event-Driven):用事件流解耦「生产者」和「消费者」。谁产生信号、谁消费信号,中间用总线隔开,系统才弹性、才好扩展。
你会发现,这三样东西在微服务、消息队列、操作系统里早就被讲烂了。所以下次你要给自己搭 Agent 工作流,别急着追新概念——先把「要不要加个 Router」「Worker 上下文隔不隔离」「事件怎么过滤」这几道老题目做对,就已经胜过绝大多数花活。
一句话:Agent 编排的尽头,是扎实的 system design。
写在最后:行动起来
文章看到这儿,最划算的下一步不是收藏,而是动手。这个周末,花一小时用 asyncio 写个最简单的 Router + 两个 Worker,让它们通过事件队列通信。你会发现,比读十篇架构文章都顶用——因为你亲手摸到了「调度与执行解耦」的手感。
如果你在落地多 Agent 时踩到了别的坑,欢迎在评论区聊聊,咱们一起把这套「老智慧」用得更顺。


