> 原文为中文。本文是机器翻译。

> 本文讨论的是架构层面的想法，并非对 DeepSeek Harness 现有功能的介绍。

## 1. Super-agent

过去一年，编码 agent 和其他单任务 agent 已经表明，模型可以借助工具解决复杂问题，而人类所需的持续监控和逐步干预越来越少。模型协调多个 agent 的能力也越来越强，这使得跨会话组织和调度工作变得切实可行。随着人们在底层执行中的参与减少，他们的角色正逐渐上移到更高层级的决策与拍板确认。

更强的模型也催生了新的应用。最近，许多个人 agent 出现了。它们直接连接到日常的消息、日历、邮件和工作平台，监控信息流，并协助处理任务。个人 agent 只是这种始终在线、事件驱动的工作方式的一种应用。这种工作方式并不局限于个人用途，在软件开发等商业工作中同样有价值。

然而，当今主流的 agent 设计难以在多任务或整个团队的范围内支撑这种工作方式。Agent 仍以单个会话为基本工作单元，而会话之间彼此隔离。并行运行多个任务的用户必须手动在会话之间切换，并记住每个会话里有什么。根据我们的经验，一个人通常同时最多只能跟上 3 到 5 个活跃会话。在这类设计下，单个任务受限于模型能力，但多任务处理受限于人的注意力。

给现有的本地单会话 agent 加上 CLI、MCP 或外部连接器，能让它接收外部消息，但它的基本局限依然存在。它仍然运行在一个同步会话中，长操作会造成阻塞；不同任务的上下文会混杂在一起；本地设备一旦离线，一切都会停止。维持这样一套系统运转需要大量人工投入。

要突破这些局限，就必须把 agent 与任何单个、由人手动驱动的会话解耦。相反，agent 应当是一个持续存在的实体：它跨会话保持自己的上下文，同时处理多个复杂任务，且任务之间互不干扰。我们把这种 agent 及其系统架构称为 **Super-agent**。

例如，我们内部运行在 DeepSeek Harness 上的 Super-agent 实例，可以在 IM 和 GitHub 之间延续同一个开发任务。它还会监控公开群聊中的反馈，即使没有人 @ 它，也能自行找出根因，并提交 Pull Request 来修复：

![](img/HWB9aQxbsAI02Ht.jpg)

![](img/HWB9kRhagAA9Qv_.jpg)

我们认为，Super-agent 具有四个基本特征：

- **Continuous:** 用户可以直接在他们已经在工作的场所与它交互，例如 IM 聊天和 GitHub 评论，而且它始终给人感觉是一个 agent。用户永远不必操心某个会话 X 的上下文里到底有没有信息 Y。例如，用户在 IM 中要求方案 A，之后在 GitHub Pull Request 评论中改成方案 B，agent 能理解这一变化，并调整自己正在做的事情。
- **Productive:** 它响应迅速，并以高标准并行完成多个复杂任务。它可以在上一个命令或任务尚未完成时，就接受下一条指令。
- **Proactive:** 它不等待逐步下达的指令。它监控环境中的事件，对任何值得处理的事情采取行动，其余时候保持安静。
- **Persistent:** 它始终在线，直接连接到用户真实的工作环境，并在长时间运行中从异常中自动恢复。

没有任何单个 ReAct 循环能同时提供这四个特征，因此它们必须来自其周围的系统架构。相似的设计约束往往产生相似的架构。当目标是一个始终在线、并发响应环境事件的系统时，我们预计，个人 agent 和软件开发等商业工作用的 agent 最终会采用相似的设计。构建这样的系统还会带来许多问题，与计算机系统领域长期研究的问题非常相似，因此该领域的许多经典设计思想在这里同样适用。

具体实现会有所不同，但我们认为五个模块构成了支撑这些特征的基本框架。双层架构（第 2 节）同时提供 _持续_ 的交互和 _高产_ 的并发。事件驱动设计（第 3 节）使 agent 变得 _主动_。全双工多通道交互（第 4 节）让与用户的每一次交流既 _持续_ 又 _高产_。将计算、状态和环境分离（第 5 节），再配合 Watchdog（第 6 节），使 agent 能跨设备 _持久_ 在线，并能自行从异常中恢复。

