大数跨境

DeepSeek 超级 Agent 架构解读

DeepSeek 超级 Agent 架构解读 Python程序员
2026-11-02
0
导读:DeepSeek 多 Agent 用 Router/Worker 双层、事件驱动与 Watchdog,把经典系统设计智慧用到 Agent 编排上。

图片



从写代码到盯不过来

先讲个真事。我朋友老王,资深后端,前阵子迷上了用 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 时踩到了别的坑,欢迎在评论区聊聊,咱们一起把这套「老智慧」用得更顺。


Python程序员

有料有趣的技术公众号


美编二维码.jpg

扫码关注、一同进步


【声明】内容源于网络
0
0
Python程序员
1234
内容 2525
粉丝 0
Python程序员 1234
总阅读0
粉丝0
内容2.5k