同时开 5 个 Agent 就盯不过来了:DeepSeek Harness 团队的 Super-agent,把 session 从人手里收走
原文链接: https://x.com/DeepSeekHarness/status/2116857257245987236 来源: x.com 发现于: 小互 · AI 解读站 · 2026/11/2 说明: 本文由 AIHot 自动聚合,并由 GLM 翻译为中文(保留全部代码与链接)。正文取自小互 AI 解读
全文 Markdown · 会员
作者:DeepSeek Harness11-02 · 约 20 分钟
DeepSeek Harness 团队公开了一套名为“超级 Agent(Super-agent)”的系统架构设计。这套设计针对当前 Agent 落地中最现实的瓶颈——当任务变得复杂、多任务并发增加时,限制生产力的往往不再是大模型的单次推理能力,而是人类自己的注意力上限。
一个人只能盯五个窗口:为什么今天的 Agent 跑不起多任务
不管是写代码还是日常办公,用过 Agent 的人都会遇到同一个尴尬局面:你在终端或网页里开了一个 Agent 跑长任务,整个窗口就进入了阻塞等待;你想同时推进第二件、第三件事,就只能手动多开几个标签页。
在现有的产品逻辑里,“会话(Session)”既是底层模型管理上下文的单位,又是人类用来管理项目的唯一单位。但人类的注意力极其有限,一个人通常最多只能同时盯住 3 到 5 个活跃会话。一旦并行的任务再多几个,你就必须充当“人肉调度器”,在各个窗口之间来回切换,回忆哪一个窗口聊到了哪一步、有没有遗漏上下文。
试图给现有的单会话 Agent 挂载外部插件或命令行工具,并不能从根本上化解这个问题。长任务一跑,前端依然卡死;如果把多个任务混在同一个窗口里,不同任务的上下文会互相污染,最终导致模型回答变形;要是电脑合盖休眠,挂在本地的所有任务更是直接中断。
要打破这种限制,Agent 必须从单个、由人工一步步推着走的对话框,变成一个常驻后台、全天候在线、能自主并发推进多个复杂任务的实体。DeepSeek Harness 团队将这种系统形态定义为“超级 Agent(Super-agent)”,并提出了它的四大核心特征:
- 全场景连贯(Continuous):无论你在即时通讯群聊(IM)、邮件还是 GitHub 评论区发起讨论,面对的都是同一个 Agent。它能跨平台记住前情,不会出现“在聊天软件里说了方案 A,切到代码平台它又忘干净了”的情况。
- 高并发产出(Productive):多个复杂任务可以在后台并行推进,且互不干扰。上一个任务还在跑,前台就能立刻接收下一条新指令。
- 环境驱动主动干活(Proactive):不再傻等人类按回车发号施令,而是全天候监听工作环境中的事件(如群聊里的 Bug 讨论、代码评审意见、自动化测试报警)。值得处理就主动接手解决,不值得处理就保持安静,绝不刷屏打扰。
- 长期在线与自愈(Persistent):摆脱单台电脑的硬件限制,运行在云端,直连真实工作环境。遇到网络抖动或模型死循环等异常,能够依靠外部机制自动恢复。

同一个任务跨越聊天群与代码评审平台持续推进。
用户先在 IM 群聊里提出字体独立设置的需求,维护者 @Super-agent 介入并创建 Pull Request;随后用户在 IM 追加字体大小设置,维护者和设计师在 GitHub PR 下提出折叠控件与排版改进,Agent 均在同一个 PR 中跟进修改,最后在群聊中同步合并结果。

无需人工 @ 提醒,Agent 自主从群聊对话中识别出具体缺陷。
在用户群里,成员在没有 @ Agent 的情况下抱怨 macOS 窗口未激活时单选变重命名的 Bug;Agent 静默在后台复现问题并定位到底层 Electron 的 `detail=2` 机制,直接附带前后对比截图提交了修复 Pull Request。
没有任何单一的 ReAct 循环(思考-行动-观察循环)能够凭空兼顾这四点。要实现这种协作体验,必须将经典计算机体系结构中的工程思想借用到 Agent 系统中。整个 Super-agent 架构由五个紧密配合的模块组成,分别对应并支撑上述四大特性:两层架构同时提供全场景连贯与高并发产出,事件驱动设计赋予其主动性,全双工多渠道交互保障了每次人机交流的连贯与高效,而计算、状态与环境分离结合外部看门狗(Watchdog),则维持了跨设备的长期在线与异常自愈能力:

支撑四大特性的五大系统架构模块全景。
涵盖事件触发与两级过滤、保持全局连贯的 Router 路由层、负责上下文隔离执行的 Worker 层、全双工多渠道交互通道、计算与状态及环境分离的存储层,以及运行在外部的独立监控看门狗(Watchdog)。
把决策与搬砖拆开:用两层架构化解连贯性与吞吐量的死结
在组织多任务会话时,系统面临一个最根本的技术取舍:上下文连贯性与并发吞吐量不可兼得。
如果把所有事情都塞进同一个会话,这个会话能看到全局所有信息,连贯性最好;但大模型的一问一答是串行的,长任务一跑整个会话就会被卡住,吞吐量极低,而且不同任务的杂乱过程混合在一起,会直接稀释模型的注意力。反过来,如果每来一个新事件就开一个全新的会话,并发吞吐量确实上去了,但各会话之间缺乏共享记忆,得到的结果往往支离破碎;多个会话同时跑出来抢着在群里向用户汇报,更是会让交互彻底陷入混乱。
化解这个死结的办法,是将职责划分为逻辑上的“两层架构”:一个长期存活的 **Router 层(路由层)**负责人类交互与全局统筹,维持连贯性;多个上下文严格隔离的 **Worker 层(工作层)**负责高并发执行独立任务,提供吞吐量。

通过两层解耦实现全局连贯与局部高并发。
中心的长周期 Router 层直接连接即时通讯、GitHub、邮件日历等各类交互渠道,维护共享记忆与全局调度;具体的耗时开发或排查任务被派发给彼此上下文隔离的 Worker 会话(Worker Session 1、2、3)。
这两层的分工边界非常清晰,且有着严格的纪律约束:
路由层(Router Layer):只当接待与调度,绝不亲自下场写代码
Router 层是整个系统的全局序列点、协调中心与全局记忆库。来自聊天软件、邮件或代码仓库的所有人类输入和外部事件,第一时间都汇聚到这里。
为了防止这个单点成为全系统的性能瓶颈,Router 层在设计上被严格限制为“只做沟通与分发,绝不执行具体任务”,系统甚至可以完全不给它配备命令行(Bash)等执行工具。它不需要像传统 Agent Team 的队长那样把一个复杂任务深度拆解成极其琐碎的执行步骤,它只判断高层次的目标该交给谁,并在宏观上记录任务之间的关联。
因为不承担重度推理,Router 层可以使用响应更快、成本更低的轻量模型。更关键的是,它在工程上拥有极强的批处理(Batching)抗压能力:当外部突发事件密集到达时,正在进行推理的 Router 会将排队积攒的事件自动合并,统一注入到下一次大模型 API 调用中。在大模型的输入处理阶段(Prefill),这些合并的文本是在 GPU 上高度并行计算的,单次请求耗时增长极其缓慢,分摊到每个事件上的平均决策时间反而大幅下降。
工作层(Worker Layer):专心埋头搬砖,绝不直接打扰用户
Worker 层的每一个会话就是一个执行单元。每个 Worker 拥有完全独立的上下文窗口和完整的执行工具链,只专注搞定被派发给它的那一个任务。
因为 Worker 的输出直接决定了代码改动和分析的质量,所以这里通常调用能力最强的旗舰大模型。更重要的是,Worker 会话绝不允许直接向人类或公共渠道输出。它们的详细推理思考、中途报错和频繁的工具调用日志,全部被锁在会话内部,最终只向 Router 汇报阶段性状态和最终结果。用户在聊天群或 PR 评论里看到的,永远是 Router 整理后的精炼答复,不会被底层大量的命令行刷屏。
在 Worker 内部,如果遇到极度复杂的专项问题,单个 Worker 也可以自行开辟子 Agent 或本身作为一个 Agent Team,这种内部细节对上层的 Router 是完全透明的。这种结构同样适用于个人 Agent 场景:尽管用户面对的通常只有一个单页聊天窗口,但当同时讨论多个话题时,前台界面维持对话连贯,后台则能为每个话题派发独立的 Worker 并行推进任务和起草回复。
不等人类敲回车:两级过滤与直通路由如何驱动主动干活
把架构拆成两层之后,驱动 Agent 运转的动力源也必须发生根本改变。它不再是人类在输入框里一条一条敲出来的 Prompt,而是来自日常协作软件中的半结构化事件流(Triggers,如群聊发言、邮件、日历日程、代码评审意见、自动化测试结果)。
让 Agent 直连真实工作环境,立刻会引来海量的噪音。为了让 Agent 做到“该出手时才出手”,事件从进入系统到被模型处理,需要经历四道关键机制:
1. 两级过滤(Event Filtering):用代码规则挡掉绝大部分闲聊
日常群聊里绝大多数消息都是日常问候或无关闲聊(比如“中午吃什么”),并不需要 Agent 介入处理。如果把每一条消息都送进大模型做推理判断,不仅会有不可承受的延迟,还会产生巨大的 Token 账单。
借鉴计算机系统设计中的“快慢路径(Fast/Slow Path)”设计,系统将大模型语义理解视作灵活但昂贵的 Slow Path,而将确定性的过滤逻辑固化为极速、零成本的代码规则(Fast Path):
- 代码规则过滤(Fast Path):用普通程序代码做准入检查,比如检查消息来源频道、发件人群组、白名单列表等。比如某个闲聊群直接设为“忽略”,测试报警群设为“只对明确指令响应”。绝大多数无关事件在这一步就被代码直接掐掉,不消耗任何大模型 Token。
- 大模型语义过滤(Slow Path):通过代码规则初筛的候选事件,才会交给轻量大模型。大模型根据写在 Prompt 里的判断准则,决定是保持沉默还是采取行动。这也为人类维护者提供了一个用自然语言随时热更新规则的入口。