下图给出 Super-agent 架构的总览。标注为 [2] 到 [6] 的模块分别在第 2 到第 6 节中介绍：

![](img/HWB910MbcAAF68B.jpg)

# 2. 双层架构

同时支持跨通道的 _持续_ 交互和跨任务的 _高产_ 并发，会在系统如何组织其会话的问题上，迫使我们在连续性与吞吐量之间做一个根本性的权衡。

把每个事件都路由到同一个会话，能获得最连续的上下文，因为那个会话看得到一切。但 ReAct 循环一次只能运行一步，这限制了单个会话的工作速度：任务耗时很长，吞吐量一直很低。不同任务的中间细节也会交织在同一个上下文中，从而拉低结果质量。

给每个事件都分配一个全新的会话，则把这个权衡反转过来。它能最大化并发吞吐量，但当任务并非完全独立时，缺少共享的全局上下文会使它们的结果彼此脱节。多个会话分别回复用户，也会让交互变得混乱。

为了兼得连续性与吞吐量，我们可以把工作拆分到两个层级。一个长寿命的 **Router 层**（第 2.1 节）通过处理所有人机交互和全局协调来维持全局连续性，而一个上下文隔离的 **Worker 层**（第 2.2 节）以高并发运行任务，如下图所示：

![](img/HWB-BsLasAAi5Qe.jpg)

有了双层架构，系统接管了上下文管理和并发执行，用户因此很少需要去想会话的事，始终是在与同一个 Super-agent 协作。这样看来，让用户手动管理会话，很大程度上是沿袭自底层 LLM API 的一种设计习惯。会话应该是系统的实现细节，而不是用户的心智负担。

在现有设计中，一个会话承担两项工作：它管理模型的上下文，同时也是用户的项目管理单元。一旦产品与底层会话解耦，项目管理就不必再遵循会话的边界。应该向用户提供什么样的交互与任务管理，就成了一个单独的产品问题，我们后面还会回到这一点。

这两个层级是职责上的逻辑划分。任何一层都不必实现为单个会话，每一层都可以有自己的内部结构。接下来两个小节依次介绍这两层。

## 2.1 Router 层

Router 层是一个长寿命的全局路由层，接收来自每个入口点的人机交互。所有跨任务的信息和决策都汇聚于此，因此它充当系统的全局顺序点、协调点和记忆。为了不让这个单一的全局节点成为性能瓶颈，Router 层被设计为不亲自执行任务。它只与人交互并分发任务，甚至可以完全不用 Bash 工具来运行。

以一个中心节点向多个执行节点分发任务，这样的结构看起来像一个典型的 Agent Team，但二者关注点不同。Agent Team 通常把一个复杂任务拆解成步骤，并协调承担这些步骤的角色。由于这些步骤往往紧密耦合，Team Lead 常常必须深入理解任务、规划子任务并频繁协调成员，这累积起来是沉重的推理负担。在 Super-agent 中，Router 层只分发任务，并在高层面上跟踪任务之间的关系。它不拆解单个任务。反过来，Agent Team 也可以作为一种双层架构来运作。为此，其提示词必须使主会话不亲自执行任务，而是把它限定在外部交互，以及把独立的任务分发给成员、由成员独立完成。根据我们的经验，Router 层的工作往往比预想的要简单，一个更轻量的模型通常就能同时提供速度和质量。

在内部，Router 层也不必是单个会话，其部分逻辑甚至可能根本不需要 LLM。我们选择了最直接的设计——单个长寿命的 LLM 会话，并发现它成为吞吐瓶颈的可能性比看起来要低。原因在于，在一次推理轮次进行期间到达的环境事件（第 3 节的触发事件（Trigger））会排起队来，并在下一轮中被一起处理。其结果就是 **batching**，把这些事件一起处理所增加的开销很小：

- 当外部事件以稳定速率到达时，Trigger 一个接一个地到达 Router 会话，每个响应都很快返回。
- 当事件突发涌入并开始在 Router 会话处排队时，在上一轮期间积攒下来的 Trigger 会被自动合并，并一起注入下一次 LLM 调用。由于 Router 会话只做轻量的交互和分发，每一步通常是长输入、短输出。合并进一次 LLM API 调用的 Trigger 在 Prefill 阶段是并行计算的，因此每个请求的时间随批量规模的增长要慢得多。这样一来，在一定程度内，积压越多，每个决策所摊销的推理时间反而越低。其上限取决于上下文长度，以及模型能在一轮中准确处理多少个 Trigger。

