智能体提速被反复提起,新一轮发布前夜的这步棋意味着什么
智能体提速被反复提起,新一轮发布前夜的这步棋意味着什么
在新模型发布的窗口期,被讨论最多的往往不是参数规模,而是"快不快"。社区里既有"打通智能体提速之路"的标题,也有"发布当天 API 响应明显变慢"的实测抱怨,还有"涨价已经在 API 价格页面写明"的记录。这些碎片指向同一个问题:当智能体从演示走向承担真实工作,决定体验的已经不是单次推理的秒数,而是一次任务从触发到交付之间,究竟有多少时间花在了等待上。
这正是仓库 dsh-superagent-prototype 值得细看的原因。它不是又一个提示词集合,而是一个可运行的原型:一个面向单一 GitHub 仓库的主动式编码智能体,打包为 DeepSeek Harness 的 bundle,监听 GitHub(可选 Feishu),把请求变成 Ticket,在自己的 Session 和目录里执行,最后回到原对话里交付。README.md 开篇就写明它是研究原型、"not an official DeepSeek product",这句话很重要——它提示我们应当把它当作设计意图的公开切片,而不是产品功能清单。
本文不谈玄学,只做一件事:把"提速"这个叙事,逐条对应到仓库里真实存在的机制、常量与文件。
从提速叙事到可跑原型之间的证据链
判断一个"提速"故事是否可信,第一件事是看它有没有可验证的落地物。这个仓库给出的证据链相当完整,而且层级分明。
首先是规模。src/ 下有 110 个 TypeScript 文件、约 1.5 万行代码,配套 59 个测试文件,pnpm check 一次跑完类型检查、测试与构建(package.json 的 scripts 字段)。这不是一份架构草图,而是一套能启动、能重启、能恢复的系统。
其次是文档的组织方式。docs/ 的编号是强约束:每篇只依赖编号更小的文档,读者不需要提前知道后面才引入的概念(docs/000-philosophy.md 的 "Documents read in order")。更关键的是,tests/docs.spec.ts 会校验这条规则——编号文档只能链接到更早的文档、本地链接必须可解析、架构文档的表格必须列全每个模块和每个测试。文档在这里是可被 CI 拒绝的产物,这比任何"设计理念"的表述都更有说服力。
第三是概念收敛。整个系统只有 Source、Trigger、Thread、Correlation、Channel、Policy、Eval、Mandate、Ticket、Assignment、Subscription 这十来个概念(docs/001-domain.md),并且专门列了一张"被拒绝的概念"表:不做 Principal 实体、不做跨 Source 的身份映射、不让 Eval 调度自己的延迟触发、不做"至多一个活跃 Ticket 每线程"。一张写清楚"我们不做什么"的表,通常比功能列表更能反映工程成熟度。
第四是边界诚实。docs/006-deployment.md 直接写明两个 preset 以 danger-full-access、以操作者的操作系统用户身份运行,账号包装器只决定默认凭据、并不隔离进程,worker 可以按绝对路径执行程序、可以读操作者主目录;docs/003-execution.md 也重复了这一点:"These wrappers and directories establish defaults, not a security boundary."
对上社区情报里那条"DeepSeek-Harness(dsh)把工具、命令、技能、MCP 统一为插件这一种机制"的说法,仓库侧的证据是对得上的:cordis.patch.yml 用 insert 插入三个插件(主插件、GitHub Source、默认 disabled: true 的 Feishu Source),而 Source 通过 SourceKind 协议声明自己的身份、配置 schema、Channel、健康项(src/sources/kind.ts、docs/007-architecture.md)。执行层是可插拔的,模型层是可替换的,这是理解后面所有取舍的前提。
为什么先把执行层拿出来,而不是先发模型
这个问题有一半答案在仓库的目录结构里,另一半在它的常量里。
主 Session 只路由,不干活
docs/004-prompts.md 的第一条原则是"Separate roles":主 Session 只转发原始 Trigger 与路由事实,不做技术判断;一个路由工具一次处理多个候选;路由备注最多 30 词;执行器才去读原始来源、判断范围、实现并验证。
这条原则在代码里是硬约束,不只是提示词。主 Session 的 preset 是 dsh-superagent-router,在 cordis.patch.yml 中它的文件系统工具被显式关闭:
- id: tool-fs
name: '@deepseek-ai/dsh-tool-fs'
config:
write: false
edit: false
没有子代理、没有 web fetch、没有 todo、没有提问工具。它拿到的是一套"路由所需的最小工具集"。而在 src/app/sessions.ts 里还有一道 noWait 守卫,直接拒绝会主动阻塞的调用:
function noWait({ name, arguments: input }, routed: () => boolean): string | undefined {
const args = (input ?? {}) as { command?: unknown; timeoutMs?: unknown; run_in_background?: unknown; wait?: unknown; timeout_ms?: unknown }
if (name === 'bash') {
const sleeps = typeof args.command === 'string' && SLEEP.test(args.command)
if (sleeps || typeof args.timeoutMs === 'number' && args.timeoutMs > 30_000) return NO_WAIT
...
}
if (name === 'job_output' && args.wait === true && (typeof args.timeout_ms === 'number' ? args.timeout_ms > 5_000 : !routed())) return NO_WAIT
sleep、超过 30 秒的 shell 超时、超过 5 秒的任务等待,全部被拒。理由写在注释和文档里:被阻塞的一步会推迟新候选的进入。在一个多任务并行的智能体系统里,调度器的排队延迟往往比模型本身的推理延迟更影响用户体验——因为它是随并发线性放大的。
命令等 5 秒就转后台
执行器 side 的策略方向相反:不阻止长命令,而是让它不再占据前台。dsh-superagent-worker preset 里的 shell 沙箱配置是:
- id: bash-sandbox
name: '@deepseek-ai/dsh-bash-sandbox'
config:
timeoutMs: 5000
maxTimeoutMs: 5000
任务工具的 waitTimeoutMs 同样是 5000。前台命令超过 5 秒自动转为后台作业,作业结束时再唤醒执行器,把结果送进它的下一步。这与"让模型单次输出更快"是完全不同的优化维度:它优化的是"人发来的新消息要等多久才有机会被读到"。
docs/003-execution.md 把这条写成了明确的设计目标:"This lets a worker receive new messages at the next step instead of waiting for a long command to finish."
先发执行层,是有现实理由的
把这两点放在一起,答案就清楚了。
模型的迭代节奏由训练决定,发布前夜的"提速"叙事很难被外部验证;而执行层的提速是可以被工程化、被度量、被回滚的。当一次任务的耗时被拆成"排队时间 + 命令等待 + 后台作业 + 恢复重试"四项时,每一项都有对应的常量与可调参数,改一个数字就能改变结果。厂商在这个时点公开执行层原型,与其说是"抢发",不如说是在提供一个可被独立复核的因果链:不是"我们的模型更快了",而是"我们把等待从关键路径上摘掉了,你可以自己跑一遍看看"。
把每一步都记账:延迟预算的四笔账
如果"提速"只是口号,实现里应该看到大量"优化"注释却没有边界。这个仓库恰恰相反:几乎每一处等待都被写成了一个有上限、有退避、有恢复路径的常量。这是我认为最值得抄的部分。
第一笔:并发槽位,和留给人的那一格
src/executor/dsh.ts 的 WorkerSlots 管两种容量:已经在跑的 worker,和正在启动的预约。关键在 reserve:
reserve(ticketId: string, by: 'launch' | 'wake' | 'person'): void {
if (this.starting.has(ticketId)) return
if (this.used() >= this.max() + (by === 'person' ? 1 : 0)) throw new Later('No worker slot is free')
this.starting.set(ticketId, by)
}
人的消息可以多用一个槽位,而 launches() 在计算可用启动数时会把唤醒预约先扣掉:
launches(): number {
const wakes = [...this.starting].flatMap(([ticketId, by]) => by !== 'launch' ? [ticketId] : [])
return this.max() - new Set([...this.running(), ...wakes]).size
}
这是一个很小的设计,但它解决了一个很常见的退化:当队列被批量新任务占满,人对自己已有工单的追问会排到最后。这里的策略是新任务永远不能阻断人对既有工单的继续。docs/003-execution.md 的并发一节把这条规则写得很直白:"New work therefore cannot prevent a person from continuing an existing Ticket."
槽位上限本身也是受限的:src/limits.ts 里 maxWorkers 的范围是 1..16,src/policy.ts 的默认值是 3。十六个并发 worker 对单机来说是合理天花板——每个 worker 都是一个独立操作系统进程、独立目录、独立 Session。
第二笔:后台作业的 30 分钟,和"交给人"的例外
一轮对话结束时如果还有 shell 作业或子代理在跑,工单不会报告"等待",而是继续持有 worker 槽位。src/executor/dsh.ts 里的上限是:
const BACKGROUND_LIMIT_MS = 30 * 60_000
超时后 shell 作业被杀、工单转为 waiting,报告里会说明最后说了什么、哪些作业被杀。子代理则允许继续。
真正有意思的是交接给人的例外。当执行器把结果或问题交给一个人时,它立刻释放槽位,而它启动的 shell 作业——文档举的例子是"为评审起的一个 server"——可以继续跑到 Assignment 结束,不占槽位、不受 30 分钟限制,其结束也不会唤醒执行器(docs/003-execution.md)。src/executor/dsh.ts 的 handOff 实现了这个分流:
private handOff(ticketId: string, agent: Agent): void {
this.track(ticketId, stopSubagents(this.host.context, agent, true))
const left = this.left.get(ticketId) ?? { jobs: new Set<string>(), collect: new AbortController() }
...
}
这是一个很"产品化"的判断:评审期间需要活着的进程,和需要被清理的进程,不是同一类东西。多数编排框架会把它们一视同仁地杀掉,代价是评审者永远打不开那个预览环境。
第三笔:持久化副作用队列,而不是内存队列
src/app/effects.ts 是一张 SQLite 表加一套分发器。命令在事务内 enqueue,提交后才执行,因此"决定要做"和"真的做了"之间不会出现不一致:
enqueue<K extends EffectKind>(kind: K, key: string, payload: EffectPayloads[K]): void {
this.store.db.prepare(`INSERT INTO effect (kind, key, value, seq, due, since) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(kind, key) DO UPDATE
SET value = excluded.value, generation = generation + 1, attempts = 0, error = '', due = excluded.due`)
.run(kind, key, JSON.stringify(payload), ++this.seq, this.now(), new Date(this.now()).toISOString())
注意 ON CONFLICT(kind, key) DO UPDATE 这一段:同一个 kind/key 的等待行会被合并,队列位置不变,但 payload 更新、立即到期。这正是"同一个工单在短时间内被连发三条消息"时的正确语义——不是排队三次投递,而是合成一次最新投递。
退避是标准的指数增长,并且有上限截断:
const delay = Math.min(handler.retry[1], handler.retry[0] * 2 ** Math.min(row.attempts, 16))
还有一个 Later 异常,专门表示"现在不能跑,但不是失败":
else if (failure.error instanceof Later) {
this.store.db.prepare(`UPDATE effect SET due = ? WHERE ${own}`).run(this.now() + handler.retry[0], ...ownRow)
}
槽位满了、处理被暂停、worker 正在停止——这些都不是错误,不该计入失败次数、不该污染健康度。把"忙"和"坏"分开,是长跑系统里最容易被忽略的一课。
各类副作用的参数也不同:launch 的退避是 [5000, 300_000],delivery 的并发是 4、quiet: true(失败只显示在工单上,不进全局健康项),relay 与 notice 是 ordered——保序,且一条失败会挡住同类后续。
第四笔:重启后的恢复语义
docs/003-execution.md 的 "Restart" 一节,可能是整份文档里最细的部分:运行中的 Assignment 以 "host restarted" 结束,新的 Assignment 带一条恢复说明,要求执行器先检查目录、git 历史与 GitHub,再重复任何外部动作;等待、就绪、受阻、失败的 Assignment 保持原状,除非之后有输入抵达;哪些消息算"已读"取决于它是否被某个 step 取进历史。
代码侧的对应物是 assignmentInterrupted 与 resume(src/executor/dsh.ts、src/core/tickets.ts),以及 killJobs 里那个容易被忽略的细节——先起等待,再发 kill:
// The waits start before the kills, so each end counts as collected.
const collected = live.map(job => jobs!.wait(job.id, KILL_WAIT_MS, sessionId).catch(() => undefined))
for (const job of live) try { jobs!.kill(job.id, sessionId, reason) } catch (error) { failures.push(error) }
await Promise.all(collected)
如果先 kill 再 wait,作业的结束事件可能早于等待建立,从而唤醒执行器、触发一轮本不该出现的对话。这类竞态在"重启/停止"路径上极难通过人工测试发现,只能靠对事件顺序的严格推理。
同样地,瞬时故障被单独识别,而不是一刀切重试:
export function transient(error: unknown): boolean {
const status = (error as { status?: unknown } | undefined)?.status
if (typeof status === 'number') return status === 408 || status === 429 || status >= 500
...
}
TRANSIENT_TRIES = 3、TRANSIENT_BACKOFF_MS = 15_000,指数增长;而 prepare 命令失败不重试——因为"已存在的目录就算已准备",重试会把失败命令留下的残骸当成可用工作区。这个例子说明了一件事:重试策略不是越多越好,重试的前提是操作幂等。
对开发者的实际影响:可用性与代价
把上面的机制拼起来,可以得到一张"延迟记账表"。
| 等待的来源 | 仓库里的对策 | 可调边界 |
|---|---|---|
| 主 Session 被阻塞 | noWait 守卫拒绝 sleep、>30s shell 超时、>5s 作业等待 |
硬编码于 src/app/sessions.ts |
| 前台命令占住对话 | 5 秒转后台,作业结束唤醒 | timeoutMs / waitTimeoutMs 固定 5000 |
| 后台作业无边界 | 30 分钟上限,超时杀 shell 作业、保留子代理 | src/executor/dsh.ts |
| 新任务挤占人的追问 | 额外一个槽位给人类消息,唤醒优先于启动 | maxWorkers 1–16,默认 3 |
| 评估悬挂 | 超时后重新排队,连续两次后记 unavailable |
timeoutSeconds 30–600,默认 120 |
| 瞬时故障 | 三次重试,5s/15s 起指数退避 | 各 effect kind 独立配置 |
| 重启丢状态 | 副作用持久化、消息已读语义、恢复说明 | SQLite 单文件,schema 只增不减 |
这张表里最值得注意的不是任何单行,而是每一行都有一个明确的数字。在智能体系统里,"快"不是一个形容词,而是一组具体的超时、并发与退避参数;能被写下来的参数,才能被调、被回归测试、被在事故复盘里讨论。
代价同样要讲清楚。
第一,它只支持一个仓库。README.md 的第一句就是 "a proactive coding agent for one GitHub repository",docs/006-deployment.md 还注明不支持 GitHub Enterprise Server。这是刻意的收敛:所有 CLI 调用都被限制在配置的仓库范围内(src/infra/commands.ts 的 api 与 pages 做了仓库级校验)。
第二,它不是零配置。SETUP.md 把配置写成了一段需要由编码智能体陪你走完的流程,前置条件包括 Node.js 22.19+ 或 24+、pnpm、git 2.32+、tmux、Python 3.8+、GitHub CLI 2.48+,以及 DSH 版本落在 package.json 的 engines.dsh 范围内。配置项里最容易被低估的是 prepare 命令:它决定每个工单的目录如何创建,典型做法是用 git worktree 建一个检出,超时 10 分钟,失败即失败工单并记录输出。
第三,权限模型是"约定 + 包装器",不是沙箱。docs/003-execution.md 写得毫不含糊:DSH_SUPERAGENT_BLOCKED_COMMANDS 只让按名字调用的命令失败,worker 仍然可以按绝对路径执行程序;docs/006-deployment.md 的建议是要隔离就用独立操作系统账户。这一点和"提速"看似无关,实际上是同一个取舍的两面:为了让执行器能真正干活(起服务、跑构建、改文件),就得给它几乎完整的权限;而给了完整权限,就不能把它当多租户沙箱来卖。
第四,它明确不是产品。README 说"Treat it as research code, not production-ready software. It may still contain bugs, and its coding style and engineering practices may be inconsistent.";docs/007-architecture.md 末尾的 "Open questions" 还留着两个未解问题:哪些 Trigger 字段可信、以及把智能体的 profile 固定在自己的 DSH 安装上以免被外部升级打断。把未解问题写在架构文档末尾,本身就是一种态度。
这个选题真正的落点
回到"发布前夜的这步棋"。
社区里对"提速"的两种典型解释——模型更强、或者价格更低——都只能解释一部分体验。第三种解释在代码里:把一个长任务拆成许多短步骤,让每一步都不会因为等待而失去对输入的响应。5 秒转后台、多留一个槽位给人、30 分钟清理后台、持久化副作用队列、重启后按消息粒度恢复已读状态——这些机制单看都很朴素,但组合起来,系统的"感知延迟"会显著低于它的"实际耗时"。
这也是为什么先拿执行层出来是有意义的:模型的 benchmark 分值是厂商的答卷,执行层的常量表是开发者的答卷。前者你只能相信,后者你可以 git clone 下来,改一个 maxWorkers,跑一遍 pnpm check,然后自己判断。
如果想要真正上手,最省注意力的入口不是读完全部文档,而是照 SETUP.md 让编码智能体陪你走一遍配置,再把 accept mode 停在 observe——这个默认值会让智能体把"本来会做什么"记下来而不真的去做。先看它想做什么,再决定让它做什么;这大概也是这轮"提速"叙事里,最值得被继承的一条工程习惯。