代码规则与大模型语义判断结合的两级过滤。
未监控群的闲聊(Trigger 1)被代码规则直接丢弃(0 Token);普通讨论(Trigger 2)通过规则初筛但在语义判断阶段被静默;具体的缺陷报告(Trigger 3)通过两级过滤后正式进入后续路由。
2. 线程直通路由(Thread & Subscription Pass-through):别让 Router 变成传话筒
如果每一个过滤后的事件都要由中央 Router 逐一审查转交,Router 依然会被海量的跟进消息淹没。
在真实的协作流中,针对同一个 PR、同一个讨论话题或同一封邮件的往来互动,自然构成了一条事件链,系统称之为 Thread(线程)。

连续相关的事件自然归入同一个 Thread 序列。
左侧为群聊中针对缺陷由浅入深的讨论串(Thread #08),右侧为 GitHub 上针对 PR #128 的开单、CI 失败与代码评审评论串(Thread #15)。
当一个 Thread 的首条事件到达时,Router 会创建对应的 Worker 并让 Worker 直接订阅该 Thread。从这一刻起,事件路由直接分化为两条通道:
- 已订阅直通(Fast Path):这个 Thread 之后产生的所有跟进事件(例如追问、CI 跑完后的日志、同事的代码评审),代码会通过旁路直接透传给负责该任务的 Worker,完全不需要 Router 再调用一次工具进行二次转交!
- 未订阅新事件(Slow Path):Router 只保留全局视角的感知,把计算力集中在那些尚未分配给任何 Worker 的冷启动新事件上。

后续事件跳过 Router,直接透传已订阅的 Worker。
初始事件(虚线)走 Slow Path 经由 Router 创建 Worker 并建立订阅;后续相同 Thread 内的事件(实线)走 Fast Path 直通 Worker,消除了中心节点的转发瓶颈。
这种订阅是多对多的。如果有两个 Worker 共同处理一个大型 PR,它们可以同时订阅同一个 Thread。这样一来,任何代码变更和讨论都会同时推送给它们,它们无需建立点对点的复杂通信,就能在共享环境里自行察觉对方的动作、协调冲突。
3. 上下文缓存与多跳召回(Inline & Spill + Chain of Recall)
面对源源不断流入的环境事件,大模型的上下文窗口就像计算机的内存缓存,极其宝贵。塞得太多,注意力被稀释;塞得太少,模型又得频繁调用工具去翻历史,增加延迟。
系统在这里引入了两个经典优化策略:**Inline(内联)**与 Spill(外置):
- 内联高频信息:根据时间与空间局部性,把最可能马上用到的信息直接塞进窗口,比如当前事件的 ID、核心摘要、正文前 50 个字,以及聊天记录的前后两条上下文。
- 外置超长内容:对于又长又冷门的内容(如几千行的报错日志),系统做硬性截断,把大头存放在窗口之外,只在上下文里留一个引用指针或 ID。模型需要看细节时,再通过工具按需拉取。
长周期运行时,Router 不可能把几个月前的历史记录全塞在窗口里。为了让用户在重提旧事时 Agent 能立刻想起来,系统利用对象之间的引用关系构建了一张“有向图”——每一个 Trigger、Thread、Worker 会话都有全局唯一 ID,它们彼此内联对方的 ID。
当用户提起一件旧事时,Router 可以顺着这些 ID 一跳一跳地精准捞取所需信息,这被称为召回链(Chain of Recall):

顺着对象 ID 引用图实现按需多跳召回。
从当前的 Trigger #42 出发,根据其内联的 thread_id 调取 Thread #08;再从 Thread #08 关联的 worker_id 检索 Worker #03,进而追溯到相关的代码评审 Thread #15。全流程按需展开,无需在窗口中常驻巨量历史。
4. 推测执行(Acting Ahead):不等确认,后台预先写好方案
日常协作中最省心的下属往往具备这种能力:听到团队在讨论某个问题,在领导还没正式拍板派活之前,他就已经在后台悄悄把复现环境搭好、把补丁代码写出来了。
Super-agent 借用了计算机系统的“推测执行(Speculative Execution)”:利用额外的后台算力,在人类还没明确下达指令前,根据环境信号预先在后台跑起来,以此减少人类等待和介入的频率。被证明有用的结果就交付,其余则直接丢弃。
在个人 Agent 场景中,当收到会议邀请邮件或待办消息时,Agent 可以在后台自动检查日历冲突、整理背景资料并起草回复,用户只需确认即可发送。在研发协同中同样如此:比如群里有人反馈波浪号 ~ 被错误渲染成删除线的问题,团队还在讨论该怎么修,Agent 已经在后台完成了代码修改并提交了 PR。只有当它确认复现了 Bug 并给出了完备补丁时,才会带着成果发言;如果中途发现无法复现,它就会悄悄清理现场并彻底闭嘴,绝不发出毫无意义的刷屏消息。

讨论尚未结束,推测执行已在后台完成代码验证并交付。
群成员还在探讨波浪号渲染错误该改模型还是改规则,Agent 已经将仅保留双波浪号 `~~` 为删除线的补丁 PR 提交完毕,并精准解答了 Pandoc、markdown-it 与 GFM 规范之间的语法差异。
边跑长任务边秒回:全双工通信与分渠道交互规范
解决了背后的调度与路由,前台的交互体验同样需要彻底重构。要让日常协作真正丝滑,必须解决两个最直观的痛点:后台跑长任务时前台不能被卡死,以及在不同聊天软件里不能像个复读机一样胡乱发日志。
全双工通信(Full-Duplex):把同步阻塞变成异步打断
在传统的 ReAct 模式下,大模型调用一个运行工具 run() 时,整个对话就死死挂起了。直到命令行跑完返回输出,模型才能说下一句话。在此期间,用户如果在输入框发新指令,Agent 根本无法理会。
为了实现真正的全双工交互,系统将原本单向阻塞的 run() 工具拆分成异步的 start() 和 stop():

异步化工具调用打破了前台聊天的阻塞死锁。
上方的传统 ReAct 在工具执行期间前台彻底卡死;下方的全双工机制中,调用 `start()` 之后前台立刻收到就绪通知,用户随时可以发送第二条消息,后台工具跑完后以新事件形态推送结果。
大模型发出 start() 命令后,系统立刻返回一个“已启动”的简短状态,当前推理步骤随即结束。前台对话窗口瞬间恢复响应,用户随时可以插话、追加条件或直接下达新任务;如果在审查过程中发现后台任务跑偏了,模型也可以主动调用 stop() 强行掐断耗时任务。后台真正运行完毕后,系统以一条全新的异步事件通知会话收尾,彻底实现了“前台秒回、后台长跑”。
分渠道自适应:群聊要克制,代码平台要详实
不同工作场景对信息密度的要求天差地别:
- IM 即时通讯(飞书、钉钉、微信群):追求极致轻量,非必要不打扰。必须像一个知进退的人类同事,只有在需要人类审批、做关键二选一决策时才发起询问,且结论必须先行。团队在实践中摸索出一条极其有效的硬规则:群聊单次回复字数严格限制在 100 词以内。
- 异步协作平台(GitHub、邮件、技术文档):要求高度结构化、信息密集。提交一个 Pull Request 时,必须按照仓库规范写清背景、改动点分析、测试验证截图与潜在风险。
两层架构在这里发挥了天然优势:繁琐的工具链报错、代码行级排查全被封印在 Worker 会话内部,只有精炼后的结论才会由 Router 分渠道投递出去。
电脑合盖也能跑:计算、状态与本地执行环境的三层解耦
传统的本地 Agent 把三样东西死死捆绑在一台机器上:运行推理循环的计算算力、维持任务记忆的会话状态、以及存有代码和工具链的本地运行环境。
只要笔记本合盖休眠或网络断开,整个 Agent 的生命周期就宣告终结;而且这种单机结构完全无法触达其他服务器或同事电脑上的环境。为了做到长期在线,系统借鉴了经典“存算分离”思想,进行了两级深度解耦:

将云端 Agent 循环与各端轻量执行环境解耦。
云端运行无状态的 Agent Loop 弹性容器,会话与持久化数据托管在数据库中;下层的开发者电脑、云端环境和断续在线设备仅运行极轻量的守护进程(daemon)。
第一级:计算与状态分离
运行 Agent 决策循环的容器被设计为完全无状态的,所有的会话记录、任务进度和全局记忆全部沉淀到底层独立的会话数据库(Session Database)中。
这样一来,云端容器就算发生故障重启、或者为了应对流量扩容进行迁移,任何会话的状态都不会丢失。Agent 不再受制于任何单台虚拟机的存活,获得了真正的云原生高可用性。
第二级:计算与执行环境分离(自带设备 BYOM)
把计算和状态放到云端之后,最棘手的问题来了:Agent 怎么去跑开发者的代码?
业界的常规做法要么是逼用户把整个开发环境全盘迁移到云端容器中,要么是在云端启动一个临时沙箱、再尝试把代码库克隆过去。但这在实际研发中困难重重——开发者的本地电脑上往往有大量未提交的代码改动、复杂的内网调试代理、私有权限证书,以及极其个性化的依赖环境,要在云端沙箱完全镜像一份不仅成本高昂,而且极易遗漏配置。
Super-agent 采取了反向思路:既然重状态的本地开发环境最难搬迁,那就干脆不要搬。
系统让 Agent Loop 留在云端,而把本地执行环境原样留在开发者的电脑上。用户只需要在自己的电脑里运行一个极轻量的守护进程(Daemon)。这个 Daemon 本身没有任何 Agent 智能、也不存储任何会话状态,它唯一的职责就是作为“手脚”,接收来自云端 Agent 的具体终端指令并回传标准输出。
Anthropic 在《将大脑与双手解耦》(Decoupling the brain from the hands)中也采用了无状态 Harness 与外置环境按需连接的类似思路,但其面向托管服务,主要讨论按需创建的云端沙箱和客户 VPC 内部资源;而 Super-agent 优先要连接开发者日常使用、存有未提交代码和本地凭据且可能断续在线的个人电脑,因而重点支持“自带设备(Bring Your Own Machine,BYOM)”,同时也兼顾云端托管机器与按需创建的环境。当开发者合上笔记本下班时,云端 Agent 继续监控群聊和 PR;一旦第二天开发者重新开机联网,Daemon 自动重新报到,云端积攒的本地测试任务立刻开始自动补跑。
进程没挂但模型卡死了:独立看门狗如何监控目标漂移
长期运行的分布式系统要想保持稳定,绝不能仅仅依赖系统内部的代码逻辑,必须在外部设立一套独立的控制循环。
在传统的服务端运维中,监控通常只看“进程心跳”——只要进程没崩溃,系统就认为它是健康的。但对于 Agent 系统而言,这种指标是远远不够的。Agent 最致命的异常往往不是进程死掉,而是“进程还活着,但大模型陷入了原地打转的死循环,或者在多次工具调用后彻底偏离了最初的目标(Goal Drift,目标漂移)”。
针对这种特有顽疾,系统在主业务流程之外独立部署了一个由定时任务驱动的 看门狗(Watchdog)会话:
- 双层体检机制:Watchdog 既做底层的连通性巡检(如 API 报错重试、数据库状态恢复),更会调取大模型来审查每一个 Worker 的实际产出记录,判断该 Worker 是否在真正取得实质性进展,还是在机械地重复犯错。
- 带工具的交互式纠偏:Watchdog 本身就是一个拥有完整工具权限的独立 Agent。运维工程师可以直接在聊天窗口里用大白话询问 Watchdog:“为什么刚才那个构建任务失败了?”;同时,工程师还可以通过它在系统运行中动态更新 Prompt 规则或调整触发阈值,实现免重启的热修复。
初步实验:多任务分流不能靠 Prompt 靠架构
为了验证核心调度与路由机制,团队在整套系统与单 Router 节点两个层面进行了初步实验。需要说明的是,这组实验使用的是合成负载与简化环境,部分设置有待更严谨,因此数据结果仅供参考。
端到端任务消融实验
第一组实验在群聊与 GitHub 混合的模拟消息流下,对比了四种不同的系统设计。每轮测试包含约 300 条消息,其中约 20 个为工作请求,其余均为日常聊天、追加取消与 CI 状态消息。
四种参测方案包括:完整的 Super-agent、关闭了直通旁路的 Super-agent without Pass-through,以及两种依赖单一会话、仅通过 Prompt 尝试调用子 Agent 的传统方案(一组使用中立提示词,另一组使用强委派提示词)。

两层架构展现出极短且高度稳定的任务完成周期。
Super-agent 及其无直通版本(蓝实线与绿虚线)在 30 分钟内平稳完成了绝大多数任务;而传统单会话即使配置了强委派提示词(紫色线),依然存在拖长至近 50 分钟的严重长尾。
| 系统设计方案 | 任务完成耗时 p50 / p95 (分钟) | 每轮总缓存读取 Token 数 (Cache-read) |
|---|---|---|
| 完整 Super-agent | 12.4 / 15.7 | 23.2 M |
| Super-agent(无直通旁路) | 12.6 / 15.5 | 31.8 M |
| 传统单会话(中立提示词) | 20.4 / 29.5 | 6.1 M |
| 传统单会话(强委派提示词) | 13.8 / 29.0 | 10.8 M |
(注:每种方案独立测试 5 轮。耗时统计区间为从收到工作需求到最终交付结果。为纯粹对比系统调度效率,代码执行耗时由统一时长工具模拟。)
从实验数据中可以提炼出两个极其深刻的工程结论:
第一,多任务并发必须靠系统架构强行把关,绝不能寄托于大模型的自我节制。在单会话设计中,即便工程师千叮咛万嘱咐(强委派提示词),大模型在 5 轮测试中依然有 1 轮自作聪明地认为任务很小、选择亲自下场执行。这直接导致前台主会话被新涌入的聊天消息不断打断,p95 耗时长尾被拉长到了 29.0 分钟,甚至出现了逼近 50 分钟的极端拖尾。而在中立提示词下,单会话模型更是 5 轮全部选择自己单挑、一次子任务都没分发出去。只有两层架构从系统层剥离了 Router 的执行能力,才换来了 p50 12.4 分钟、p95 15.7 分钟的极速且稳定的表现。
第二,Super-agent 本质上是用更多的 Token 换取更短、更稳定的完成时间,而直通机制大幅削减了调度开销。由于维持多个独立会话,Super-agent 每轮总缓存读取 Token(23.2M)明显高于单会话方案(6.1M 与 10.8M),这是以算力换取执行速度与稳定性的必然代价。而对比表中前两行可以看出,关闭直通旁路后任务耗时变化不大(12.6 分钟对比 12.4 分钟),但由于每个跟进事件都要经由 Router 转手一次,Router 决策次数增加了约 30%,总缓存读取 Token 暴涨了约 37%(从 23.2M 升至 31.8M)。在这组负载下,直通机制虽未让任务跑得更快,却大幅削减了 Router 会话的 Token 消耗与推理开销。
路由层高并发压力测试
第二组实验针对核心的单个 Router 节点进行了极限施压,测试当外部每分钟需要决策的事件数从 1 次逐渐拉高到 40 次时,系统的响应曲线:

突发高并发下,大模型的输入并行度反而摊薄了单次决策时间。
左图显示随着事件到达率从 1 上升到 40 次/分,平均批大小从 1.0 增至 2.8,单次 API 耗时仅微增至 3.9 秒;右图显示单决策摊销耗时从 6.4 秒大幅暴跌至 1.6 秒。
数据展现出了批处理带来的性能优势。需要先理解的是,一次分发决策可能跨越多次大模型 API 请求(Router 在派发前可能需要多步推理,或通过工具调用按需召回上下文),因此单决策耗时会高于单次请求耗时。同时,由于 Router 仅处理轻量交互与分发,每一步通常是“长输入、短输出”,合并到同一请求中的多个事件在 Prefill 阶段高度并行计算,单次请求耗时增长极其缓慢(从 2.5 秒微增至 3.9 秒),远慢于批大小的增长(从 1.0 增至 2.8)。这意味着,分摊到每一个具体决策上的平均推理时间,反而从 6.4 秒显著下降到了 1.6 秒。当然,这种批处理收益存在上限,取决于上下文窗口长度以及模型在单轮中能够准确处理的事件数量。
外部事件越是集中爆发,系统的摊销处理效率反而越高。这组实验显示:在当前团队规模下,单个常驻的 Router 会话完全能够扛住日常并发,过早做复杂的横向水平分片是没有必要的过度设计。
你可以通过下方的交互沙盒,直观体验这两种机制对延迟与成本的协同影响:
Super-agent 调度与吞吐量推演沙盒
调节事件到达频率并切换架构模式,观察 Router 批处理效应与直通机制对延迟和 Token 开销的真实影响(端点和表格数字来自原文第 7 节的初步实验,中间的滑动曲线是示意)。
事件到达率(每分钟需决策事件数) 10 次/分
1 (低频平缓) 20 (日常业务) 40 (突发流量顶峰)
系统架构选择
平均批处理大小 (Batch) 1.2 Prefill 并行启动
单决策摊销耗时 4.5 秒 高频下反而下降
20任务完成耗时 (p50/p95) 12.4 / 15.7 分 两层并发调度
运行消耗 Cache-read Token 23.2 M 直通省去 37% 开销
机制剖析:为什么单节点 Router 不会被压垮?
当外部消息平缓时,事件逐个进入 Router 快速响应。当事件密集突发时,上一轮推理间隙排队的事件会自动合并进下一次大模型调用的输入中。由于大模型的输入计算(Prefill)天然并行,耗时增长极慢,单次决策的平均耗时反而从 6.4 秒摊薄至 1.6 秒。
走向真实世界的四大阻碍:分片、无会话界面与安全边界
这套设计目前仅有部分在原型插件 dsh-superagent-prototype 中实现。需要说明的是,该插件只是验证技术路线的原型,并非 DeepSeek 官方产品,其中的异步任务机制也尚未默认开启。尽管团队内部基于这些理念搭建的 Super-agent 实例每天都在协助修复缺陷与推进开发,但如果要让它走出当前受控环境、迈向更大规模的通用场景,还有四个尚未彻底攻破的技术深水区:
1. 规模化扩展与数月级长期记忆
单 Router 结构配合 Chain of Recall 召回链,目前已足以应对当前规模团队的日常协作。但一旦任务规模与耦合度超过单个 Router 会话的承受极限,Router 层终究需要进行横向分片(Sharding)。然而分片越细,各分片之间的共享记忆与上下文就越割裂。
此外,当前的按需召回图谱主要解决的是“找回几周前的相关任务”。当系统连续运行数月乃至数年时,海量陈旧信息的沉淀将触及长程记忆的理论上限,如何在不遗失关键技术资产的前提下对全局记忆进行有效的蒸馏与归档,目前仍无定论。
2. 扔掉会话框后,人该怎么中途接管?
两层架构将底层的会话细节对用户完全屏蔽了。但这也带来了一个新的产品设计挑战:当底层的会话不再等同于聊天窗口时,人与 Agent 的协作界面该长成什么样?
很多时候,聊天对话框纯粹是过去十年人机交互的路径依赖。对于研发而言,最自然的交互场所本来就是代码平台的 Pull Request、代码高亮行或 Issue。更重要的是,在模型能力尚未达到绝对完美的今天,人类往往需要在 Agent 后台自主推进的过程中适时“插手接管”。如何设计一种产品形态,既不破坏后台自主推测执行的效率,又能让人类随时随地在关键技术细节上轻松无缝介入,是下一步人机协同体验的探索核心。
3. 上下文边界与跨主体协作(A2A)
在一个大型组织中,不可能把所有机密数据与代码统统倒进一个全局的超级 Agent 中。财务、法务、核心算法与普通业务团队之间有着严格的权限隔离。
这就意味着未来必然会并存多个独立的 Super-agent 实例。跨越这些隔离边界的协作属于 Agent 间通信(A2A),例如每位成员的个人 Agent 与团队共享的 Super-agent 之间的协作。这里的 A2A 泛指 Agent 之间的通信协作,并不特指某种具体协议。在这些互不共享底层上下文、各自代表不同权限边界的 Agent 之间,如何实现安全可靠的通信与协作,仍是一个有待解决的开放问题。
4. 最致命的软肋:云端大脑直连本地设备的安全与凭证风险
这套架构最大的工程便利在于支持开发者“自带设备(BYOM)”,由云端大脑远程指挥本地机器上的轻量 Daemon。然而,这一设计在安全专家眼里是高度敏感的。
在全天候开放的工作环境中,Agent 每天接收来自公开群聊、开源社区 PR 和外部邮件的非受信事件流。一旦系统遭遇恶意的 Prompt 注入攻击(比如在 PR 代码或群消息中植入隐藏的越狱指令),被攻击者劫持的云端 Agent 循环就可能反向向开发者的个人电脑下发破坏性指令,造成严重的本地代码篡改或系统提权。
与此同时,本地开发环境常驻有各类私有 Git Token、数据库密码与内网访问证书。如果这些凭证直接被读入模型的上下文窗口,哪怕云端未被攻破,在模型正常的推理输出中也极易发生凭证意外泄露。如何在让模型正常调取工具执行任务的同时,做到对本地敏感凭据“可用而绝对不可见”,是这套架构迈向商业化之前必须筑牢的安全底线。
结语:从人肉调度到自主协作
这套 Super-agent 架构并未提出全新的理论,而是将计算机系统领域的经典工程思想应用到了 Agent 系统构建中。具体的技术实现虽会随模型与工具的演进而改变,但其背后的系统设计思想却具有更长期的价值。
当大模型在单项任务上越来越少依赖人工介入时,生产力提升的瓶颈已经转移到了人类有限的注意力上。通过两层架构、事件驱动、全双工交互、存算分离与外部看门狗的协同,系统接管了繁琐的会话管理与上下文同步,人类得以从底层执行细节中抽身,聚焦于更高层次的决策与把关。在这个形态下,Agent 不再是一个被动等待敲回车的聊天窗口,而是一个真正长期常驻、主动并行的数字化协作者。
来源Exploring Super-agent Design: Towards a More Autonomous Agent System查看主材料
DeepSeek Harness · 系统架构设计
超级 Agent:把决策与搬砖拆开,化解多任务并发死结
限制 Agent 生产力的不再是大模型的单次推理,而是人类只有 5 个窗口的注意力上限。DeepSeek Harness 团队提出两层解耦与直通架构,让 Agent 走出阻塞对话框,成为全天候自主并行的协同系统。 建议阅读时长 4 分钟 · 核心图解:两层架构调度与直通旁路机制
无论是写代码还是日常办公,用过 Agent 的人都遇到过同一个尴尬:在终端或网页里让 Agent 跑一个长任务,整个窗口瞬间陷入阻塞等待;若想同时推进第二、第三件事,就只能手动多开标签页充当“人肉调度器”。
在现有的产品逻辑里,“会话(Session)”既是底层模型管理上下文的单位,又是人类用来管理项目的唯一单位。但人类的注意力极其有限,一个人通常最多只能同时盯住 3 到 5 个活跃会话。一旦并行任务增多,多窗口切换让人疲于奔命;若把多个任务混在同一个窗口,上下文又会互相污染,最终导致模型回答变形、长任务直接卡死。
要打破这种限制,Agent 必须摆脱由人工一步步推着走的单个对话框,演进为一个常驻后台、全天候在线、自主并发推进多个复杂任务的“超级 Agent(Super-agent)”。这要求系统具备四大特质:全场景连贯(跨 IM、邮件与代码平台统领全局)、高并发产出(后台多任务独立并行)、环境驱动主动干活(全天候监听真实协作事件)、以及长期在线与自愈(摆脱单机束缚,支持外部异常恢复)。
核心机制:两层架构化解连贯性与吞吐量的死结
在多任务协同中,系统面临根本性的技术取舍:如果把所有事情塞进同一个会话,能看到全局信息但串行推理极易卡死、注意力被严重稀释;如果每来一个事件就开新会话,并发虽高但记忆支离破碎,多个会话还会抢着向用户汇报。化解这个死结的办法,是将职责划分为逻辑上的“两层架构”:一个长期存活的 Router 层(路由层)负责人类交互与全局统筹,维持连贯性;多个上下文严格隔离的 Worker 层(工作层)负责高并发执行独立任务,提供吞吐量。
Router 路由层:只当接待与调度,绝不写代码 全局记忆 · 批处理抗压
作为所有消息的统一入口,汇聚 IM、GitHub 与邮件输入。系统甚至不给它配备 Bash 执行工具,仅使用响应更快的轻量模型统筹分发。突发流量下自动合并事件,利用 GPU Prefill(模型读入输入的阶段)并行计算,将单决策耗时从 6.4 秒摊薄至 1.6 秒。
↓ 派发独立任务 / 汇报精炼结果(绝不向外刷屏) ↑
Worker 工作层:专心埋头搬砖,绝不打扰用户 上下文隔离 · 旗舰模型
每个 Worker 拥有独立的上下文与完整工具链,专职执行具体缺陷修复或代码分析。其思考过程、调试报错与频繁日志全部被锁在会话内部,仅向 Router 交付阶段结论,彻底杜绝日志刷屏。
Worker A PR #128 补丁编写与测试 Worker B macOS 窗口点击 Bug 排查 Worker C Markdown 规范渲染验证
剥离出两层架构后,驱动系统运转的动力源从被动的 Prompt 变为真实环境中的事件流(Triggers)。为了让 Agent 做到“该出手时才出手、出手时不添乱”,系统引入了两级过滤、直通旁路和全双工交互:
两级过滤
快路径代码规则 + 慢路径语义判断
日常闲聊和未监控频道在代码层以 0 Token 成本直接丢弃;仅有通过初筛的候选事件才交给轻量模型做语义意图判断,大幅阻断无效 Token 消耗。
直通路由
Thread 订阅透传,消除中心转发瓶颈
针对同一 PR 或话题的跟进事件(CI 日志、追加评论),代码通过旁路直接透传给负责该任务的 Worker,完全不需要 Router 二次转交,消除了中心传话筒瓶颈。
全双工交互
异步 start() / stop() 替代阻塞式 run()
大模型调用工具后前台秒回就绪,用户随时可追加需求或掐断跑偏任务;群聊单次答复严控在 100 词内,长篇结构化结果沉淀至 GitHub PR。
团队用约 300 条模拟消息,对比了完整架构和只靠 Prompt 委派的单会话方案。这是合成负载下的初步实验,代码执行耗时为模拟值,数据仅供参考。
12.4m 一半任务在此时间内完成(p50);95% 任务在 15.7m 内(p95),单会话强委派方案为 29.0m
+37% 去掉直通旁路后多烧的 Token(缓存读取从 23.2M 涨到 31.8M),耗时几乎不变(p50 12.6m 对 12.4m)
1.6s 高并发单决策耗时(40 次/分压测下 GPU Prefill 批处理显著摊薄耗时)
实验指向的结论:多任务并发必须靠系统架构强行把关,绝不能寄托于大模型的自我节制。中立提示词下,单会话模型 5 轮全部自己动手;强委派提示词下,5 轮仍有 1 轮亲自下场,p95 拉长到 29.0 分钟,最慢逼近 50 分钟。从架构上剥离 Router 的执行工具后,交付时间才稳定下来。代价是 Token 更多:每轮缓存读取 23.2M,单会话方案只有 6.1M 和 10.8M,这是用算力换速度和稳定。
传统本地 Agent 将算力、记忆和本地代码环境死死绑定在单台笔记本上,合盖或断网即崩溃。Super-agent 设计上做了深度的存算分离与执行解耦:
**计算、状态与环境三层分离(自带设备 BYOM):**云端容器运行无状态的 Agent Loop,所有记忆沉淀到底层会话数据库;而对于重状态、含有未提交代码和私有证书的本地开发环境,系统不强求搬迁上云,而是让开发者在本地运行轻量 Daemon 充当“手脚”。云端大脑远程下发指令,合盖下班断线无妨,开机重连自动补跑。
独立看门狗(Watchdog):监控进程存活之下的“目标漂移”
Agent 最致命的异常往往不是进程死掉,而是“进程还活着,但大模型陷入了原地打转的死循环,或者在多次工具调用后彻底偏离了最初的目标(Goal Drift,目标漂移)”。系统在外部部署定时驱动的 Watchdog 会话,由模型审查 Worker 的实质进展并支持运维免重启交互纠偏。
这套设计目前只有部分落在原型插件里,不是 DeepSeek 官方产品,异步任务机制也未默认开启。
走向现实的深水区挑战
① 规模化分片与长程记忆:多 Router 分片导致的记忆割裂与跨月资产蒸馏;② 无会话界面的中途接管:告别对话框后人类如何在代码行中丝滑介入;③ 跨主体协作(A2A):企业内不同安全域 Agent 的受控通信;④ 最致命软肋:云端大脑直连本地时面临的恶意 Prompt 注入与本地敏感凭据泄露风险。
从“人肉调度器”走向“自主协作实体”,DeepSeek Harness 团队的超级 Agent 架构主张:当单任务推理能力迈过门槛后,下一代 Agent 的质变关键在于借鉴经典分布式系统思想,用清晰的分层、异步直通与存算解耦,把人类有限的注意力彻底释放出来。
原文版权归原作者,这里只供对照阅读。 看原网页 ↗
探索 Super-agent 设计:迈向更自主的 Agent 系统

原文为中文,本版本为机器翻译。
本文讨论的是架构构想,并非对 DeepSeek Harness 现有功能的介绍。
1. Super-agent
过去一年,coding Agent 及其他单任务 Agent 已经证明,模型能够借助工具解决复杂问题,同时对人类持续监督与逐步介入的需求越来越少。模型在协调多个 Agent 方面也日益成熟,使得跨会话地组织与调度工作变得切实可行。随着人们越来越少地参与底层执行,其角色正逐步上移至更高层的决策与审批。
更强的模型也催生了新的应用。近期涌现了许多个人 Agent(personal agents),它们直接接入日常的即时通讯、日历、邮件与工作平台,监听信息流并协助处理任务。个人 Agent 只是这种“始终在线、事件驱动”工作方式的一种应用。这种工作方式并非个人场景专属,在软件开发等商业工作中同样有价值。
然而,当今主流的 Agent 设计难以在多任务或整个团队层面支撑这种工作方式。Agent 仍以单个会话(session)作为基本工作单元,且各会话相互隔离。并行运行多个任务的用户必须手动在会话之间切换,并记住每个会话各自的内容。根据我们的经验,一个人通常只能同时跟进 3 到 5 个活跃会话。在这类设计下,单任务受限于模型能力,而多任务则受限于人的注意力。
在现有的本地单会话 Agent 上加装 CLI、MCP 或外部连接器(connector),可以让它接收外部消息,但其根本局限依然存在:它仍运行在单个同步会话中,会被耗时操作阻塞;不同任务的上下文混在一起;本地设备一离线,一切便陷入停摆。维持这套设置运转需要大量的人工投入。
突破这些限制意味着将 Agent 从任何单一的、由人工驱动的会话中解耦出来。相反,Agent 应该是一个连续的实体,能够跨会话保持其上下文,并同时处理多个复杂任务,而任务之间互不干扰。我们将这类 Agent 及其系统架构称为 Super-agent。
例如,我们内部运行在 DeepSeek Harness 上的 Super-agent 实例,可以在 IM 和 GitHub 之间延续同一个开发任务。它还会监控公开群聊中的反馈,即使没有任何人 @-mention 它,也会自行定位根本原因并创建 Pull Requests 来修复:


我们认为一个 Super-agent 具有四个基本特征:
- Continuous: 用户可以直接在他们已经工作的地方与它交互,例如 IM 聊天和 GitHub 评论,并且它始终让人觉得是同一个 Agent。用户永远不必担心会话 X 的上下文中是否包含信息 Y。例如,如果用户在 IM 中要求 Plan A,之后又在 GitHub Pull Request 评论中改为 Plan B,该 Agent 能理解这一变化并调整自己正在做的事情。
- Productive: 它响应迅速,能够并行完成多个复杂任务,且每个任务都达到很高的标准。在前一个命令或任务尚未完成时,它就可以接收下一条指令。
- Proactive: 它不会等待一步步的指令。它会监控环境中的事件,对任何值得处理的事项采取行动,否则保持安静。
- Persistent: 它始终在线,直接连接到用户真实的工作环境,并能在长时间运行过程中自动从异常中恢复。
单一的 ReAct 循环无法同时提供全部四个特征,因此这些特征必须来自其外围的系统架构。相似的设计约束往往会催生相似的架构。当目标是构建一个能够并发响应环境事件的、始终在线的系统时,我们预期个人 Agent 与面向商业工作(如软件开发)的 Agent 最终会采用相似的设计。构建这样的系统还会引出许多与计算机系统领域长期研究的问题相似的问题,因此该领域的许多经典设计思想同样适用于此。
具体实现会有所不同,但我们认为有五个模块构成了支持这些特征的基本框架。两级架构(第 2 节)同时提供了 continuous 的交互和 productive 的并发。事件驱动设计(第 3 节)使 Agent 具有 proactive 特性。全双工多通道交互(第 4 节)让每次与用户的交互都既 continuous 又 productive。将计算、状态与环境分离(第 5 节),再加上 Watchdog(第 6 节),使 Agent 能够跨设备保持 persistent 在线,并能自行从异常中恢复。
下图概述了 Super-agent 的架构。标记为 [2] 到 [6] 的模块分别在第 2 节至第 6 节中介绍:

2. 两级架构
要同时支持跨通道的 continuous 交互和跨任务的 productive 并发,系统在组织会话的方式上就必须在连续性与吞吐量之间做出根本性的权衡。
将每个事件都路由到同一个会话可以获得最连续的上下文,因为该会话能看到所有信息。但 ReAct 循环一次只能运行一步,这限制了一个单一会话的工作速度:任务耗时长,吞吐量也低。不同任务的中间细节还会最终交错混杂在同一个上下文中,从而降低结果质量。
为每个事件分配各自的新会话则反转了这种权衡。它能最大化并发吞吐量,但当任务之间并非完全独立时,由于缺乏共享的全局上下文,各任务的结果会彼此割裂。多个会话各自分别回复用户,也会使交互变得混乱。
为了同时获得连续性和吞吐量,我们可以把工作拆分到两个层。一个长期存活的 Router 层(2.1 节)通过处理所有人类交互和全局协调来维持全局连续性,而一个上下文隔离的 Worker 层(2.2 节)以高并发方式运行任务,如下图所示:

有了这种两层架构,系统接管了上下文管理和并发执行,用户几乎不需要考虑 session,始终与同一个 Super-agent 协作。因此,让用户手动管理 session,很大程度上是从低层 LLM API 延续下来的设计习惯。Session 应该是系统的实现细节,而不应成为用户的心智负担。
在现有设计中,session 承担两项职责:管理模型的上下文,并作为用户进行项目管理的单元。一旦产品与底层 session 解耦,项目管理就不必再跟随 session 边界。向用户提供何种交互和任务管理,就成了一个独立的产品问题,我们稍后会再讨论。
这两个层是逻辑上的职责划分。任何一层都不必实现为单个 session,各自都可以有自己的内部结构。接下来两个小节将依次描述这两个层。
2.1 Router 层
Router 层是一个长期存活的全局路由层,从每个入口接收人类交互。所有跨任务的信息和决策都汇聚于此,因此它充当系统的全局序列点、协调点和记忆。为了避免这个单一全局节点成为性能瓶颈,Router 层被设计为自身不执行任务。它只与人类交互并分发任务,甚至可以在完全没有 Bash 工具的情况下运行。
由一个中心节点向多个执行节点分发任务,这种结构看起来像一个典型的 Agent Team,但两者的侧重点不同。Agent Team 通常把一个复杂任务拆解成若干步骤,并协调负责这些步骤的角色。由于这些步骤往往紧密耦合,Team Lead 常常必须深入理解任务、规划子任务、频繁协调成员,这累积成沉重的推理负担。在 Super-agent 中,Router 层只分发任务,并在高层层面跟踪任务之间的关联,它不拆解单个任务。反过来,Agent Team 也可以作为两层架构运作。为此,其 prompt 必须约束主 session 不亲自执行任务,只负责对外交互以及向成员分发各自独立的任务,由成员独立完成。根据我们的经验,Router 层的工作往往比预想的简单,一个更轻量的模型通常就能同时提供速度和质量。
在内部,Router 层也不必是单个 session,其部分逻辑甚至可能根本不需要 LLM。我们选择了最直接的设计——单个长期存活的 LLM session——并发现它成为吞吐量瓶颈的可能性比看起来要小。原因在于,在一次推理回合期间到达的环境事件(即第 3 节中的 Triggers)会排队,并在下一个回合中一起处理。其结果就是 batching,而将事件一起处理几乎不增加开销:
- 当外部事件以稳定速率到达时,Trigger 逐个到达 Router Session,每次响应都很快返回。
- 当事件以突发方式到达并开始在 Router Session 排队时,上一回合中积压的 Trigger 会被自动合并,并一起注入下一次 LLM 调用。由于 Router Session 只做轻量级的交互和分发,每一步通常是长输入、短输出。合并到一次 LLM API 调用中的 Trigger 会在 Prefill 阶段并行计算,因此每个请求的耗时增长远慢于批量大小的增长。在一定范围内,积压越多,每个决策摊销的推理时间反而越低。其上限取决于上下文长度,以及模型在一个回合内能准确处理多少个 Trigger。
7.2 节通过一个实验量化了 batching 的效果。结合 subscription and pass-through(3.2 节)与 Chain of Recall(3.3 节),一个长期存活的 Router Session 就能让上下文保持连续,对我们当前规模的团队而言已经足够。
如果系统规模增长到单个 session 确实无法支撑的程度,Router 层可以在内部采用多级过滤结构,或通过 horizontal sharding(水平分片) 拆分为多个 session。届时,其内部设计又会归结为连续性与吞吐量之间的同一权衡。分片越细,Router 层获得的并发吞吐越高,但各分片之间共享的记忆与上下文就越少。在全局记忆问题得到解决之前,这一权衡将持续存在。
2.2 Worker 层
Worker 层由执行任务的各个 session 组成。每个 Worker 拥有隔离的上下文和一整套执行工具,并专注于单一任务。Worker Session 直接决定每个任务的结果及代码质量,因此通常需要使用能力最强的模型。
Worker 从不与人类直接交互。它们的推理过程和 tool calls 都不会出现在外部渠道中。取而代之的是,每个 Worker 向 Router 层报告自身状态,由 Router 层处理对用户的所有回复。这样,系统既保住了并发能力,又保住了输出质量,不会出现多个 session 各自回复的混乱。
当任务并发运行时,每个 Worker 处理各自的任务,其他 Worker 之间通常无需直接通信。Worker 之间的冲突往往出现在共享的工作环境中,比如同一个 Pull Request。只要涉及的 Worker 都订阅了该环境的 Thread,它们就会收到相同的事件通知(3.2 节),从而有机会自行发现并化解冲突。少数需要跨任务协调的情况,则由 Router 层负责转发。
与 Router 层一样,Worker 在内部也不必是单个 session。面对复杂任务,Worker 可以创建 subagent,或者自身就是一个 Agent Team,而这一切对上层的 Router 层是透明的。同样的结构也适用于代码协作:复现 issue、审查 Pull Request、开发功能等相互独立的任务可以同时推进,互不阻塞。它同样适用于个人 Agent 场景,尽管个人 Agent 通常只提供一个聊天页面。当用户在同一个聊天里同时讨论多个话题时,页面保持对话的连续性;与此同时,后端可以为每个话题分别派出一个 Worker,并行地执行任务、起草回复。
3. 事件驱动的 Trigger
要让 Super-agent 变得 proactive(主动),我们首先需要改变系统的驱动方式。Agent 的主要输入不再是人类逐条输入 session 的 prompt,而是来自环境的半结构化事件。在 Super-agent 中,这些环境事件——例如群聊消息、邮件、日历提醒、code review 评论以及 CI 结果——被称为 Trigger。由于 Agent 会监听并响应 Trigger,它不再需要像单 session Agent 那样,每次运行前都要等待人类的指令。
下面的小节按环境事件从到达到被处理的顺序,用层层递进的四个步骤展开。首先,结合代码与模型的 two-stage policies(两级策略) 过滤掉海量噪声(3.1 节)。接着,subscription and pass-through 机制将事件路由给 Worker(3.2 节)。随后,Inline & Spill 与 Chain of Recall 将稠密上下文注入模型,并按需召回更多内容(3.3 节)。最后,speculative execution 让 Agent 基于环境信号在后台提前行动(3.4 节)。
3.1 事件过滤
一旦接入真实的群聊与代码平台,系统面对的就是一条嘈杂且触发率很低的事件流:日常消息中的绝大多数都无需 Agent 采取行动。让大模型对每个事件都从零开始判断,会增加过多延迟,消耗过多算力。借鉴计算机系统中的 Fast Path / Slow Path 思想,我们将大模型推理视为一条灵活但昂贵的 Slow Path;而那些高频、定义清晰、稳定的判断,则可以转化为确定性的代码,充当低延迟、低成本的 Fast Path。
所以系统会先对每一个输入事件进行过滤。在调用任何大模型之前,确定性策略先去除噪声,只有需要语义理解的候选事件才会进入模型。我们采用两阶段过滤,将程序化策略与大模型相结合:
- **程序化策略(Fast Path):**代码对事件来源、群组、用户或 bot 允许列表等确定性条件运行快速准入检查。例如,每个来源可以被设置为"仅响应显式请求"、"作为候选事件处理"或"忽略"。这些检查会在调用任何模型之前丢弃大部分无关消息。
- **语义策略(Slow Path):**通过程序化检查的候选事件会被送入 LLM,由它根据上下文以及以 prompt 形式编写的策略来决定是否采取行动。语义阶段同时也是一个自然语言扩展点,人类可以随时通过 prompt 开启或关闭策略,或添加新策略,如下所示:

3.2 事件路由
第 2 节中的全局 Router 层保证了跨渠道的交互连续性。但如果一个已分配任务的每个后续事件都必须经过 Router 层,这个单一全局节点就会承担过重的负载并拖慢响应。因此,Fast / Slow Path 的划分同样适用于过滤后事件的路由。Router 层只处理新任务的冷启动和跨任务协调,而后续事件则由代码直接发送给拥有它们的 Worker Session。
在真实工作流中,同一个 GitHub Pull Request、IM 话题或邮件链上的连续事件构成一条事件流,我们称之为 Thread:

当 Router 层为一个 Thread 中的第一个事件创建 Worker Session 时,该 Worker 会直接订阅这个 Thread。从那时起,事件路由按照下面两条路径之一进行:
- **已订阅(Fast Path):**代码将 Thread 中的后续事件直接透传给已订阅的 Worker,Router 层无需再通过一次工具调用来转发。如果新事件超出了当前任务的范围,Worker 可以取消订阅,或将事件交还给 Router 层重新分发。
- **未订阅(Slow Path):**Router 层仍然可以看到每一个事件,从而能够追踪全局状态,但它只评估和分发尚无订阅者的新事件。

Thread 与 Worker 之间的订阅关系是多对多的。一个 Worker 可以订阅多个相关的 Thread,一个 Thread 也可以有多个已订阅的 Worker。当多个 Worker 处于同一个工作环境或同一讨论中时,共享 Thread 中的每个新事件会立即直接透传给它的所有订阅者。这样,各个 Worker 就有机会了解其他 Worker 在做什么,并自行解决冲突,而无需点对点通信。在输出侧,Worker 仍然会向 Router 层汇报关键结论,由 Router 层统一处理对用户的回复,并保持全局记忆的同步。
3.3 上下文组织
事件经过过滤并被路由到目标会话之后,下一个问题是应该向模型的上下文窗口中注入多少信息。输入不再是数量有限的人类 prompt,而是环境持续产生的半结构化事件,因此工具调用与事件注入的设计变得更加重要。注入太多,窗口就会被填满,稀释模型的注意力;注入太少,模型又不得不反复调用工具来读取上下文,从而增加执行步骤。浪费上下文窗口,就是浪费模型的智能。
因此,我们可以把有限的上下文窗口当作一个 cache。借用编译器优化和计算机系统领域的术语,上下文注入归结为两个基本操作。Inline 将近期可能需要的信息直接放入当前上下文窗口,省去额外的工具调用往返。Spill 则在信息超出预算或不常被使用时,将完整信息保留在窗口之外,仅在窗口中留下一个引用或摘要,模型可以通过它按需读取完整信息。
结合计算机系统设计中的经典思想 locality,Inline & Spill 可以逐步改进事件注入和工具调用:
- 从最少信息开始: 最开始只给模型当前对象的 ID 及其内容的摘要。
- 借助 locality 逐步 Inline 相关信息: Inline 模型很可能很快需要的内容。先从紧密相关对象的 ID 开始,再添加在空间或时间上相邻的内容。例如内容的前 50 个字符、某条 IM 消息周围的消息及其所回复的那条消息,以及同一代码评审讨论中相邻的评论。
- 将超出上限的内容 Spill 出去: 对无法完整 Inline 的长内容设置一个较小的长度上限,把超出的部分 Spill 到窗口之外。一种简单的做法是截断内容并留下一个指向后续位置的指针,模型需要时可以调用工具读取剩余部分。
Router 层自身也有上下文问题。许多后续事件会直接传给 Workers,而长期运行中过去的任务不断累积,因此 Router 层无法在其上下文窗口中保留每个任务的完整历史。然而,当用户在另一个 channel 中提起某个旧任务时,Router 层仍需要恢复该任务的上下文。将 Inline & Spill 一致地应用于系统中的每一类对象,就得到了一种按需的、多跳的检索机制:Chain of Recall。它减少了 Router 层在长期运行中丢失早期信息的程度,如下所示:

系统为 Triggers、Threads、Worker Sessions 等对象分配唯一的 ID,并在注入某个对象时 Inline 紧密相关对象的 ID。这些 ID 将对象链接成一张引用图。每次通过工具调用召回的对象同样遵循 Inline & Spill,因此返回的结果会 Inline 下一跳对象的摘要和 ID。模型可以从当前事件出发,沿着这些引用逐跳召回上下文,直至满足所需。
例如,模型可以从当前消息所在的 Thread 出发,沿着一个 Inline 的 ID 找到相关的 Worker Session,再找到与该 Worker 关联的另一个代码评审 Thread。
3.4 提前行动
我们同样从计算机系统中借鉴了 speculative execution。基于环境信号,Agent 在尚不确定结果是否会被使用的情况下,就在后台开始工作。它利用额外的后台算力,让人们等待更少、介入更少。事后证明有用的结果会被交付,其余则被丢弃。
在个人 Agent 场景中,当收到会议邀请邮件或待办消息时,Agent 可以在后台检查日历冲突、收集背景信息并起草回复。用户随后只需审阅草稿并发送即可。同样的方法也适用于研发协作。例如,在我们内部的 DeepSeek Harness 用户群中,我们配置了"静默复现并修复"策略。当有人报告问题或讨论拟议的变更时,Agent 会先在后台尝试复现问题并寻找修复方案。只有在确认问题并找到简单修复方案后,它才会交付结果。否则,它全程保持沉默。

4. 全双工多通道交互
第 2 节的两级架构在上下文层面保证了跨 channel 交互的 连续性。但要让日常交互既 连续 又 高效,还需要解决两个问题:交互如何进行,以及交互在哪里发生。第一个问题是避免耗时的后台操作阻塞前台对话。异步 ReAct 循环 解决了这个问题,使 session 可以随时接受新指令,而无需等待先前的命令或任务完成(见 4.1 节)。第二个问题是根据每个通信 channel 以及人们在其上的沟通方式,调整 Agent 回复的内容和详略程度(见 4.2 节)。
4.1 全双工
在经典的 ReAct 循环中,当模型发起同步的 run() 工具调用时,循环会被阻塞,直到工具执行完毕并返回最终结果。在此之前,会话无法响应用户的任何新输入。要消除这种阻塞,对话必须从基于轮次的半双工模式转变为全双工模式,如下图所示:

为此,我们将耗时的命令和工具调用替换为异步的 start() 和 stop() 调用,从而将循环转变为异步 ReAct 循环。调用 start() 会立即返回 "Started",循环不再等待工具;当工具在后台完成时,系统会将其最终结果作为新的事件消息送达会话。基于上下文,模型还可以调用 stop() 来终止运行时间过长的后台命令。
前台对话与后台任务解耦之后,Agent 可以在耗时任务于后台运行的同时响应人类。新输入会在当前推理步骤结束后立即得到处理,而不必等待后台工具执行完毕。
DeepSeek Harness 已经实现了这一异步任务机制,但尚未默认启用。
4.2 多渠道
人们在群聊、电子邮件和 GitHub 讨论中的沟通方式各不相同。Agent 需要调整内容的详细程度和回应方式,以适应不同渠道。详细的推理过程和工具调用日志或许适合单用户终端,但原封不动地发布到群聊中,可能让参与者陷入信息过载。
在 Super-agent 中,两级架构已经部分解决了这一问题。每个任务冗长的推理过程和频繁的工具调用都保留在其 Worker Session 内部,从不直接进入外部渠道,而由 Router 层处理所有外部交互。除此之外,系统还需要接入用户日常依赖的工作环境,并通过 prompt 为每个渠道设定交互规范:
- IM 及其他即时通讯渠道: 保持轻量沟通,尽量减少对他人的打扰。像人类同事一样,只在需要决策或确认时才通知他人,只问直接的问题,并给出简短的结论。我们验证过的一个简单有效的硬性规则是:每次回复不超过 100 词。
- GitHub、电子邮件和文档等异步渠道: 输出结构化、信息密集的内容。例如,在创建或更新 Pull Request 时,按照项目惯例完整写出问题背景、变更说明和验证结果。在个人 Agent 场景中,直接起草结构化的邮件和文档摘要。
5. 分离计算、状态与环境
默认情况下,本地 Agent 会把三样东西绑定在同一台设备上:运行 Agent Loop 的计算、必须持久保存的会话状态,以及代码仓库和本地工具链等执行环境。一旦设备休眠或离线,Agent 就会停止运行,而且它无法访问其他设备上的环境。为了让 Super-agent 持续在线并连接到其任务所需的真实工作环境,我们借鉴计算机系统中的计算存储分离思想,分两步将三者解耦。第一步,我们将计算与会话状态分离,使 Agent 摆脱对任何单台机器生命周期的依赖,从而在云端持续在线(见 5.1 节)。第二步,我们将托管在云端的 Agent Loop 与包含大量状态的执行环境解耦,执行环境可以留在原地,而 Agent 则能跨设备访问它们(见 5.2 节)。
5.1 计算与状态分离
运行 Agent Loop 的计算可以是无状态的,只有会话状态需要持久保存。因此,解耦的第一层是将这些计算运行在无状态的弹性云端容器中,而把会话及其他持久化状态保存在数据库里。容器可以横向扩展、重启或被替换,而持久化存储保障了会话与任务的连续性。本地设备的休眠或离线不再使 Agent 停止运行,它将在云端持续在线。
5.2 将计算与执行环境分离
当 Agent Loop 和会话状态进入云端之后,下一个问题是 agent 如何触达其任务所需的执行环境。模型所处理的上下文很大一部分来自针对代码仓库、本地文件、依赖服务以及其他执行环境的工具调用。因此从广义上讲,上下文也包括执行环境本身。
常见做法有两种。第一种是在云端启动 sandbox,拉取代码,并尝试重建和同步环境。但真实的工作环境往往包含未提交的本地修改、私有凭证、对内网服务的依赖,以及特定的硬件或工具链。要同步这一切代价高昂,而且很容易遗漏。第二种做法则要求用户放弃本地环境,把工作迁移到云端,对许多用户而言,这种迁移的成本过高。
既然难以复制和同步的正是环境本身,就没有必要把它连同 Agent Loop 一起搬到云端。第二层解耦是让 Agent Loop 运行在云端,而把状态繁重的执行环境留在原地。每个 endpoint 只需要一个轻量级 daemon,它不保存任何会话状态,只负责执行命令并返回结果。执行环境保持在云端之外,agent 按需从中读取上下文。
Anthropic 的"将大脑与双手解耦"采用了同样的思路:harness 保持无状态,会话日志存储在其外部,执行环境通过统一接口按需接入。区别在于目标场景。Anthropic 的文章描述的是托管服务,主要讨论按需创建的 sandbox 和客户 VPC 内的资源。而我们首先要连接的是人们日常使用的个人机器——它们保存着未提交的修改和本地凭证,而且可能只是间歇性在线。因此,我们的设计支持 BYOM (Bring Your Own Machine),将用户自己的开发机或个人电脑连接到云端 agent。同时也支持云托管的机器和按需创建的计算环境。
由此,agent 不再被绑定到某一台机器上。它可以在执行设备之间切换,在任务所需的任意环境中执行命令、读取上下文。它甚至可以与仅间歇性在线的设备协作:当用户的个人设备重新连接时,云端 agent 会自动启动并完成需要在该设备上运行的任务。下图展示了由此形成的结构,其中计算、持久状态和执行环境在两个层面被解耦:

6. Watchdog
要做到持久在线,仅有第 5 节所述的计算与存储分离还不够:系统还必须在长时间运行过程中自动从异常中恢复。一个持久在线的分布式系统,如果只依赖其内部逻辑,很少能长期保持可靠。它需要在主系统之外有一个独立的 Control Loop。
Agent 系统需要的也不只是传统的进程存活探针或监控脚本。许多异常并非崩溃:进程仍在运行,但模型陷入了无产出的循环,或者已经偏离了目标。因此,长期运行的 agent 系统不仅要监控基础设施的存活状态,还要监控任务进展。
我们的外部 Control Loop 是一个独立的 Watchdog Session,它运行在主系统之外,由定时消息驱动。Watchdog 处理基础设施层面的故障,例如 API 错误和状态恢复失败。它还会利用模型来判断每个 Worker 是在取得实质性进展,还是已偏离总体目标。它会及时修复异常,并持续复查暂时性的外部故障,直到问题解决。
由于 Watchdog 本身就是一个拥有全套工具的 agent session,维护者可以用自然语言向它询问某处失败的原因。他们还可以让它在系统运行期间纠正主系统的行为,例如添加或移除 prompt、调整触发规则等。
7. 初步实验
我们针对核心调度与路由设计在两个层面进行了初步实验:整个系统,以及 Router 层本身。端到端实验将两级架构与单 Session 设计进行对比,并测量订阅与 pass-through 机制的效果(7.1 节)。第二个实验测试 Router 层中的 batching(7.2 节)。实验使用了合成 workload 和简化环境,部分实验设置本可以更严谨,因此以下结果仅供参考。
7.1 消融实验
四种端到端设计同时运行,由群聊消息和 GitHub CI 消息流驱动。每次运行约有 300 条消息,其中约 20 条是工作请求,其余为闲聊、跟进、取消以及 CI 消息。编码工作由一个单纯消耗时间的工具来模拟,因此该实验衡量的是系统的调度与协调能力,而非其执行单个任务的能力。每种设计各运行 5 次。
这四种设计是 Super-agent、Super-agent without Pass-through,以及使用不同 prompt 的两个 Single Session with Subagent tool 版本。
中性 prompt 的内容是 "在合适时,把一项工作交给 subagent……"。
委派优先 prompt 的内容是 "聊天中的每条消息都会送达你这里,因此你亲自执行的工作会不断因新消息而停下。尽量把每一项工作分别交给各自独立的 subagent,自己只做小事……"。

| **Design** | **Task completion time p50 / p95 (min)** | **Cache-read tokens per run (all sessions)** |
| --- | --- | --- |
| **Super-agent** | 12.4/15.7 | 23.2M |
| Super-agent without Pass-through | 12.6/15.5 | 31.8M |
| Single Session with Subagent tool, neutral prompt | 20.4/29.5 | 6.1M |
| Single Session with Subagent tool, delegation prompt | 13.8/29.0 | 10.8M |
注:每种设计各运行 5 次。任务完成时间从工作请求发出起,到其结果消息为止。
Super-agent 的任务完成时间 p50 为 12.4 分钟、p95 为 15.7 分钟,明显快于 Single Session with Subagent tool。单 Session 设计之所以更慢,是因为在本实验中它严重依赖自身的 prompt:主 Session 经常决定亲自执行工作,导致完成时间长且不稳定。使用中性 prompt 时,模型在全部 5 次运行中都没有调用 subagent:所有工作都在主 Session 中运行,新消息不断打断它,p95 达到 29.5 分钟。使用委派优先 prompt 时,模型在 5 次运行中的 4 次进行了委派,完成时间有所下降,但整体上仍长于 Super-agent。在剩下的一次运行中,模型判断这项工作"很小"并亲自完成,这就产生了图中紫色的长尾。单 Session 只能依靠 prompt engineering 和模型的临场判断来决定是否委派。而两级架构是在系统层面缓解了这一问题:Router 自身不执行工作,每个 Worker 只接收其订阅的 Thread 中的消息。
由于 Super-agent 维护了多个独立 Session,它每次运行消耗的 cache-read token 多于单 Session 设计,以 token 换取更短、更稳定的完成时间。Super-agent without Pass-through 完成任务的时间与 Super-agent 大致相同,但其 Router 每次运行做出的决策多出约 30%,cache-read token 总量从 23.2M 升至 31.8M,增加约 37%。因此在这一 workload 下,pass-through 并不会让任务完成得更快或更好,但它大幅降低了 Router Session 的 token 消耗和推理开销。
7.2 Router 层 Batching
为了弄清一个长期存活的 Router Session 在 2.1 节所述 batching 机制下能承受多大的负载,我们单独对 Router 层进行了压力测试。Router 调用真实模型,而 Worker 使用 mock 模型。我们逐步将需要做出决策的 Trigger 的到达率从每分钟约 1 个提升到约 40 个,并在每个速率下测量平均 batch 大小、每个请求的耗时,以及每个决策分摊的推理时间。一个决策可能跨越多个 LLM 请求,因为 Router 在派发之前可能要经过多步推理,或通过 tool call 回忆上下文,因此每个决策的耗时可能会超过每个请求的耗时。

如上图所示,当需要决策的 Trigger 到达速率从每分钟约 1 个上升到约 40 个时,平均批大小从 1.0 增加到 2.8。单次请求耗时仅从 2.5 s 增长到 3.9 s,增速慢于批大小,因此每次决策的摊销推理时间从 6.4 s 下降到 1.6 s。换言之,当外部事件以突发方式到达时,Router 层通过自动合并堆积的事件提升了有效吞吐量。Batching 也解释了 7.1 节的结果:移除 pass-through 提高了 Router 的峰值负载,但单个 Router 仍未达到其吞吐量上限。因此,以我们当前的团队规模,没有必要过早地对 Router 层进行分片而牺牲全局上下文的连续性。
8. 开放问题
第 2 节至第 6 节描述了构成 Super-agent 基础架构的五个模块。第 7 节的实验表明,在多个任务并发运行时,其核心调度与路由机制能够正常工作。系统能够保持相对简单,很大程度上是因为在这一阶段,我们既简化了工程设计,也简化了所支持的场景。除这些简化之外,仍有四个领域的开放问题:两级架构的扩展(8.1 节)、与无会话的 Agent 协作(8.2 节)、上下文边界与 Agent 间(A2A)通信(8.3 节),以及安全与隐私(8.4 节)。
8.1 如何扩展两级架构
到目前为止,一套简单的组合已能以较低的工程成本覆盖我们大部分日常任务:单一长驻的 Router Session、订阅与 pass-through,以及 Worker 之间不直接通信。一旦任务的规模和耦合程度超出单个 Router Session 所能处理的范围,各层应采用何种结构尚无定论。我们仍需测试更多场景,以确定 Router 层应在何时分片、分片粒度多细,以及同级 Worker 应在何时直接通信、采用何种协作拓扑。系统与模型的协同设计是另一个值得探索的方向。针对 Router 层的工作专门训练模型,例如判断事件、批量分发和召回上下文,可能进一步提升 Router 层的吞吐量和决策质量。
记忆能力也限制了系统的可扩展程度。长驻的 Router 层连同基于引用图的 Chain of Recall,主要负责按需检索近期任务与会话历史。一旦系统运行数月或更久,长期记忆就会成为主要瓶颈。
8.2 如何与无会话的 Agent 协作
由于两级架构对用户隐藏了多会话管理,会话不再是产品设计的核心关注点。但一旦底层的执行会话不再直接映射到界面上的对话,一个新问题便浮现出来:如何向用户呈现任务,以及何种交互与项目管理形式才显得自然。我们认为,聊天窗口之所以成为交互中心,部分源于路径依赖。更多交互可能会迁移到领域专用界面中,例如我们的 Super-agent 实例直接在 GitHub Issues 和 Pull Requests 中工作。会话也可能因用户的使用习惯而保留在界面中,但用户看到的一段对话未必对应一个底层会话。
前文各节主要涉及任务启动和验收时的人机交互。但在这一过渡期,模型快速进步的同时,许多任务仍需要人在中途介入。同样值得探索的是,产品设计如何让用户在不丧失后台自主工作效率的前提下,逐步介入关键细节。例如,用户可以在后台执行过程中的任意时刻介入、接管,或与 Agent 实时协作。
总体而言,用户所需的项目管理与交互高度依赖于其工作领域和个人风格,因此最终设计很可能是高度定制的。DeepSeek Harness 采用开放架构,因此更容易支持这类定制。
8.3 如何定义上下文边界并通过 A2A 协作
到目前为止,我们讨论的都是单个 Super-agent 实例的设计,并假设其范围内的所有信息都汇集在一个全局上下文(global context)中。当使用范围从个人和小团队扩展到更大的组织时,如何部署 Super-agent 实际上就是在决定哪些上下文被共享、哪些被隔离。组织中需要共享上下文的部分共用一个实例,而需要隔离的部分则各自拥有独立的实例。
一旦组织内部或组织之间出现了相互隔离的实例,跨越其边界的协作就是 A2A 通信,例如每个成员的个人 Agent 与团队共享的 Super-agent 之间的通信。这里的 A2A 泛指 Agent 之间的(agent-to-agent)通信,而不是某个特定协议。我们仍需解决的问题依然是:彼此不共享底层上下文、各自代表不同权限边界的 Agent,如何安全、可靠地通信与协作。
8.4 如何保障安全与隐私
第 3 节的事件驱动设计让更多样的环境能够驱动 Agent,但也让 Agent 暴露在更多不可信输入之下。如果安全和隐私问题处理不好,Super-agent 就只能在非常小的可信范围内工作。
例如,第 5 节的设计将 Agent Loop 运行在云端,并在执行设备上安装轻量级的守护进程(daemon)。这一设计隐含地假设云端与端点之间彼此信任。但云端托管的 Agent Loop 持续接收外部事件,而端点设备上保存着私有代码、敏感数据和本地凭证。将二者连接起来会带来显著的安全与隐私风险。一旦服务器端入侵或 prompt injection 攻破了 Agent Loop,连接到它的每一台端点设备都可能被接管。
即使云端从未被攻破,凭证也可能泄露。只要端点上的凭证能够进入模型的上下文,正常的执行过程就可能使其暴露。因此,Agent 需要一种能够在从未"看到"凭证的情况下使用凭证的方法。要让这一架构得到更广泛的使用,就必须在保留其从多种不同环境中召回上下文能力的同时,解决这些安全与隐私问题。
9. 结语
这一设计并没有提出新的理论,而是将计算机系统中的经典工程思想应用到 Agent 系统的构建中。具体实现会随着技术的发展而变化,但我们相信其背后的系统设计思想将在更长的时间内保持价值。基于这些思想并在 DeepSeek Harness 之上构建的内部 Super-agent 实例已经在持续运行。它每天都在协助复现和修复 issue、响应 code review,以及开发 DeepSeek Harness 本身。
正如我们在开头所指出的,大模型在单个任务上需要的人工干预越来越少,因此进一步提升生产力的瓶颈正在转移到人的注意力上。两级架构、事件驱动设计、异步多通道交互、计算与存储分离,以及外部 Watchdog,共同让系统接管了管理会话和同步上下文这类繁琐的工作。人们因此可以进一步向上移动,从执行细节转向更高层级的决策与最终确认。
以这种方式构建的 Agent,不再只是一个等待指令的聊天窗口。它成为一个自主的协作者,持续在线地存在于人们使用的数字环境中。对个人而言,它可以是一个跨设备协助处理日常事务的个人 Agent。对团队而言,它成为研发工作流的一部分,承接任务并推动其前进。我们相信,随着模型与系统架构的共同演进,这种更加自主的工作方式有可能成为人与 Agent 协作的常态。
本文设计的部分内容已在 dsh-superagent-prototype 中实现。该插件只是用于验证技术思路的原型,并非 DeepSeek 的官方产品。
作者与致谢
本文基于 DeepSeek Harness 团队的共同工作成果。Yujia Qiao 负责系统实现并撰写本文。Huanqi Cao、Zui Chen、Xieting Chu、Tianyi Cui、Shiyuan Feng、Yudong Han、Kexin Liu、Shichun Liu、Gesi Luo、Yifan Shi、Tongrui Xiong、Hanxiang Xu、C.C. Yu、Ziya Zhang、F. Zhou 等人参与了评审与讨论并提供了反馈。无论是系统本身还是本文,都离不开团队的日常交流及其积累的经验。
↑ 正文结束 ✓ 本篇全文免费开放
会员可复制、下载全文 Markdown,还能让你的 AI 订阅和提问。 订年卡 $59/年看权益对比 →
📮 新解读每晚进邮箱
读完觉得有用?留个邮箱,每晚一封当天的新解读,随时退订。