第 7.2 节用一个实验量化了 batching 的效果。结合订阅与 pass-through（第 3.2 节）以及 Chain of Recall（第 3.3 节），单个长寿命的 Router 会话能保持上下文连续，对于我们目前规模的团队已经足够。

如果系统增长到单个会话确实跟不上的地步，Router 层可以在内部使用多级过滤结构，或者通过 **horizontal sharding** 拆分成多个会话。届时，其内部设计又归结为同一个连续性与吞吐量之间的权衡。分片越细，Router 层获得的并发吞吐量越高，但各分片共享的记忆和上下文越少。在全局记忆问题得到解决之前，这一权衡将一直存在。

## 2.2 Worker 层

Worker 层由执行任务的会话组成。每个 Worker 都有一个隔离的上下文和一整套执行工具，专门负责单个任务。Worker 会话直接决定每个任务的成果及其代码的质量，因此通常需要能力最强的模型。

Worker 从不直接与人类互动。它们的推理过程和工具调用不会出现在外部渠道中。相反，每个 Worker 向 Router 层汇报自己的状态，由 Router 层负责对用户的全部回复。这样，系统既保持了并发能力，又保证了输出质量，不会出现多个会话各自回复所造成的混乱。

任务并发运行时，每个 Worker 处理自己的任务，同级 Worker 之间通常不需要直接通信。Worker 之间的冲突往往出现在共享的工作环境中，比如同一个 Pull Request。只要相关的 Worker 都订阅了那个环境的 Thread，它们就会收到相同的事件通知（第 3.2 节），有机会自行发现并解决冲突。Router 层转达的是少数需要跨任务协调的情况。

与 Router 层一样，Worker 在内部也不必是单个会话。对于一个复杂任务，Worker 可以创建子智能体，或者本身就是一个 Agent Team，而这对位于它上方的 Router 层是透明的。同样的结构也适用于代码协作：在其中，复现问题、评审 Pull Request、开发功能等相互独立的任务可以同时推进，互不阻塞。它也适用于个人 agent 场景，尽管个人 agent 通常只提供一个聊天页面。当用户在那个聊天页面中同时讨论几个话题时，页面保持对话的连续性；与此同时，后端可以为每个话题分派一个独立的 Worker，并行处理任务并起草回复。

# 3. 事件驱动的 Trigger

要让一个 Super-agent 变得_主动_，我们首先需要改变驱动这个系统的东西。agent 的主要输入不再是人类逐条输入会话的提示词，而是来自环境的半结构化事件。在一个 Super-agent 中，这类环境事件——例如群聊消息、电子邮件、日历提醒、代码评审评论和 CI 结果——被称为**触发事件（Trigger）**。因为 agent 会监听并响应 Trigger，它就不必再像单会话 agent 那样，在每次运行之前都要等一条人类指令。

下面各小节将跟随一个环境事件从到达到处理的全过程，分四步展开，层层递进。第一，结合了代码与模型的**两阶段策略**过滤掉大量噪声（第 3.1 节）。接下来，**订阅与透传（Pass-through）**机制把事件路由给 Worker（第 3.2 节）。然后，**Inline & Spill 与 Chain of Recall** 把密集的上下文注入模型，并按需召回更多上下文（第 3.3 节）。最后，**推测执行**让 agent 能根据环境信号提前在后台行动（第 3.4 节）。

## 3.1 事件过滤

一旦连接到真实的群聊和代码平台，系统看到的是一条噪声很多、触发率很低的事件流：绝大多数日常消息并不需要 agent 采取任何行动。让一个大模型从头判断每一个事件，会增加太多延迟，也会消耗太多算力。借鉴计算机系统中的**快路径（Fast Path）/ 慢路径（Slow Path）**思想，我们把大模型推理当作一条灵活但昂贵的慢路径。而那些频繁出现、定义明确、稳定的判断，则可以变成确定性的代码，充当低延迟、低成本的快路径。

因此，系统会先过滤每一个到来的事件。确定性策略在调用任何大模型之前就去除噪声，只有那些需要语义理解的候选事件才会被送到模型。我们采用将程序化策略与大模型结合起来的**两阶段过滤**：

- **程序化策略（快路径）：** 代码依据确定性条件快速进行准入检查，比如事件来源、所在群组，以及用户或机器人的允许列表。例如，可以把每个来源设置为「仅响应明确的请求」「视为候选事件」或「忽略」。这些检查在调用任何模型之前，就丢弃了大多数无关消息。
- **语义策略（慢路径）：** 通过程序化检查的候选事件会被送到 LLM，由它根据上下文、以及以提示词形式写成的策略，来决定是否采取行动。语义阶段还是一个自然语言扩展点，因此人类可以随时通过提示词启用或停用策略、或者新增策略，如下所示：

![](img/HWB-bbPaYAAwiP3.jpg)

## 3.2 事件路由

第 2 节中的全局 Router 层让跨渠道的交互保持连续。但如果一个已分派任务的每一个后续事件仍然必须经过 Router 层，这个单一的全局节点就会承受沉重的负载，拖慢响应速度。因此，快路径 / 慢路径的划分同样适用于被过滤事件的路由。Router 层只处理新任务的冷启动和跨任务协调，而后续事件则由代码直接发送给负责该任务的 Worker 会话。

在一个真实的工作流中，同一个 GitHub Pull Request、IM 话题或电子邮件链上连续发生的事件构成一条事件流，我们称之为一个 **Thread**：

![](img/HWB-jgWbgAASHEr.jpg)

当 Router 层为一个 Thread 中的第一个事件创建一个 Worker 会话时，该 Worker 会直接订阅这个 Thread。从此以后，事件路由遵循下图所示的两条路径之一：

- **已订阅（快路径）：** 代码把该 Thread 中的后续事件直接透传给已订阅的 Worker，因此 Router 层无需再多进行一次工具调用来转发它们。如果一个新事件超出了当前任务的范围，Worker 可以取消订阅，或者把事件交还给 Router 层重新分派。
- **未订阅（慢路径）：** Router 层仍然可以看到每一个事件，这让它能够跟踪全局状态，但它只评估和分派那些还没有订阅者的新事件。

![](img/HWB-t4aboAAc4z4.jpg)

Thread 与 Worker 之间的订阅关系是多对多的。一个 Worker 可以订阅几个相关的 Thread，一个 Thread 也可以有几个已订阅的 Worker。当多个 Worker 在同一个工作环境或讨论中重合时，共享 Thread 中的每一个新事件都会同时直接透传给它的全部订阅者。然后，这些 Worker 有机会了解其他 Worker 正在做的事情，并自行解决冲突，无需点对点通信。在输出一侧，Worker 仍然把关键结论汇报给 Router 层，由它负责对用户的全部回复，并保持全局记忆同步。

## 3.3 上下文组织

在一个事件经过过滤、被路由到它的目标会话之后，接下来的问题是：要往模型的上下文窗口里放入多少信息。输入不再是数量有限的人类提示词，而是环境持续产生的半结构化事件，因此工具调用和事件注入的设计变得更加重要。注入太多，窗口会被占满，稀释模型的注意力。注入太少，模型就必须一遍又一遍地调用工具来读取上下文，增加执行步骤。浪费上下文窗口，就是浪费模型的智能。

因此，我们可以把有限的上下文窗口看作一个缓存。借用编译器优化和计算机系统中的术语，上下文注入可以归结为两个基本操作。**Inline（内联）**把可能很快就会需要的信息直接放入当前上下文窗口，省去额外的工具调用往返。**Spill（溢出）**则在信息超出预算、或很少被用到时，把完整信息保留在窗口之外，只在窗口中留下一个引用或摘要，模型可以通过它按需读取完整信息。

再结合计算机系统设计中一个经典思想——**局部性（locality）**，**Inline & Spill** 可以逐步改进事件注入和工具调用：

1. **从最少的信息起步：** 起初，只给模型当前对象的 ID 和其内容的摘要。
2. **借助局部性逐步内联（Inline）相关信息：** 内联模型可能很快就会需要的信息。先从关系密切的对象的 ID 开始，然后加入在空间上或时间上相邻的内容。例如：内容的前 50 个字符、某条消息周围的 IM 消息以及它所回复的那条消息、同一场代码评审讨论中相邻的评论。
3. **把超出上限的内容溢出（Spill）：** 为无法完整内联的长内容设定一个较小的长度上限，并把超出的部分 Spill 到窗口之外。一个简单的做法是截断内容，并留下一个指向其后续部分的指针，这样模型在需要时可以调用工具来读取其余部分。

Router 层自身也有一个上下文问题。许多后续事件直接透传给了 Worker，而随着长期运行，以往的任务不断累积，因此 Router 层无法把每个任务的完整历史都保存在自己的上下文窗口中。然而，当用户在另一个渠道中提起一个旧任务时，Router 层仍然必须恢复那个任务的上下文。把 Inline & Spill 一致地应用到系统中每一类对象上，就得到了一种按需的、多跳的检索机制：**Chain of Recall（召回链）**。它减少了 Router 层在长期运行中丢失早期信息的程度，如下图所示：

![](img/HWB-3mwa4AAd7HW.jpg)

系统为 Trigger、Thread、Worker 会话等对象赋予唯一的 ID，并在注入某个对象时，内联与它关系密切的对象的 ID。这些 ID 把各个对象连接成一张引用图。通过工具调用召回的每个对象同样遵循 Inline & Spill，因此返回的结果中内联了下一跳对象的摘要和 ID。这样，模型就可以从当前事件出发，沿着这些引用逐跳召回上下文，需要多远就召回多远。

例如，模型可以从当前消息的 Thread 出发，沿着一个内联的 ID 找到一个相关的 Worker 会话，然后再找到与那个 Worker 相关联的另一个代码评审 Thread。

## 3.4 提前行动

我们还借鉴了计算机系统中的**推测执行（speculative execution）**。基于环境信号，agent 会在尚不知道结果是否会被用到之前，就在后台开始工作。它利用额外的后台算力，让人们等待得更少、需要介入的次数也更少。那些最终被证明有用的结果会被交付，其余的则被丢弃。

在个人 agent 场景中，当一封会议邀请邮件或一条待办消息到来时，agent 可以在后台检查日历冲突、收集背景信息并起草回复。之后，用户只需要过目草稿并将其发送出去即可。同样的方法也适用于研发协作。例如，在我们内部的 DeepSeek Harness 用户群中，我们配置了一条「静默复现并修复」的策略。当有人报告问题或讨论一项提议的改动时，agent 会先尝试在后台复现该问题并找到修复办法。只有在它确认了问题、并找到了一个简单的修复办法之后，它才会交付结果。否则，它全程保持静默。

![](img/HWB_CSNbAAAq4Ur.jpg)

# 4. 全双工多通道交互

第 2 节的两层架构在上下文层面让跨通道的交互保持_持续_。但要让日常交互既_持续_又_有产出_，还有两个问题需要解决：交互如何进行，以及交互在哪里发生。第一个问题是让耗时的后台操作不要阻塞前台对话。**异步 ReAct 循环**解决了这一点：会话可以随时接受新指令，无需等待上一条命令或任务完成（第 4.1 节）。第二个问题是针对每个通信通道以及人们在该通道上的沟通方式，调整 Agent 回复的内容与详细程度（第 4.2 节）。

## 4.1 全双工

在经典的 ReAct 循环中，当模型发起一次同步的 run() 工具调用时，循环会阻塞，直到工具执行完毕并返回最终结果。在此之前，会话无法对用户的任何新输入作出响应。为了消除这种阻塞，对话必须从回合制的半双工模式转为全双工模式，如下图所示：

![](img/HWB_UbGbgAANrKk.jpg)

为此，我们用异步的 _start()_ 和 _stop()_ 调用替代耗时的命令与工具调用，把循环变成**异步 ReAct 循环**。调用 _start()_ 会立即返回 "Started"，循环不会等待工具。当工具在后台执行完毕后，系统会把它的最终结果作为一条新的事件消息投递给会话。模型还可以根据上下文调用 _stop()_，结束一个运行时间过长的后台命令。

前台对话与后台任务解耦之后，Agent 可以在耗时任务于后台运行的同时响应人们的输入。新输入会在当前推理步骤一结束时就得到处理，而不是等到后台工具执行完毕之后。

DeepSeek Harness 已经实现了这一异步任务机制，但尚未默认启用。

## 4.2 多通道

人们在群聊、电子邮件和 GitHub 讨论中的沟通方式各不相同。Agent 需要调整回复的详细程度和回复方式，以适配每个通道。详尽的推理过程和工具调用日志也许适合单人使用的终端，但原样发到群聊里，会让参与者被信息淹没。

在 Super-agent 中，两层架构已经解决了这个问题的一部分。每个任务冗长的推理过程和频繁的工具调用都留在它自己的 Worker 会话内部，永远不会直接发到外部通道，而所有对外交互都由 Router 层处理。除此之外，系统还需要接入用户每天依赖的工作环境，并用提示词为每个通道设定交互规范：

- **IM 等即时消息通道：** 保持沟通轻量，尽量少打扰人。像一位人类同事一样，只在需要决策或确认（sign-off）时才通知对方，只问直接的问题，给出简短的结论。我们验证过一条简单而有效的硬性规则：每条回复最多 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 如何访问其任务所需的执行环境。模型所处理的大量上下文，来自对代码仓库、本地文件、依赖服务和其他执行环境的工具调用。因此，广义地说，上下文包括执行环境本身。

有两种常见做法。第一种是在云端启动一个沙箱，拉取代码，尝试重建并同步环境。但真实的工作环境通常包含未提交的本地变更、私有凭据、对内网服务的依赖，以及特定的硬件或工具链。把这一切同步过去成本高昂，而且容易遗漏。第二种是要求用户放弃本地环境、把工作迁移到云端，而对许多用户来说，这种迁移的成本太高。

既然难以复制和同步的是环境本身，就没有必要把环境随 Agent Loop 一起搬到云端。第二层解耦把 Agent Loop 运行在云端，把状态繁重的执行环境留在原地。每个端点只需要一个轻量级的守护进程，它不保存任何会话状态，只负责执行命令并返回结果。执行环境留在云外，Agent 按需从中读取上下文。

Anthropic 的 ["Decoupling the brain from the hands"](https://www.anthropic.com/research/managed-agents) 采用了同样的做法：harness 保持无状态，会话日志存储在其外部，执行环境通过统一接口按需接入。区别在于目标场景。Anthropic 的文章描述的是一种托管服务，主要讨论按需创建的沙箱和客户 VPC 内的资源。而我们首先需要接入的是人们每天使用的个人机器，这些机器保存着未提交的变更和本地凭据，而且可能只是间歇性在线。因此，我们的设计支持 **BYOM (Bring Your Own Machine)**，即把用户自己的开发机或个人电脑接入云端 Agent。它也支持云端托管的机器和按需创建的计算环境。

由此，Agent 不再被绑定在某一台机器上。它可以在不同的执行设备之间切换，在任务需要的任何环境中运行命令、读取上下文。它甚至可以与只是间歇性在线的设备协作：当用户的个人设备重新上线时，云端 Agent 会自动启动并完成需要在该设备上运行的任务。下图展示了由此形成的结构，其中计算、持久状态和执行环境在两个层面上实现解耦：

![](img/HWCACygasAAvhLx.jpg)

# 6. Watchdog（看门狗）

_持续_在线需要的不仅仅是第 5 节的计算-存储分离：系统还必须在长时间运行期间从异常中自动恢复。一个持续在线的分布式系统，如果只依赖其内部逻辑，可靠性通常维持不了多久。它需要在主系统之外有一个独立的**控制循环**（Control Loop）。

Agent 系统需要的也不只是传统的进程存活探针或监控脚本。许多异常并不是崩溃：进程还在运行，但模型陷入了没有产出的循环，或者已经偏离了它的目标。因此，一个长时间运行的 Agent 系统必须同时监控任务进展和基础设施的存活状态。

我们的外部控制循环是一个独立的 **Watchdog 会话**，它运行在主系统之外，由定时消息驱动。Watchdog 负责处理基础设施故障，如 API 错误和状态恢复失败。它还会用模型来判断每个 Worker 是在取得实质性进展，还是在偏离总体目标。它会及时修复异常，并对暂时性的外部故障持续复查，直到问题得到解决。

由于 Watchdog 本身就是一个拥有完整工具集的 Agent 会话，维护者可以用自然语言向它询问某件事为什么失败。维护者还可以让它在系统运行期间修正主系统的行为，例如增删提示词，或者调整触发规则。

# 7. 初步实验

我们在两个层面上对核心的调度与路由设计做了初步实验：整个系统，以及单独的 Router 层。端到端实验将双层架构与单会话设计进行对比，并测量订阅与 Pass-through 机制的效果（第 7.1 节）。第二个实验测试 Router 层的批处理（第 7.2 节）。实验使用的是合成工作负载和简化环境，设置的部分环节不够严谨，因此以下结果仅供参考。

## 7.1 消融实验

四种端到端设计同时运行，由一串群聊消息和 GitHub CI 消息驱动。每次运行约有 300 条消息，其中约 20 条是工作请求，其余是闲聊、跟进、取消和 CI 消息。编码工作由一个只消耗时间的工具模拟，因此实验测量的是系统的调度与协调能力，而不是它执行单个任务的能力。每种设计运行 5 次。

四种设计是 **Super-agent**、**无 Pass-through 的 Super-agent**，以及使用不同提示词的两个版本的**带 Subagent 工具的单会话**。

**中性提示词**的内容是 _"在适当的时候，把一项工作交给一个 subagent 去做……"_。

**委派优先提示词**的内容是 _"聊天里的每条消息都会到达你这里，所以你自己动手做的工作会不断被新消息打断。优先把每项工作交给一个专属的 subagent，自己只做小事……"_。

![](img/HWCAXLOaoAELExc.jpg)

| **设计** | **任务完成时间 p50 / p95（分钟）** | **每次运行的缓存读取 token（所有会话）** |
| --- | --- | --- |
| **Super-agent** | 12.4/15.7 | 23.2M |
| 无 Pass-through 的 Super-agent | 12.6/15.5 | 31.8M |
| 带 Subagent 工具的单会话，中性提示词 | 20.4/29.5 | 6.1M |
| 带 Subagent 工具的单会话，委派提示词 | 13.8/29.0 | 10.8M |

_注：每种设计运行 5 次。任务完成时间从发出工作请求时起算，到其结果消息发出为止。_

Super-agent 完成任务的时间在 p50 为 12.4 分钟、p95 为 15.7 分钟，明显快于带 Subagent 工具的单会话。单会话设计更慢，是因为在本实验中它高度依赖提示词：主会话经常决定自己动手做这项工作，导致完成时间又长又不稳定。使用中性提示词时，模型在 5 次运行中没有一次调用 subagent，所有工作都在主会话里运行，新消息不断打断它，p95 达到了 29.5 分钟。使用委派优先提示词时，模型在 5 次运行中有 4 次进行了委派，完成时间有所下降，但总体上仍比 Super-agent 长。在剩下的一次运行中，模型判断这项工作"很小"，于是自己做了，由此产生了图中紫色的长尾。单个会话只能依靠提示词工程和模型临场判断来决定是否委派。双层架构则在系统层面缓解了这个问题：Router 自己不执行工作，每个 Worker 只接收来自它所订阅的 Thread 的消息。

由于 Super-agent 维护着多个相互独立的会话，它每次运行使用的缓存读取 token 比单会话设计更多，这是用 token 换取更短、更稳定的完成时间。无 Pass-through 的 Super-agent 完成任务的时间与 Super-agent 大致相同，但它的 Router 在每次运行中要多做约 30% 的决策，缓存读取 token 总量从 23.2M 上升到 31.8M，约多出 37%。因此在这种工作负载下，Pass-through 并不会让任务完成得更快或更好，但它大幅削减了 Router 会话的 token 用量和推理开销。

## 7.2 Router 层批处理

为了弄清单个长生命周期的 Router 会话在采用第 2.1 节所述的批处理后能承受多大的负载，我们单独对 Router 层做了压力测试。Router 调用的是真实模型，Worker 使用的是 mock 模型。我们逐步把需要决策的 Trigger 的到达速率从每分钟约 1 个提高到每分钟约 40 个，在每个速率下测量平均批次大小、每个请求的时间，以及每次决策分摊的推理时间。一次决策可能跨越多次 LLM 请求，因为 Router 在分发之前可能要经过多步推理，或通过工具调用回忆上下文，所以每次决策的时间可能超过每个请求的时间。

![](img/HWCEDgNbIAAzqbX.jpg)

如上图所示，当需要决策的 Trigger 的到达速率从每分钟约 1 个上升到每分钟约 40 个时，平均批次大小从 1.0 增加到 2.8。每个请求的时间仅从 2.5 s 增长到 3.9 s，增速慢于批次大小，因此每次决策分摊的推理时间从 6.4 s 降到 1.6 s。换句话说，当外部事件突发式到达时，Router 层通过自动合并积压的事件来提高其有效吞吐量。批处理也解释了第 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 会话、订阅与透传，以及 Worker 之间不直接通信。一旦任务规模变大、耦合程度超过单个 Router 会话所能处理的范围，每一层合适的结构尚无定论。我们仍然需要测试更多场景，才能弄清 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 实例的设计，并假设其作用域内的全部信息都汇集在一个全局上下文中。随着使用从个人和小团队扩展到更大的组织，如何配置 Super-agent，实际上就成了决定哪些上下文共享、哪些上下文隔离的问题。组织中需要共享上下文的部分共享一个实例，需要隔离的部分则各自拥有自己的实例。

一旦组织内部或组织之间存在相互隔离的实例，跨越它们边界的协作就是 A2A 通信，例如每个成员的个人 agent 与团队共享的 Super-agent 之间。这里的 A2A 指的是广义上的 agent 之间通信，而不是某个具体的协议。我们仍然需要弄清：不共享任何底层上下文、且各自代表不同权限边界的 agent，如何才能安全、可靠地通信与协作。

## 8.4 如何保障安全与隐私

第 3 节的事件驱动设计让更广泛的环境可以驱动 agent，但也让 agent 暴露在更多不可信输入之下。如果安全与隐私处理不好，Super-agent 就只能在一个非常小、受信任的范围内工作。

例如，第 5 节的设计在云端运行 Agent Loop，并在执行设备上安装轻量守护进程。它隐含地假设云端和端点彼此信任。但托管在云端的 Agent Loop 不断接收外部事件，而端点设备保存着私有代码、敏感数据和本地凭据。把两者连接起来会带来显著的安全与隐私风险。如果服务器端入侵或提示注入攻陷了 Agent Loop，与它连接的每一台端点设备都可能被接管。

即使云端从未被攻陷，凭据也可能泄露。只要端点上的凭据能够进入模型的上下文，正常的执行过程就可能将其暴露。因此，agent 需要一种使用凭据而永远不真正看到它们的方法。要让这种架构得到更广泛的应用，它必须解决这些安全与隐私问题，同时保留从多种不同环境召回上下文的能力。

# 9. 结论

这一设计提出的不是新理论，而是把计算机系统中的经典工程思想应用到 agent 系统的构建上。具体实现会随着技术的发展而变化，但我们相信，其背后的系统设计思想在更长时间内仍然有用。我们的内部 Super-agent 实例正是基于这些思想和 DeepSeek Harness 构建的，目前已经在持续运行。它每天都在协助复现和修复问题、响应代码评审，以及开发 DeepSeek Harness 本身。

正如我们在开头提到的，大模型在单个任务上需要的人工干预越来越少，因此进一步提升生产力的瓶颈正在转移到人的注意力上。两层架构、事件驱动设计、异步多通道交互、计算与存储分离，再加上一个外部 Watchdog，共同让系统接管了管理会话和同步上下文的繁琐工作。人们由此可以进一步向上移动，从执行细节转向更高层面的决策与签核。

以这种方式构建的 agent 不再只是一个等待指令的聊天窗口。它成为了一个自主的协作者，持续在线于人们所使用的数字环境中。对个人而言，它可以是跨设备帮忙处理日常事务的个人 agent。对团队而言，它成为研发工作流的一部分，承接任务并将其向前推进。我们相信，随着模型与系统架构共同演进，这种更自主的工作方式有可能成为人机协作的常态。

> 本文中部分设计的实现见 [**dsh-superagent-prototype**](https://github.com/deepseek-ai/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 等人参与了评审与讨论，并给出了反馈。这个系统和这篇文章都得益于团队日常的交流以及团队积累的经验。
