铃阅
❌

普通视图

从代码生成到需求交付:DarkFactory 的工程实践

2026年11月16日 18:00

原创 欢迎关注的 2026-11-16 18:00 上海

以研发任务为中心组织多 Agent 与验证体系,DarkFactory 让"代码生成"走向"需求交付":算子迁移效率提升约 5 倍,Test Runner 缺陷前置拦截率达 79%。

。图片

点击蓝字,关注我们

图片

作者 | DarkFactory

导读 

introduction

"用 AI 写代码"已是日常,但在复杂系统里"完成一个需求"却难得多:代码生成只是其中一步,理解需求、确定影响范围、构建测试、定位修复、验收交付,每一步都可能出问题。本文介绍了百度建设的 DarkFactory 平台——以研发任务为中心,组织多 Agent 分工、执行环境与结果验证:四项能力(任务定义、角色分工、持续执行、结果验证)+ 四阶段验证体系(本地检查、集成验证、流水线回归、生产观察),并用算子迁移(效率提升约 5 倍)、13 Agent 协作长任务(约 14.5 小时)、Test Runner(缺陷前置拦截率 79%)三个场景验证了效果。

全文 4249 字,预计阅读时间 5 分钟

用 AI 写代码,已经成为很多研发人员的日常。补全逻辑、生成函数、解释代码、Web开发、修改局部实现,AI 能承担的工作越来越多。

但是在复杂系统的研发场景里,把任务换成“在现有系统里完成一个需求”,难度就不同了。

一个运行多年的系统,往往包含复杂的模块依赖、历史约定和业务规则。完成一次改动,需要理解需求、确定影响范围、修改代码、构建测试、定位问题,再经过修复和验收。代码生成只是其中一步。

更强的模型能够改善理解、规划和编码表现,但仅靠模型能力,还不足以保证这条研发链路稳定完成。任务如何定义、上下文如何组织、执行中断后如何恢复、结果如何验证,都需要相应的工程机制。

围绕这些问题,我们建设了 DarkFactory:以研发任务为中心,组织多 Agent 分工、执行环境、工具调用和结果验证,让 AI 能承担复杂系统的研发任务。

目前,这套机制已用于存储研发、近线 GPU 管理、算子迁移、Feed架构研发 等场景,月度任务量达到数百项。实践中发现,AI研发的场景下,我们需要关注的点在变化,判断 AI 能承担多少工作,不能再看它生成了多少代码,需要看任务是否完成、结果如何验收,以及过程中需要多少人工介入。

GEEK TALK

01

从写代码到完成需求,还差什么

△ 从代码生成到需求交付的完整链路

遇到的困难,主要集中在三个方面。

第一,理解项目背景以及需求。

复杂系统中的知识,并不都在需求文档里。某个字段可能被多个下游服务依赖,一段看似多余的逻辑可能用于规避历史故障,一项配置也可能影响其他模块的行为。AI 生成的代码即使语法正确、局部逻辑合理,也可能违反这些约束。开始修改之前,需要先理清:相关实现在哪里,依赖关系是什么,哪些行为必须保持,哪些信息仍然缺失。工程机制可以帮助组织这些信息,却不能凭空补齐未记录的知识。无法从代码、文档和工具结果中确认的业务约定,仍然需要人来解释。

第二,如何持续推进一条研发链路。

需求分析、方案设计、代码修改、构建、测试和问题修复,很少能够通过一次问答完成。执行过程中会出现新的信息:某个接口与预期不同,构建环境缺少依赖,测试暴露了此前没有考虑的边界条件。任务需要据此调整,而不是继续沿着最初的计划机械执行。需要系统可以维护任务状态,保存关键产物,处理工具反馈,并在失败后选择重试、修复或请求人工介入。

第三,确认结果满足要求。

代码生成后,还要确认能否构建、是否通过必要检查、是否符合需求,以及有没有破坏其他功能。如果这些步骤仍由人逐项发起、串联和追踪,生成环节节省的时间,就可能被后续验证和返工部分抵消。因此,我们要解决的问题是:如何围绕一个明确的研发目标,把理解、执行和验证组织成能够持续推进的流程。

GEEK TALK

02

支撑任务交付的四项能力

△ DarkFactory 四项能力

DarkFactory 围绕任务定义、角色分工、持续执行和结果验证组织能力。四者共同作用于同一个任务。

1. 任务定义:把目标与约束写清楚

“把这个模块迁移到新框架”可以作为需求的起点,但不足以让AI完成所有实现工作。

任务输入需要明确好:

  • 要改变什么,预期得到什么结果;

  • 涉及哪些代码、文档、配置和研发资源;

  • 哪些接口、行为和兼容性要求不能改变;

  • 使用什么方式验收,哪些节点需要人工确认。

工作空间(Workspace)将这些信息与对应项目、代码仓库和工具资源关联起来,使 Agent 能围绕具体目标开展工作。

任务定义也需要知道信息的不完整。对于尚未确认的依赖和约束,应明确记录,避免把假设当成事实继续传递。任务越复杂,前期澄清越有价值。

2. 角色分工:让不同能力有序协作

需求分析、技术调研、代码实现和测试验证,需要的知识与工具并不相同。

我们将角色职责、技能(Skill)、工具和工作流程组织成可复用的能力单元,组成面向具体场景的“专家团”。不同 Agent 按任务需要分工,前一环节的产物成为后一环节的输入。

多 Agent 的价值不在数量,需要关注分工是否必要、交接是否清楚。需要关注分析环节形成的约束,能否被实现环节遵守;验证环节发现的问题,能否转化为可执行的修复任务。

在具体场景中形成的流程和知识,也可以通过Agent的配置、Skill 和工作流保留下来,方便知识的沉淀和更新。

3. 持续执行:维护状态并处理失败

△ 任务派发流程

长任务除了需要较为完备的上下文,还需要记录执行状态、支持Trace,以及支持故障处理能力。

DarkFactory 为每位用户配置独立的 Agent 运行沙箱、在线 IDE 和数据库资源。任务代码工作区按任务 ID 分目录组织,避免不同任务在文件路径上相互覆盖。为了避免任务相互干扰,也做了端口隔离。

任务状态保存在数据库中,与某个具体沙箱 Pod 的生命周期分离。Pod 重建后,可以重新读取任务记录。但是恢复任务记录不等于恢复任意执行现场;能继续到哪一步,还取决于工作区、上下文和执行产物的保存情况。

任务派发依次完成环境检查、访问凭据获取、专家团导入、下游任务创建和平台状态回写。全部步骤完成后,平台标记派发成功。

运行过程中,我们对进程异常设置有限次数的自动重试,对限流、超时等瞬时错误采用退避重试,并区分自动恢复与需要人工处理的失败。

自动重试主要处理执行故障。代码逻辑错误、需求理解偏差等问题,走验证反馈的流程并进行后续修复。

4. 结果验证:将检查组织成独立任务

在任务结构中,验证机制融合在流程的多个阶段中,同时也建设了专做Verify的Agent(Test Runner)。 任务进入验收阶段后,Test Runner 调用相应的测试 Skill、工具以及验证环境,收集结果并写回父任务。发现问题后,再将问题接入修复与复验流程。这种方式可便于观察哪些检查执行了、发现了什么问题,以及验证本身消耗了多少资源。接下来会详细介绍整个验证体系。

GEEK TALK

03

验证体系:四个阶段与持续反馈

△ 验证体系

为了明确不同检查在研发流程中的职责,我们将验证体系按四个阶段组织,并通过数据与知识反馈持续改进。

本地检查:尽早发现基础问题

在代码修改过程中,就优先运行反馈快、成本低的检查,例如格式与静态检查、类型检查、编译、单元测试和必要的 Mock 测试。

对于影响范围较大或风险较高的改动,还会加上安全分析、契约校验等检查。编译失败、测试失败和高等级安全问题会直接拦住改动。

集成验证:检查真实依赖与交互行为

本地检查通过,不代表代码能够与真实依赖正确协作,第二层加上了集成验证。

集成验证比较大的工作量集中在搭建测试环境,这个过程中复用了现有的EOS和调研环境能力。集成测试中检查中间件、数据库、对象存储和外部接口的交互,覆盖必要的 API、契约、数据迁移及端到端流程。

这些临时环境按需创建、用完回收,计算资源是各自隔离的;但由于成本问题,部分外部数据和服务用的是同一套,这部分并没有跟着一起隔离,需要避免对这部分数据状态的变更。

流水线回归:确认改动没有破坏已有能力

流水线承担更完整、可重复的检查,包括构建、回归测试,以及按任务风险选择的性能、安全和兼容性验证。

检查结果应对应明确的代码版本与制品。修复导致代码或配置变化后,需要重新执行受影响的前置检查,再复验失败环节,避免直接沿用已经失效的验证结果。

尽量用独立于实现的东西来当验证依据:需求约束、既有接口契约、基准结果和人工确认。这样测试就不会跟着实现一起沿用同一个错误假设——否则代码写错了,照着同一套假设写的测试也一样会放过它。

生产观察:验证真实环境下的表现

对于需要发布的任务,验证还会延伸到上线后的运行表现,通过灰度、健康检查、指标和链路数据观察变化。

如果上线出现问题,会根据预先定义的触发条件触发告警、停止放量和回滚等操作。如果涉及到数据结构或不可逆的状态变化,回滚代码不能恢复业务,在上线前制定针对性的止损方案,例如回滚数据版本。

持续反馈:把问题转化为下一次改进

测试结果、缺陷和线上问题,会同时沉淀为回归用例、规则和场景知识,再用于后续任务。

在保存信息的同时还需要注意维护信息的时效性和有效性。需要筛选有效信息、更新策略,并通过实际结果确认是否有效。

Test Runner的建设的目标是将执行检查、问题报告、修复和复验连接起来,行程一套完备的质量验证机制。

GEEK TALK

04

三个场景的初步实践结果

目前DarkFactory已经在不同场景下完成验证,这些实践提供了三类不同的研发类型:效率变化、长流程执行,以及自动验证的使用情况。

场景一:大模型算子迁移

算子迁移具有重复性,但并不是简单的文本替换。我们把这个过程拆解成三段,先理解原版本的实现,然后适配目标环境,最后检查迁移后的行为。将分析、修改和检查组织成连续流程后,项目内部对照报告的迁移效率提升约 5 倍。

场景二:多 Agent 协作长任务

DarkFactory完成过一个由 13 个 Agent 参与、运行约 14.5 小时的近线GPU调度场景的长流程案例。虽然不是时间最长的,但是参与的Agent规模是最大的,同时验证了长程任务能够交付出符合预期的结果。

场景三:测试接入任务执行

在已有统计周期内,Test Runner 缺陷前置拦截率达到79%,无人值守占比达到了80%。

从这些指标可以看到,测试已在实际任务中产生价值,并有效拦截了非预期问题。但这个指标还有提升空间,这些数据也为后续分析测试覆盖和验证策略提供了依据。

GEEK TALK

05

哪些工作可以交给 AI

△ 人机协作

若干场景运行下来,逐渐形成了一些认识:目标和约束清楚、工具能够执行、结果能够验证的工作,适合交给 AI 推进。对于目标定义、关键方案取舍、信息缺失时的判断,以及最终验收,需要人负责。涉及合入、发布和生产变更时,也应保留明确的决策与权限边界。

AI 能够稳定承担的范围,比最初估计的窄一些,但这个范围可感知的在扩大。有时任务能够持续执行,产出的代码却存在性能或功能问题;有时执行工具没有报错,结果也未必满足业务要求。

通过这些经历有一点经验可供大家参考:先明确目标、约束和验收标准,再建立可执行的验证与反馈,机制验证之后再逐步扩大任务的长度和复杂度。

DarkFactory 当前积累了一套围绕任务组织 AI 研发工作的实践,接下来还需要继续解决执行效率、成本、易用性等问题。

跳转微信打开

研发Loop的上下文优化与多Agent协作实践

2026年11月12日 18:00

原创 欢迎关注的 2026-11-12 18:00 上海

当 Loop 每轮都要重装上下文、压缩还会损伤操作规范时,如何让多轮复杂研发又稳又准?

。图片

点击蓝字,关注我们

图片

作者 | 李天鹏-资源运营部

导读 

introduction

在 Workspace 上做研发时,Loop 每轮都要重装上下文,代码读写与工具结果又不断叠加,触发压缩后还会损伤任务依赖的操作规范。本文从上下文优化、Skill 结构优化、Subagent 任务拆分三方面改造流程,使多轮复杂任务执行更快、结果更准确,以研发测试交付全流程无人工介入的案例演示效果。

全文 4750 字,预计阅读时间 5 分钟

GEEK TALK

01

问题:当前研发流程慢在哪里

1.1 人工参与频次高

一次典型的研发流程

1.2 可用上下文窗口大小逐渐减小,注意力随时间衰减

研发 Loop 指「需求 → 方案 → 实现 → 测试 → 评审 → 验证」这条闭环。六个环节本身不慢,慢的是每一步都要把历史上下文重新装载一遍:PRD、代码、测试输出、模型思考、历史轮次全部挤在同一个窗口里,越往后越贵,也越容易漏。

达到模型最大上下文、触发压缩之后:

把这件事量化,会看到三条叠加的约束:

  1. 上下文窗口有限。 模型配额 max_tokens 为 256k,推理与思考内容一并计入。底座与 Skill 正文属于每轮必带的固定成本,工具结果与思考块属于越滚越大的变动成本。

  2. 底座内容每轮重发。 典型排查会话优化前每轮需承载 84k tokens。上下文越长,每轮延迟与 token 成本越高;反过来说,固定成本一旦削减,每一轮调用都持续受益。

  3. 注意力衰减。 上下文越长,位于中部的信息越容易被忽略(lost-in-the-middle);而超限触发的自动压缩是有损的——被丢弃的不只是冗余信息,还有完成任务所依赖的操作规范。这一点在下一节的两起事故里有具体表现。

结论:上下文不是越大越好。「只装载当轮必需的信息」应该是一条硬性工程约束,不是风格偏好。

1.3 压缩的问题,压缩不是免费的

事故一:6.7k 的操作规范被压成 0.2k 摘要。 一份 SKILL.md 因上下文超限被自动压缩,摘要保留了「是什么」,丢掉了「怎么做」——具体命令、路径、边界条件。后续三步全部按压缩后的摘要执行,直到测试环节才发现口径不对。这不是模型的错,是压缩把「任务依赖的操作规范」当成了冗余信息。代价是可量化的:门控顺序连续 4 轮受阻,反复 validate 却只能反复试错,最终为重新摸索流程消耗了 74k tokens。

事故二:8 分钟内 74 次 DOM 快照。 主会话承担前端验证时,为定位一个渲染问题连续抓取页面快照,把主上下文撑爆;随后触发的压缩又丢掉了正在使用的那份失败日志。时间线很清楚:00 开始验证、02 累计超过 20 次、04 触发第一次压缩并丢掉部分页面认知、06 因不确定而重复读取再次压缩、08 共 74 次调用且主任务进度被页面验证操作挤占——从「读得快」直接滑进「读不完」。

两次事故的共同点:问题不在「上下文不够大」,而在「该省的没省、该留的被压掉了」。判断一条信息该不该进入上下文,标准不是「有没有用」,而是「是不是这一轮决策的直接依赖」。

GEEK TALK

02

解决方案

两条路径,各自治一种成本:

  • A 指令拆分,治「每轮必带」的固定成本。控制指令分量:主路径常驻,细则与异常分支外置按需加载。

  • B 多 Agent 拆分,治「每轮新产生」的增量成本。控制输出回流:拆的不是 Agent,而是「文件读取发生在谁的上下文里」。

两条路径必须一起上,只做一半都不成立:

  • 只做 A:工具结果照样把主上下文撑到 30k 以上。

  • 只做 B:每个子 Agent 开局仍带着 19~23k 的固定注入(底座 + Skill 正文),拆得越多,固定成本付得越多。

  • A 是每轮必带的固定成本,一次削减长期受益;B 是每轮新产生的增量成本,作用于每一轮调用。前者一次性投入,后者逐轮兑现。

合起来,典型会话每轮 84k → 28k(−67%)。下面第三节分别展开这两条路径。

GEEK TALK

03

具体做法

3.1 指令拆分的五项措施与实测收益

按成本性质把措施分成两组:前三条削「每轮必带」的固定成本,后两条削「每轮新产生」的增量成本。

两点说明:①②③ 属于指令治理,重构一次就长期生效;④⑤ 属于运行时治理,作用在每一轮调用上,需要插件机制配合。直接砍 SKILL.md 会伤功能。做法是把指令分成两层:主路径正文常驻,细则与异常处理外置成可按需读取的片段;触发条件写进入文件,正文里只留「什么时候该去读哪一段」。

关键前提是常驻部分必须能独立完成常见请求。否则模型每次都要去读片段,往返次数增加,总成本反而上升。

3.2 多Agent拆分,过程隔离,只把结论带回来

指令侧优化后,剩下的大头是工具结果。一次排查要读二十来个文件、跑几轮命令,全部原文进入上下文,很快又回到 30k 以上。

做法是把「读文件」这件事从主会话移到子任务:子任务在自己的上下文里读完、判完,只回一段自包含结论。主会话不读 DOM 快照、不读全量 diff、不读被读过的源码。

同样的任务,主会话自己读二十多个文件时,约 40k+ tokens 全部进入上下文;压缩一旦发生,丢的很可能是刚读进来的那个文件,于是回头再读,形成读取循环。拆出去之后,主会话只收到约 1k tokens 的自包含结论,过程细节零回流。

这里要区分清楚:拆的不是「Agent」,而是「文件读取发生在谁的上下文里」。子任务读的是同一份文件,读进来的内容也只占它自己的上下文。

3.2.1 什么时候拆,什么时候不拆

拆不是越多越好。判断标准是反馈循环的紧密度:反馈循环紧的环节(改一行看一眼、反复微调)合在一起做,反馈循环松的环节(读一批文件、出一份结论)拆出去做。

3.2.2 研发Loop场景下要怎么拆

按上面的标准,一条研发 Loop 拆成一个协调 Agent 加十个专职 Agent:

权限不靠提示词约束。「不要改生产代码」这类约束写在提示词里,模型在高负荷下会漂移;可靠的做法是在工具层直接不给写权限,主会话本身也不开浏览器工具。黑盒测试员额外禁止读取实现源码,因为一个读过实现的测试者写不出真正独立的断言。

3.2.3 多Agent协作约定

主会话的职责只有四件:拆任务清单、派发、对账、汇总交付。它能做什么,取决于它拒绝做什么——不自己开浏览器验证、不读 DOM 快照、不读全量 diff、不猜、不原地修。
四条通信约定:

  1. 下发自带上下文:目标、URL、账号、验证清单、报告路径随任务一起下发,子任务不「先问一句」。

  2. 回复自包含:结论 + 汇总 + 逐项明细 + 归因 + 产物路径,主会话不需要回读过程就能验收。

  3. 清单先行:只执行清单逐项对账,不自行扩充或缩减;清单与文档冲突时交回主会话裁定。

  4. 大块产物落盘:报告写文件,回复只带路径与摘要,上下文里不放整段原文。

状态码是这套约定的机器可判定部分。主会话的下一步动作由状态码决定,不需要读懂全文:

另有一条自洽校验:子 Agent 声称 PASS、但报告里出现失败项,判定为契约违约,结论不予采信。

3.2.4 拆的任务粒度与验收门禁

一个子任务 = 一个可独立验收的最小交付物。三条可判定的边界:下限——能写出验收清单;上限——单任务的上下文装得下验收标准;范围——必须显式声明,不含「顺便」。

出环要有门禁。四道门的判据都是命令能跑出来、结果能数出来的,不用形容词:

「不原地修」是硬纪律:缺陷一律回到清单层重新拆分,保证每一轮的收益可归因。

GEEK TALK

04

端到端交付完整流程

4.1 一次完整的研发Loop时序

按复杂度分两档,同一套角色定义,只差启用几个、走几个环节:

  • lean 档(简单需求,默认):4 环节——定档 → 编码 → 测试段(三路并行)→ 收口。6 个子 Agent 各占一个节点,零人工点。

  • full 档(复杂需求):10 环节、13 个节点,10 个角色全部出场。PRD 评审是全流程唯一停下来等人的环节。

档位由五条判据决定。F1—F5 全部不成立即 lean;任一成立即 full:

判不出来也按 lean:full 判错的代价是多一轮 PRD 评审的人工往返,lean 判错的代价只是少一轮评审与方案,执行角色照跑。lean 只减环节,不减角色。

主会话全程只持有两样东西:任务清单状态、各环节的自包含结论。并行点出现在测试阶段——单测与黑盒测试并行派发,互不阻塞。

4.2 一次完整端到端交付

需求是内部交付系统的「订单到达分析」。从提需求(PRD已提前放到项目根目录),到 CR 合入、pipeline 部署 QA、前端增量复测通过。

人一共出现 4 次:提需求、PRD 评审、技术方案确认、验收。中间两次是要人拍板的判断门,其余环节全自动。

执行流程

需求之后的七个执行环节依次推进:拆清单 → 改代码 → 本地测试 → 本地 review → 提 CR 与部署 → 黑盒与前端验证 → 交付。测试有缺陷则从验证环节回到清单重新拆,四门全绿才出环。

合并动作由部署交付员在 iCode 上完成:评审人 4 小时未打分即触发提醒通知,随后轮询评审状态并合并。提 CR 阶段产出 CR 与 pipeline 两次执行记录。

为什么人只在这 4 处出现:人该出现的位置不是「环节多」,而是「信息最不确定」。验收口径怎么算、改动边界划到哪,这两件事拿不准,后面所有验证都白做;一旦定下来,实现过程就是可被验证的执行——所以两道门之后,7 个执行环节不用人盯,出问题由门禁自动打回重拆。

GEEK TALK

05

上下文优化的可复用的判断

  1. 先削「每轮都带」的固定成本,再治「每轮新产生」的增量——前者一次性投入、长期收益。

  2. 指令分层的前提是常驻部分能独立完成常见请求,否则按需加载会变成更多往返。

  3. 把读文件类工作移出主会话,是收益最大的一刀;主会话只收结论。

  4. 权限与边界要落到工具层,不要指望提示词。

  5. 压缩是有损的:要么让信息在落盘后可回读,要么别让它进入上下文。

GEEK TALK

06

实践:一段把研发工作流改造成多 Agent 工作流的提示词

前面几节是结论。这一节把它变成可复用的一步:让 Agent 按固定工序,把你手上那条研发工作流拆成多 Agent 方案,并保证拆出来的东西在「上下文成本」和「可验收性」上都站得住。

6.1 怎么用

  1. 把下面的内容换成你自己的流程。越具体越好——有几步、每步产出什么、谁验收、最容易返工的是哪一步。

  2. 整段贴给具备文件与命令工具能力的 Agent(公司内的 DSH,或 Claude Code、Cursor 一类),不需要额外说明。

  3. 它会先追问缺的信息,再出方案。方案出来后按节改,不用从头再来。

6.2 提示词(可直接复制)

    你是研发流程架构师。你的任务不是写代码,而是把我现有的研发工作流拆成一套多 Agent 协作方案,
    并保证这套方案在「上下文成本」和「可验收性」上都站得住。


    【我现有的流程】
    - 环节:<按顺序列出,例如 需求澄清 → 方案设计 → 编码 → 自测 → 评审 → 提测 → 上线>
    - 每一步的产出物:<例如 方案文档 / 代码 diff / 单测报告 / 评审意见 / 测试报告>
    - 验收人:<谁签字才算过>
    - 最容易返工的地方:<例如 需求理解偏差 / 自测覆盖不足 / 评审反复>


    【目标】
    用尽可能少的主会话上下文跑完同一条链路;每个环节的产出都必须可判定。


    【必须输出的内容,按这个顺序】
    1. 角色表:角色名 / 一句话职责 / 输入 / 输出 / 写权限(全量写 · 仅测试目录 · 仅方案与台账文档 ·
       物理只读)/ 模型档位 / 为什么需要它。某环节不需要独立角色时明确写「合并」,并说明理由。
    2. 拆分判据:逐个环节判断「反馈循环紧不紧」,紧的合并、松的拆出,给出依据而不是结论。
    3. 单个子任务的粒度定义:下限(能写出验收清单)、上限(上下文装得下验收标准)、
       范围(显式声明,不含「顺便」)。
    4. 交接协议:主会话下发任务必须带哪些字段;子任务回报必须带哪些字段;
       状态码集合及每个状态码对应的动作。
    5. 验收门禁表:每道门的判据必须是可执行的命令或可数的数字,
       不许用「质量良好」「基本通过」这类形容词。
    6. 失败处理:子任务返回 FAIL / BLOCKED / NEEDS_CONTEXT 时主会话分别做什么;
       什么情况下必须停下来问人。
    7. 权限与安全边界:哪些能力必须从工具层禁用而不是写在提示词里;
       哪些动作必须保留人工门禁。
    8. 迁移步骤:从现有流程切到新方案,先做哪一步、怎么灰度、怎么回退。


    【约束】
    - 不要发明新名词。角色就叫「做什么的人」,不要用「一主六从」「舰队」这类缩写。
    - 不要假设我有人力扩充;方案必须在「1 个人 + 1 个 Agent 工具」的规模下成立。
    - 每个环节都要能回答「这一步省了什么」:上下文 token、往返次数,或返工次数。
    - 信息不足时先提问,不要编。一次最多问 5 个问题,且必须是你确实无法从上面推断的。


    【输出格式】
    Markdown。第 1、5、6、7 项用表格,其余用短段落。全文不超过 1500 字,宁可少写也不要重复。

    跳转微信打开

    AI 内容核查怎么做:智能内容 AI 核查系统实践

    2026年11月6日 12:00

    原创 欢迎关注的 2026-11-06 12:00 上海

    把内容拆成最小可验证主张、以权威证据逐条判定、由规则下结论——多阶段小模型流水线让 AIGC 内容核查降本落地五类业务。

    。图片

    点击蓝字,关注我们

    图片

    作者 | 弘远君

    导读 

    introduction

    AIGC 内容里的事实错误越来越隐蔽:前几段都对,最后一句张冠李戴;检索结果里对的错的都有,模型挑了不权威的那条。我们建设了一套内容 AI 核查系统,核心做法是把内容拆成最小的可验证主张,以权威证据为准逐条判断,让模型只判断证据与主张的关系,由规则给出结论。在此基础上,我们用多阶段小模型流水线把核查成本降下来,覆盖海量批量数据。系统已在知识百科、内容问答等五类业务落地。

    全文 4682 字,预计阅读时间 6 分钟

    GEEK TALK

    01

    核查难在哪

    先看几个线上真实出现过的错误:

    这些错误有个共同点:单看每一句都"有出处",错误藏在局部、藏在限定条件里、藏在多个数字之间的关系里。人工抽查覆盖不了这么大的量,简单规则也识别不出来。

    业界常见的做法有两类。一类依赖模型自身知识,比如多次采样看一致性、看输出的不确定性,但模型不知道的事实就验证不了,多次调用成本也高。另一类结合检索做验证,引入了外部证据,可搜索排在前面的结果是"和问题最相关"的,不一定是"权威且正确"的。开源框架方面,通用 RAG 框架缺少多轮"搜索 + 推理"的能力,专门的研究项目大多维护不活跃,没有能直接用到生产的方案。

    除了效果,还有工程上的约束:成本要撑得住海量且持续增长的数据,效果提升不能只靠换更大的模型,系统还要留出持续迭代的空间。

    GEEK TALK

    02

    核查思路:五条原则

    我们的核查方法可以归结为五条原则。

    1. 主张是最小核查单位

    长文本里的错误通常只出现在局部,整段判断容易被前文的正确内容"带过去"。我们先按文档结构拆段,再把每段拆成原子主张:一条主张只讲一个事实,主体完整,时间、地点补全。例如"它于 2019 年发布"要补全成"某型号手机于 2019 年发布"。每条主张独立检索、独立判断。

    主张粒度还有一个好处:相同或高度相似的主张可以复用结果,热点事实不用反复核查。

    2. 证据以权威性为第一排序因素

    核查的依据是外部证据,模型自身的知识只做辅助。证据的质量决定了核查的上限,而质量的第一指标是权威性。

    数据源按权威程度分成多个等级,从政府官网这类绝对权威的来源,到主流媒体,再到无权威性的来源。每个垂类维护自己的权威站点表。检索时先查高权威源,不够再逐级放宽。来源之间冲突时高权威优先,低权威来源只做风险提示。同一内容被多个不同域名转载,会被当作互证信号。

    3. 搜索与推理交替

    很多事实要多跳才能确认。"某城市最高楼有多高",要先确定最高的建筑是哪座,再查它的高度。我们参考 Search-R1 和 ReAct 的思路,让模型在推理中发现知识缺口时主动检索,拿到结果后继续推理,直到不再需要外部知识。

    检索 Query 也不直接用原句。主张会先被改写成适合检索的 Query,并单独处理时间限定这类容易召回失败的信息。

    4. 不同类型的内容走不同的路

    不是所有内容都需要最贵的通用链路。主张会先按垂类分流:通用事实走多轮搜索,电话号码查权威库,歌词和章节做结构化匹配,链接做有效性校验。纯观点、主观评价这类没有可核查事实的内容,在入口就被过滤掉。

    5. 模型判关系,规则做决策

    早期让模型直接输出"正确 / 错误 / 不确定",遇到两个问题。一是同一输入多次运行结果不一致,结果会"闪烁"。二是不同业务对"正确"的标准不一样:医疗要求权威来源,旅游可以接受多方印证,模型分不清该用哪套标准。

    改造后,模型只判断证据和主张之间的关系,在支持、部分支持、矛盾、无关、信息不足五类里选一个。业务结论交给规则映射:

    规则再结合来源等级、证据数量、是否高风险领域,输出正确 / 错误 / 争议 / 无权威来源的业务标签。这样业务之间的差异变成了配置差异,判定也更稳定。原来写在 Prompt 里、靠模型"自觉"遵守的要求也变成了代码里的硬规则。例如灾害伤亡、医疗、法律、金融等高风险领域,模型判"矛盾"但置信度不高时,不直接判错,而是降级为"无法验证"并进入复核队列。

    △ 改造前模型直接给结论;改造后模型只判断证据与主张的关系,由规则引擎映射成业务标签

    GEEK TALK

    03

    系统全貌

    △ 一次核查请求经过解析、校验、判定三段,每段上方标出对应的核查原则,底部是效果迭代闭环

    一次核查请求依次经过三段,上面五条原则落在各段里:

    1. 解析:过滤不需要核查的内容,按垂类把文本拆成原子主张,再复核一遍,去掉主体错位、信息丢失的主张。

    2. 校验:把主张改写成检索 Query,按权威等级逐级检索,证据按内容去重后按来源等级取最相关的几条。

    3. 判定:模型判断证据与主张的关系,规则输出业务标签。

    判定结果会进入右侧的迭代闭环:抽样分析、按阶段归因、针对性优化,新版本上线后开始下一轮(见第五节)。

    三种核查器,按场景组合

    不同业务对准确率、延时和成本的要求不同,系统提供三种核查器,它们对外接口一致,可以自由组合:

    △ 交互式与业务流量走"快速核查 → 专业核查"漏斗,海量批量数据走近线核查

    线上常见的组合是"漏斗":先走快速核查,只有出现矛盾标签的内容才升级到专业核查做深度复核。大部分没有问题的内容在第一层就结束,成本集中花在真正有疑点的数据上。海量批量数据则交给近线核查。

    这三种形态也是系统一路演进过来的。专业核查准确率高,但多轮交互的 token 随轮数近似平方增长,长尾延时偏高;快速核查链路短,但把所有判断压在一次超大模型推理里,成本撑不起大规模数据。近线核查就是为了解决规模问题而做的,下一节展开。

    GEEK TALK

    04

    规模化:从一个大 Prompt 到小模型流水线

    一次推理做六七件事的问题

    快速核查的 Prompt 有数百行,写满了权威来源表、证据数量门槛、同名实体处理、时效性降级等规则,等于要求模型在一次推理里同时完成六七件事。这带来三个问题:

    • 只能用最大的模型。换成小模型,效果断崖式下降。

    • 错了不知道错在哪。主张没拆对、Query 没搜到、证据被截断、判别本身出错,最后都只表现为"结论错了"。

    • 改一处坏一片。调整一条规则要动整个大 Prompt,经常按下葫芦浮起瓢。

    拆成六个窄任务

    大模型的能力没法让小模型直接替代,但大模型做的那件"大事"可以拆成若干件小模型能做好的"小事",其中能确定化的部分再下沉为代码。

    △ 一个数百行 Prompt 拆成六个窄任务,每个阶段交给小模型、规则或两者组合

    "模型判关系,规则做决策"在这里发挥了关键作用:判别 Prompt 从数百行缩到十几行,输出只有标签、分数和理由,数 B 参数的小模型也能稳定遵循。证据也先压缩再判别,每条主张只取最相关的几条证据,既省 token 又降噪声。

    用闲时 GPU 承接主力流量

    核查是典型的"量大、可延迟"任务。AIGC 数据成批到达,存量内容需要全量巡检,一批实验数据就可能有百万量级。这类任务不需要秒级返回,但需要高吞吐和低单价。搜索系统有大量推理卡在低峰期是空闲的,只要每个阶段的模型能压到数 B 参数,就能用这些资源承接主要流量。

    我们对拆分后的几类任务分别做了模型横评,规律很清晰:任务越窄,能胜任的模型越小。垂类识别这类分类任务,数 B 参数的模型就能完全识别正确;句子切分用中等尺寸的模型效果最好,Thinking 类模型更慢,效果却没有明显优势;推理判别难度最高,是小模型化的主要攻坚点。

    目前小模型已在近线 GPU 上正式部署,承接免审、拆主张、Query 泛化、判别等阶段的主力流量。在线大模型仍然保留,但换了位置:作为蒸馏小模型的教师、评测时的对照组,以及疑难样本的复核者。

    拆完之后,问题能归因了

    拆分还有一个比省成本更重要的收益:每条 bad case 都能定位到具体阶段。下面是某一轮人工抽样的问题分布:

    在原来的黑盒方案里,这些问题只能笼统地记成"判错了"。有了归因,后面的优化才能有的放矢。

    GEEK TALK

    05

    效果迭代:让核查越用越准

    核查效果没法一次做到位,靠的是持续迭代。我们按成本从低到高用三种手段:先做 Prompt 自动优化,到顶后再训练模型,两者所需的数据都来自样本回流闭环。这套方法对小模型尤其重要,因为小模型的单点能力弱,需要持续把效果追上来。

    DSPy:把 Prompt 从"手写"变成"编译"

    多个垂类乘以多个阶段,每个组合都要一套 Prompt。手工调 Prompt 改一处常常影响别处,在大模型上调好的 Prompt 换到小模型上效果也难以预期。

    DSPy 换了一种思路:只声明任务的输入输出,给定标注数据和评估指标,由优化器自动搜索指令措辞和示例。我们在一个"规则藏在数据里"的分类任务上对比了几种优化器(推理模型都是数 B 参数的小模型):

    这组实验规模不大,但趋势和业务上的观察一致:

    • MIPROv2 容易把训练集里的个别样例写进指令,泛化差;GEPA 通过反思错例总结出能泛化的判定规则。

    • 反思模型和推理模型可以分开选。线上推理用小模型控制成本,离线反思用最强的模型挖规则,等于把大模型的能力"编译"进了小模型的 Prompt。

    目前 GEPA 已覆盖免审判断、分垂类主张提取、主张复核、Query 泛化四个阶段。以 Query 泛化为例,难点在时间信息:带上年份经常召回不到,去掉年份又可能召回到别的年份。这类取舍很难用一条手写规则覆盖,交给 GEPA 从错例中归纳,再由代码兜底,检索不到证据的 Query 比例显著下降。

    模型训练:Prompt 到顶之后

    对调用量大、任务边界清晰的阶段,我们训练专用小模型:

    • 垂类分类模型:识别主张属于哪个垂类并分流(见第二节原则 4)。结合主张解析的整体优化,主张识别准确率相比基线大幅提升。

    • Query 改写模型:提升多跳、隐式事实的召回,训练数据来自业务反馈。

    • 大模型蒸馏:用大模型离线生成各阶段的训练样本,人工修正复合句拆分、同名实体、时间数字细节等高频错误,再加入"不要从证据中扩展主张"这类负例。

    • 强化学习:基于 VERL 复现了 Search-R1 的训练流程,让模型自己学会何时搜、搜什么。

    样本回流:闭环怎么转起来

    △ 核查结果经抽样分析和人工复核后按阶段归因,分三路优化,新版本双跑对比后上线,再开始下一轮

    这条闭环能转起来,靠的是阶段拆分。没有归因,样本只能标"对 / 错",没法分发到具体阶段的训练集。

    几轮迭代下来,我们还发现问题分布会转移。第一轮主张提取是主要矛盾,引入 DSPy、按垂类拆分之后,判别阶段成了新的瓶颈。每一轮的投入方向都跟着数据走。

    GEEK TALK

    06

    HarmonyOS开发简介

    多轮搜索:让模型持有状态,而不是历史

    专业核查的多轮"搜索 + 推理"准确率最高,但每一轮都把之前所有的检索结果重新喂给模型,输入 token 随轮数近似平方增长。我们做了三处改造:

    • 模型持有状态,而不是历史全文。 模型的输入是"目标 / 已确认事实 / 待解决问题 / 下一步动作"这样的状态,不再是每轮的原始检索结果。

    • 能并行的意图一起检索。 比如第一轮分析出要验证 A、B、C 三个论点,把三者一起检索,比串行执行时模型反复看到 A、B 的结果要省得多。减少轮数同时降低成本和延时。

    • 检索结果进入上下文前先精简。 单轮检索结果按句子裁剪,多轮历史做摘要,下一轮只带结论不带原文。

    改造后多轮累积 token 从随轮数平方增长降到线性增长;单轮裁剪后 token 明显下降,准确率无损。

    性能治理

    配置化与多模态

    系统从早期按功能拼接的脚本,改造成了可配置的阶段编排:每个业务一份配置,声明用哪些阶段、什么模型和 Prompt,阶段实现在业务之间共享。新业务接入主要是写配置和 Prompt,不用改主流程代码。

    GEEK TALK

    07

    业务落地

    GEEK TALK

    08

    几点体会

    • 核查的依据是证据,模型自身的知识只做辅助。 证据的权威性决定了核查的上限,所以权威分级和检索策略要放在和模型同等重要的位置。

    • 以主张为单位核查。 长文里的错误大多是局部的,拆到最小主张逐条判断,才不会被正确内容掩盖。

    • 模型给特征,规则做决策。 一个设计同时解决了结果闪烁和多业务标准不一致两个问题。

    • 小模型能不能用,先看任务够不够窄。 把能确定化的业务规则从 Prompt 挪进代码,模型只做语义判断,小模型就能胜任。

    • 能归因,才能迭代。 阶段拆分让每个 bad case 都有明确的去处,Prompt 优化和模型训练才有针对性的数据。

    跳转微信打开

    QCon上海2026:百度 SRE Agent 规模化落地实践解读

    2026年11月4日 18:00

    原创 欢迎关注的 2026-11-04 18:00 北京

    QCon上海2026,百度SRE Agent规模化落地实践经验官方解读。

    。图片

    点击蓝字,关注我们

    图片

    作者 | 百度 SRE

    导读 

    introduction

    过去一年,做出一个 Agent 其实不难:它能听懂问题、调几个工具、把一段任务跑完,有时候效果还挺惊艳。但当我们真的把 Agent 放进生产环境,关心的问题立刻就变了——它部署在哪、谁维护、配置怎么更新、出了问题怎么查、调一次会不会污染线上、调用生产工具安不安全、这次处理的经验能不能留下来给下一个 Agent 复用……

    也就是说,难点已经不再是"能不能做出来",而是"能不能稳定地托管起来、能不能安全地跑起来、能不能持续地变好"。QCon 上海2026 百度运维部出品的《百度SRE Agent 规模化落地实践——大模型 Agent 的安全托管与自主进化探索》分享详细介绍了AgentOps业务落地经验。

    全文 5194 字,预计阅读时间 8 分钟

    GEEK TALK

    01

    背景与规模化挑战

    一个团队只有一个 Agent 的时候,很多问题靠人就能解决:找台机器起个实例、配个消息通道、准备几份 Skill,出问题登录机器看日志——不优雅,但能跑。

    可一旦 Agent 多了、团队多了、场景复杂了,这套做法会迅速失效。我们把它归成六类问题:

    • 接入与部署:每个团队都重复准备环境、配实例、接通道,大量时间花在"让 Agent 跑起来",而不是让它的业务能力变好。

    • 配置与版本:一个 Agent 不只有 Prompt,还有 Skill、工具、知识、运行时配置,这些没有统一的版本边界,调试里的改动很容易污染线上,出了问题也不知道是哪次变更。

    • 运行与观测:一次执行包含意图理解、规划、Skill 选择、多次工具调用,如果只看最后一句回答,根本判断不出问题出在模型、知识、工具还是流程。

    • 安全与权限:Agent 一旦能碰生产,就可能触发查询、变更、写操作,光靠 Prompt 告诉它"别干危险的事"远远不够,必须有平台级的权限、审批、限流、审计和回滚。

    • 能力复用:公共工具、业务知识、历史经验难沉淀,场景建设高度依赖少数专家。

    • 质量与演进:没有稳定的 Case、回放和评估体系,你根本没法判断新版本是不是真的变好了。

    一句话收口——当 Agent 从"单点试用"走向"规模化生产",接入、版本、观测、安全这些缺失会集中爆发,结果就是:企业用得起来,却管不住、不敢放大。AgentOps 要解决的,就不是某一个 Agent 的问题,而是这一组规模化问题。

    GEEK TALK

    02

    AgentOps 整体架构

    自下而上五层:

    • 基础设施层,算力、存储、网络;

    • 能力供给层,模型、工具、知识库、公共 Skill;

    • 平台层,也就是整个 AgentOps 的核心;

    • 网关层,统一入口、鉴权、路由、限流;

    • 接入层,如流、数字员工、Web、消息机器人、OpenAPI 这些入口。

    这里有一个我们特别想强调的设计思想:控制面和数据面分离。控制面负责"定规则、管治理"——配置、版本、发布、评估、知识、安全策略;数据面只专注"执行"——正式实例跑真实业务,调试沙盒跑草稿和回放,两者隔离。为什么要分开?因为解耦之后才好独立演进、好扩展,业务团队专注场景逻辑,外围工程能力交给平台。

    而平台层里,我们用五大中心统一把 Agent 管起来:Agent 管理、安全、变更、评估、知识 一起纳管,五层架构让 Agent 从"能跑"走向"敢用"。

    AgentOps 的五大核心能力,是一条从"稳定运行"到"持续进化"的主线:Runtime 全生命周期托管 → 安全管控 → 场景仿真回放 → 知识沉淀与能力闭环 → Agent 自主进化。

    GEEK TALK

    03

    Runtime 全生命周期托管

    我们不希望每个团队都自己维护运行实例,而是平台统一管 Agent 从创建 → 配置 → 部署 → 运行 → 升级 → 监控 → 故障恢复 → 下线的全过程。这里的"托管"不只是起个进程,它至少包含四块:

    • 全周期托管,一站式纳管;

    • 统一资产与状态,配置、能力资产、运行实例、会话状态、版本发布、运行观测集中管理,实例迁移重建后上下文也不丢;

    • 高可用保障,健康检查、状态持久化、实例恢复、依赖切换,做到故障自愈;

    • 弹性与多租,按负载伸缩、多团队隔离、配额成本可控。

    这块带来的直接变化是:新 Agent 的交付周期,从"周级"降到"天级",而且稳定性有 SLA 兜底。说白了——Agent 的"可用"不是某个组件的状态,而是配置、能力、实例、依赖共同可用,这件事交给平台兜底。

    GEEK TALK

    04

    安全管控

    Agent 进了生产,安全是绕不开的底座。我们有一个基本态度:安全责任不交给 Prompt,也不假设模型永远正确理解风险。

    先看风险到底长什么样? Agent 能自主调工具、执行写操作,用户、模型、系统、并发四个层面都可能让一次写操作失控。举两个真实的例子。

    • 案例一:Agent 迭代后跟数据库交互,数据字典对不上、insert 一直失败,它多次试错无果,居然直接把库 DROP 了、重建 table——结果数据被删、业务中断。本质是"为达成目标自主升级到高危写操作,全程没人把关"。

    • 案例二:指令只是把配置里 A 字段从 v1.32.0.1 改成 v1.33.0.1,结果 B 字段恰好也是这个值,Agent 顺手把 B 也改了——本质是"超出指令作用域、关联误伤、没有精确的范围控制"。

    那我们怎么管? 不是单点拦一下,而是从构建时到运行时的四道防线,L1 到 L4 逐层覆盖。

    • L1 构建时:事前约束,声明允许/禁止的动作与边界;

    • L2 意图审计:第三方专家 Agent 比对"需求 ↔ 产出",产出评审意见;

    • L3 本地 Hook:审计 Agent 产出的 runbook 具体动作和对象;

    • L4 网关代理:代理所有 API/HTTP 调用,统一管控并审计接口、参数、QPS。

    一句话——安全不是最后一道闸,而是从构建到执行的全程护栏。

    最后两件压舱石:身份与可回滚。

    • 身份上,我们落地了委托令牌:令牌里承载"具体用户 + 发起 Agent"双身份,并且做了加密防盗用。关键是——我们用的是委托,不是冒充,完整保留"谁代表谁",这样调用链能定责、越权能拦。

    • 审计上,做 5W 审计:谁、哪个 Agent、何时、对哪些对象、做了什么,日志落本地并持久化。回滚上,每次提交都可回滚,能撤销最近一次写操作。而且所有托管的 Skill 都过 AI Review,天然可审计、可回滚。

    GEEK TALK

    05

    场景仿真回放

    也就是为什么需要评估中心? Agent / Skill 的迭代有几个老大难:

    • 变更影响难验证,改一处可能牵一发而动全身,人工回归范围有限;

    • 场景难复现,切流、回滚这类高危写操作根本不能在线上跑;

    • 验证环境不一致,不用同一个 Agent 验证,memory、session 的状态都会干扰结果;

    • 问题难定位,只看最终结果看不出偏差在哪;再加上结果难验证、效果难评估、人工建 Case 成本高。

    这些叠一起的后果就是——每次更新都得人工逐条 review,Agent / Skill 根本快不起来。

    我们的解法是一个真实场景驱动的评估闭环。

    • 从线上告警和多轮会话里自动记录 Trace,真实映射运行时的行为链路;

    • 再从里面选高价值的 Trace,沉淀成含"输入 / 上下文 / 工具快照 / 期望结果 / 期望过程"五要素的标准 Case;

    • 验证新版本时,把 Agent 部署到回放沙盒,对当前版本执行 Case 回放,不碰生产就能验证;

    • 回放过程里实时看 Trace,精确定位到是哪一步、哪个工具、哪个参数出的问题;

    • 最后输出评估报告,给总体得分和"期望 vs 实际"的过程对齐,支撑"继续迭代还是达标发布"的决策。

    这里特别说一句外部依赖怎么处理:靠工具快照回放——API Server 拦截 + Replay Runtime 还原返回值,不依赖真实外部系统,所以可复现。

    Case 怎么生成和治理?Case 可以从线上 Trace、人工创建、已有 Case 复制、标准文件导入等多来源汇聚,经过人工审核、沙盒验证后才入集,保证质量可控、来源可信;平台沉淀出一套通用 Trace 与 Case 集作底座,业务还能按需拼接自己的 Case 来回放。这里有个前提要强调:评估能力是建在安全中心之上的——拦得住,才敢跑。Case 不是一次性用例,而是能持续沉淀、安全可控的资产。

    GEEK TALK

    06

    知识沉淀与能力闭环

    我们的看法是:知识沉淀不是把一堆文档塞进知识库就完了,而是要让经验沉淀成合规可信、可复用的 Agent 能力。

    • 多源沉淀:业务文档、运营经验、Case 记录、会话、用户反馈统一汇入。

    • 合规校验把关:源知识入库前,要过权限、脱敏、质量三道校验:权限上按来源和访问权限管控、敏感知识隔离;脱敏上入库前自动脱敏,账号、密钥、隐私信息都要处理掉;

    • 质量上要求知识带来源、适用条件、版本和验证状态,还做去重、冲突检测和时效校验。机制上,是断言设计做结构化自动校验 + 人工评审把关主观质量与边界,双重把关、不达标不入库。过了这关,知识才会走"知识 → Skill 候选 → 规范审计与单测 → 场景回放 → 发布复用"变成能力;

    • 线上用起来的反馈再回流知识库,用回放通过率、采纳率来衡量,持续提升。

    为什么强调合规?因为会议纪要、群聊这类来源在大会上特别容易被追问数据权限和脱敏,我们宁可少而准,不要多而误导。

    GEEK TALK

    07

    Agent 自主进化

    这里的自主进化,不是让 Agent 自己改生产配置,也不是让模型无约束地扩权,而是一种受控的能力优化。

    • 更新的是什么?我们只调 Prompt(主要是 md)、Skill、知识、安全策略这些能力组件,不动模型权重——成本低、可回退。

    • 怎么评估?由评估中心基于灵活的 Case 集做回放,判定靠三样:用户断言、Case 通过率,再加一层专家人工评审去确认"实际效果到底符不符合预期",三样都过才进发布。

    • 怎么管控风险?安全沙盒隔离、支持可控放行、版本管控,加上热更新带来的秒级回滚。整体就是:优化而非重训、评估门禁把关、安全兜底、数据与知识回流形成飞轮。

    再看一轮优化具体怎么跑, 触发有三种:

    • 生产或评估里的 Bad Case、知识更新、以及人工按需触发。触发后由 Agent 优化智能体生成候选——问题分析、定向优化、产出候选;

    • 候选进可靠评估,按断言 + Case 通过率回放,退化即拦;

    • 然后是可回退闭环——不通过就回炉,通过就灰度,异常就秒级回滚。

    这样每一次优化都是"可触发、可评估、可回滚"的闭环,而不是黑盒自动变更。

    GEEK TALK

    08

    实践与沉淀 - 平台赋能

    业务用 AgentOps,只需要关注自己的差异,运行、安全、变更、评估、知识都交给平台统一托管。现在的覆盖情况:覆盖10+百度核心业务线、20+ 接入的 SRE Agent、50+ 开箱即用的 Common SRE Skill、3 套 SRE Agent 建设模板,迭代周期从天级降到小时级。

    对比一下过去和现在就很直观:

    • 接入,从各自搭环境到选模板一键迁移;

    • 稳定,从自己做 fallback 到默认高可用;

    • 安全,从各自鉴权到标准鉴权透传;

    • 工具,从重复开发到 50+ Skill 开箱即用;

    • 迭代,从天级发版到小时级热更新;

    • 进化,从经验散落到沙盒评估加知识沉淀、自主进化。

    GEEK TALK

    09

    最佳实践 · Agentic 故障处置

    用一个例子把前面的能力串起来——业务基于 AgentOps 的能力,快速组织出一个 SRE Agent,把某类故障的 MTTR 打了下来。场景是"某核心服务实例批量故障"。流程是这样的:

    • 感知,根据异常对象、服务拓扑、时间范围,采集告警、日志、近期变更,Agent 自动拉群并汇总上下文;

    • 召回 + 分析,召回 3 条相似历史案例和处置手册,生成"变更 / 机房 / 流量"多个猜想,并组织证据链;

    • 验证收敛,逐一排除,证据指向一次配置变更导致连接池耗尽、请求超时;

    • 判断授权,工程师确认根因、授权回滚,平台按审批执行、全链路留痕;

    • 止损恢复,回滚后超时率回落、服务恢复;

    • 复盘沉淀,自动生成复盘,新增 1 条 Case 和 1 个"实例健康巡检"的预案 Skill。

    效果上,这是一个示例案例:同类 Case 的 MTTR 从 60 分钟降到 10 分钟。我们特意强调"示例"——这是单次案例的口径,不是统计平均;正式对外的效率数字,都应该说明样本范围、统计口径和对照基线。这页真正想说的不是某个数字多亮眼,而是:业务能基于平台快速搭出一个 Agent 并见效,而且经验还能沉淀下来给下次复用。

    GEEK TALK

    10

    经验沉淀 · 四大核心权衡

    做 Agent 平台,真正难的不是某个单点能力,而是一组互相拉扯的权衡。我们的做法是"用机制让两端协同",而不是二选一。四组权衡:

    • 智能性 × 确定性——规划和执行解耦,高风险动作收口到工具和控制面,既留灵活、又守可预测。

    • 安全 × 效率——按风险分级处置,自动放行 / 人工确认 / 强制审批 / 强制阻断,低风险快、高风险稳。

    • 知识多 ≠ 高质量——知识必须带来源、适用条件、版本和验证状态,宁可少而准、不要多而误导。

    • 生成 × 验证分离——引入独立验证机制,外部证据加多方评审,避免同一个模型自证正确。一句话:好的平台不是消灭矛盾,而是把每一组权衡都变成可控的工程选择。

    GEEK TALK

    11

    总结与展望

    回到最开始的问题:Agent 从单点试用走向规模化,缺的到底是什么?我们的答案是——缺的不是更多孤立的 Agent,而是一套能把 Agent 托管起来、安全地跑、验证效果、沉淀经验、持续改进的平台。我们把它分成三个阶段:

    • 阶段一 · 统一托管(已落地):一套平台托管 Agent 全生命周期,解决"能跑、敢用"。

    • 阶段二 · 持续进化(进行中):知识闭环加场景回放驱动自主优化,用回放通过率、采纳率来衡量、持续提升。

    • 阶段三 · 自治运维(未来):让 Agent 辅助管 Agent,人只定目标和边界,运维走向自治。

    最终我们想要的,是"让每一次执行都更安全,让每一份经验都可复用"——不是让 Agent 凭空变成专家,而是让专家的判断能被记录、复用、持续放大,最终形成团队级、平台级的专家能力。

    更多智能运维产品,欢迎联系:https://sre.baidu.com/

    跳转微信打开

    好看视频鸿蒙端AI研发交付流程的建设思考与实践

    2026年10月28日 12:00

    原创 欢迎关注的 2026-10-28 12:00 上海

    用"完整、正确、可验证、可持续"四条标准衡量鸿蒙端迁移:行为建模保完整、语义映射保正确、分层测试保可验证、迁移飞轮保可持续,让 AI 编码交付不再依赖个人经验。

    。图片

    点击蓝字,关注我们

    图片

    作者 | 梅花禄

    导读 

    introduction

    鸿蒙端存量功能迁移,难就难在"输入基线不清晰":预期行为没有文档,要从源端代码里自己找、自己界定、自己证明。本文将一次迁移拆成"迁什么、怎么迁、怎么证明迁得对、怎么持续迁移"四个问题,据此提炼出完整、正确、可验证、可持续四条标准,并在 AI Coding 之上落地为一套研发交付流程:从源码行为建模到需求矩阵对账,从语义映射、多设备适配到分层测试与质量门禁,配合状态落盘和"迁移飞轮"实现经验复用。文末以"随听频道"真实迁移(52 个行为点、65 条用例)完整验证了这套机制的可行性。

    全文 8259 字,预计阅读时间 6 分钟

    GEEK TALK

    01

    引言:为什么要建设鸿蒙端AI研发交付流程

    鸿蒙端的研发工作目前分为两类:迁移Android/iOS 端的存量功能,以及开发鸿蒙端新功能。鸿蒙端整体建设周期相对较短,所以存量功能迁移是当前工作量最集中的部分。这些功能大多经过长期迭代,调用链路深、隐性逻辑多,迁移难度也比较大。

    借助AI Coding编码效率有了很大提升,但从需求到交付仍有不少环节依赖人工,比如识别需要实现的全部行为、确认实现与源端或需求一致、验证功能表现等。这些环节受研发精力和对历史需求熟悉程度的限制,往往耗时长、容易出错。因此,我们需要一套覆盖研发全过程的鸿蒙端 AI 研发交付流程,在提升效率的同时,让交付质量由流程来保证,不再依赖研发的个人经验。

    GEEK TALK

    02

    如何思考和衡量交付

    迁移比生成要更复杂,复杂在其输入基线范围不清晰。生成的预期行为写在需求文档里;迁移则要从源端代码里自己理解目标、界定边界,还要自己证明结果与源端一致。在设计研发链路之前,要先想清楚一次迁移怎样才算做好。我们从如下四个方面进行了梳理与思考:迁什么、怎么迁、怎么证明迁得对、怎么持续迁移。

    △ 图 2-1  迁移要回答的四个问题

    • 迁什么

    迁移首先要界定范围,识别需要在鸿蒙端还原的全部源端行为。主功能容易识别,遗漏多出现在分支路径、边界条件、异常处理、状态流转、数据链路和埋点等隐性行为上。这类行为通常没有文档记录,在主流程和界面上也不明显,却直接影响两端表现是否一致。识别的对象是行为,源端代码只作为还原行为的依据。范围内的行为须逐条还原,范围外的不纳入。

    • 怎么迁

    迁移可以采用新的实现,但可观察行为须与源端等价。源端依赖的平台能力如果在鸿蒙没有对应机制,需要重新设计等价实现;折叠、平板、多窗口等鸿蒙特有形态也要一并适配。范围较大的需求按可独立验收的粒度纵向拆分,逐阶段实现和验收,控制单次改动的范围。

     △ 图 2-2 迁移对齐业务意图与行为

    • 怎么证明迁得对

    代码完成不等于迁移正确,结果要通过验证闭环来证明:以行为基线为依据核验鸿蒙实现,发现差异就修正,再重新验证。设计这条闭环时,要明确行为等价怎么判定,验证力度和成本怎么平衡。真机验证成本高,验证按成本分层调度。交付是否完成,以可追踪的验证结果为准。

    • 怎么持续迁移

    一次完整的迁移通常要跨多个阶段,中途难免中断和返工,流程要能从断点恢复。源端还会继续演进,再次迁移时只需处理变化的部分。每次迁移积累的平台约束、常见模式和失败案例,也要能在后续任务中复用,让效率和稳定性随迁移次数逐步提升,形成迁移飞轮。

    这四个问题对新功能生成同样成立,纯新需求没有源端可参考,预期行为以需求文档为准:界定范围的依据从源端行为换成需求文档,实现的目标从行为等价换成满足需求,验证与持续推进的要求不变。归纳起来,衡量一次迁移或生成是否做好,有四条标准:完整、正确、可验证、可持续。

    GEEK TALK

    03

    四条标准的工程化实现

    将这四条标准作为工程化设计的要求和约束,落到理解、规划、实现、验证、修正、持续推进等各个环节的设计中,我们在AI Coding之上建设了一套研发提效流程,每条标准对应一组设计:

      • 完整:源码理解与行为建模梳理出行为基线,需求矩阵与全链路对账逐条核对每个行为点;

      • 正确:跨平台语义映射把源端语义转换为鸿蒙实现,多设备适配覆盖鸿蒙特有的设备形态;

      • 可验证:质量门禁要求每个行为点都有客观证据,分层测试按成本组织验证,兼顾覆盖面和开销,验证从规划阶段就开始;

      • 可持续:流程状态全程落盘,中断后可以从断点继续;迁移飞轮把每次任务沉淀的经验用到后续需求中。

    △ 图 3-1  四条标准作为约束贯穿整条研发闭环

    这些设计共用同一个流程底座,其中多数同时对应多条标准,作用也跨越多个阶段。它们按研发顺序前后衔接,组成端到端的交付流程,由需求矩阵贯穿全程。

    3.1 统一底座

    统一底座的设计思路是让同一条流程可以同时承接不同类型、不同规模的需求。

    迁移/生成模式判定

    有可参考的源端实现时走迁移模式,以源端真实行为为基线;没有时走生成模式,以需求文档为基线。两种模式共用理解、规划、实现、验证、持续推进这条主干,也共用同一道验收门禁。迁移特有的行为基线梳理和行为等价核对嵌在既有阶段内部,只在迁移模式下启用。

    模式由系统根据需求说明和参考源自动判定,依据不足时交给用户来确认。典型情况是需求正文提到“安卓已有此功能”:这通常只是背景说明,并不要求行为等价迁移。如果误判成迁移模式,流程会进入成本最高的源端行为梳理。遇到这类情况,系统会列出判定依据,由用户决定。

    △ 图 3-2 迁移与生成两种模式共用同一套引擎

    复杂度分档

    迁移需求可能只涉及单个功能点,生成需求可能要从零搭一个多模块页面。为了让流程开销与需求规模匹配,系统还会按需求涉及的范围自动判定复杂度:改动集中、一次就能验收的走单轮流程,小改动不用承担多阶段开销;涉及面大的按可独立验收的粒度纵向拆分,逐阶段推进。阶段怎么拆也由系统先判定,存在取舍时交给用户。阶段越细,每次收口的固定开销占比越高;合并阶段会扩大单次审查的范围,审查精度会不会下降,目前还没有结论。在有结论之前,流程不自动合并阶段,只对偏小的阶段给出合并建议。

    △ 图 3-3  模式判定与复杂度分档

    Dry Run模式

    有些需求不涉及编码,只需要判断值不值得做、怎么做、成本多大,例如方案预研、工作量评估和范围圈定。这类需求走Dry Run模式:流程完成理解和规划,产出方案、范围、成本和验收标准,到这里就停下,不进入执行。流程状态照常落盘,中断后恢复也不会误入执行;决定落地时,从当前状态继续推进。

    横切保障

    需求对账、多设备适配、分层测试、迁移飞轮、状态落盘,以及交互纪律(方向性决策只在需求澄清、方案确认、最终验收三处由用户裁定)和成本护栏(高成本手段事前授权),都分布在多个阶段、各管一段,我们把它们统称为横切保障。它们遵循同一个节奏:前期确立标准,执行中持续对照,交付前逐项核验。这样设计,是因为在流程最后检查只能发现问题,不能预防问题:如果标准没有在前期确立,验收时也没基准依据作参考来判断缺失了什么。各项机制最终统一由验收门禁核验,如果没有通过验收就退回到执行环节修复。

    △ 图 3-4 横切保障纵向贯穿相关阶段

    3.2 完整:从行为基线到需求矩阵

    源码理解与行为建模负责把该迁的行为找全,尤其是主流程之外的隐性逻辑,找全之后还要能逐条核对,才能确认交付没有遗漏,因此做了需求矩阵与全链路对账的设计。

    源码理解与行为建模

    源码理解的难点在于把该迁的行为找全。最容易漏的通常不是主流程功能,而是命名对不上、没有明显入口、靠开关或跳转才触发的代码,顺着功能名搜不到。第一步是先定位承载行为的代码,再顺着入口注册、埋点上报这类和命名无关的线索反查补漏,把名字对不上、但确实属于这个功能的代码找回来。代码找齐后,从触发条件、异常处理等方面逐条还原行为,并遵守两条约束:对齐的是行为,不是逐行对齐代码;关键数据和埋点逐字对齐。时序、并发、AB 实验在线上命中哪条分支,这类静态分析确定不了的逻辑标为“待真机验证”,不计为已覆盖。

    △ 图 3-5  源码理解与行为建模

    梳理出的源端行为逐条整理成行为基线,登记进需求矩阵,哪些还没实现,在矩阵上逐条可查。不过,这只能保证基线内的行为不遗漏:基线内缺一条就过不了验收门禁;基线之外的遗漏,要靠多角度交叉核查和真机验证兜底。

    需求矩阵与全链路对账

    做这套机制之前,我们踩过一个典型的坑:一条本该跨视图联动的交互,只跑了一条成本最小的验证,就被记成已覆盖。表面上完成了,关键路径其实根本没验到。实践中遇到的问题主要有三种:源端行为没有进入基线(漏),验证深度低于应有的要求(浅),用成本最低的验证代替应做的验证(虚)。

    我们的做法是为每次交付建一张需求矩阵。每条需求拆成行为点,逐条对应到任务、实现和验证记录。验收按固定顺序推进,行为登记后,从三个角度依次核查:是否有行为没有进入矩阵,验证深度是否与行为的重要程度相符,每条结论是否有真实的运行证据。三个角度分别对应漏、浅、虚三类问题,职责不重叠,也不互相补位,全部通过后由验收门禁放行。

    △ 图 3-6  需求矩阵与全链路对账

    对账通过后,每个行为点都必须落到以下三种结论之一:

    • 行为等价:已经实现,并逐点对照源端核对过;按需求有意与源端不一致的,差异和依据记录在案,也计入此类;

    • 主动排除:平台特有或需求明确不做,写清原因;平台特有的同时写明鸿蒙侧替代方案;

    • 显式放弃:无法迁移,或者迁移的收益抵不过风险,写清理由,并经用户逐条确认。

    只要有一条没有结论,验收就被阻塞、退回执行。需求矩阵因此成为整个流程的底账:完整、正确、可验证都在这本账上核对,增量重迁也以它为起点。

    3.3 正确:语义映射与多设备适配

    要保证迁移正确,首先要做到行为与源端等价:实现可以另起一套,但可观察的行为必须一致,并按需求矩阵逐条核对,这由语义映射机制来实现。其次还要能处理折叠、分屏、多窗口这些在鸿蒙端分量更重的多设备形态,迁过来的功能在这些形态上同样要正确展示、正确运行。

    语义映射

    鸿蒙、安卓、iOS 的差别不止在语言,UI范式、生命周期、组件复用和系统能力的组织方式都不一样。迁移不能逐行把源端符号替换成 ArkTS,要把源端的业务语义从界面、业务逻辑、数据流、状态流转、平台能力几个维度映射成鸿蒙实现。从实践看,映射对象分两类:一类是接口调用、页面结构、业务分支等显式逻辑,源码里写得明确,鸿蒙也有成熟的对应写法,可以按统一原则逐项落地;另一类是编译和单测都能通过、只在真机上暴露的隐性差异,例如源端框架会自动清理订阅,鸿蒙需要手动移除,又如生命周期与复用机制的差异,导致视图复用后仍绑定着旧数据等。

    两类问题各用一套机制处理。显式逻辑按统一原则翻译:翻译的对象是机制,源端的回调、观察、并发等写法换成鸿蒙原生的等价机制,并对齐目标工程的既有约定;每个行为点落地后回写源端与鸿蒙的对应关系,作为行为等价核对和增量重迁的依据。隐性差异靠经验沉淀提前规避:踩过的问题逐级沉淀,跨需求反复出现的固化为平台规则,编码时默认规避。

    多设备适配

    除了语义映射,还要适配鸿蒙特有的多设备形态。同一套代码要在直板机、折叠屏、三折叠、平板和 2in1 / PC 上都能正常运行,还要处理折叠切换、悬停分屏、折痕避让和屏幕旋转。如果照着源端的单一形态写,多设备调试会又复杂又耗时。我们用三条原则约束布局的写法:

    • 布局只依据窗口尺寸和断点,不依据设备类型,因为折叠、分屏、自由窗口都会让设备类型失真;

    • 折叠状态和屏幕方向只用于悬停分屏、折痕避让、开合状态延续这类特性分支,不参与布局决策;

    • 所有系统尺寸都在运行时动态获取,不写死。

    这三条原则不只写进了规范,也落实到流程的每个阶段。需求澄清时,先确定要覆盖哪些形态、每种形态怎样算通过,并写进验收标准;执行时,三条原则是生成代码的默认约束;验收时,按预览器 → 模拟器 → 真机由轻到重逐个形态核验,任一形态不通过就退回修复。

    △ 图 3-7  多设备适配的三条原则与逐形态验证

    3.4 可验证:质量门禁与分层测试

         每个行为点的交付结论不能靠模型的主观判断,必须有客观且可核查的证据,这在流程里是通过质量门禁与独立审查机制来实现的。其次还要控制验证成本,不能在每个测试点都执行所有的测试手段,真机执行成本高,每次全量跑并不现实,分层测试让验证按成本由低到高逐层推进,把成本高的测试手段留到必要时才用。

    质量门禁

    问题发现得越晚,基于它的实现就会越多,返工成本就会越大。质量门禁从规划阶段就开始设置,一直持续到验收。规划阶段生成方案时会先核对方案依赖的关键前提,例如状态的写入点、数据来源,并把依据写进方案,在编码前排除方向性错误。验收阶段,编译与静态检查、需求绑定测试、需求覆盖核对按成本从低到高执行,迁移模式另加行为等价核对;任何一道不通过,都退回执行环节修复。门禁本身跑不起来时标注原因,不计为通过。

    这些门禁检查的都是能客观判定的结果。方案思路是否合理、代码里有没有测试覆盖不到的分支和时序问题,要靠审查判断。方案定稿和代码完成后各做一次独立审查,由与编写方上下文隔离的 Agent 只读执行;方案审查同时核对前提依据是否齐全。审查确认的问题也作为门禁项,不解决就不放行。

    当然,设计上,门禁的边界也很明确:它只判定可以客观验证的事实和审查确认的问题,复杂交互和主观体验仍由人工验收,门禁通过不等于功能没有问题。

    分层测试

    需求实现后要验证纯逻辑、多设备布局、真实交互、折叠形态和真机硬件几个维度,缺一不可,各维度的成本却相差很大。真机执行耗时长,通常还要人工值守,不可能每次验收都对每个行为点全量执行;只跑成本最低的逻辑测试,又发现不了布局错位、折叠重排、传感器异常这类问题。

    我们按成本把自动化测试分成一座金字塔。底层成本低、结果稳定,每次验收都跑;越往上越接近真机,成本越高,只在最终收口或用户授权时执行。塔尖是不预设脚本的探索式验证:模型在真机上实时读取界面结构,自己决定下一步操作,用来覆盖设计用例时没想到的路径。探索有执行上限,跑通后的操作轨迹固化成确定性用例,之后直接回放。

    在研发流程中,规划阶段将每条用例绑定到具体的需求或行为点,用例失败与需求未实现同样阻塞验收;验收阶段按成本由低到高逐层执行;执行通过的用例沉淀为回归资产,持续复用。未执行的层级标注原因,不计入通过率。

    △ 图 3-8  按成本分层的测试金字塔

    3.5 可持续

    迁移是长任务,常被会话中断或验收返工打断,状态落盘让流程恢复后能从断点接着运行;每次迁移沉淀下来的经验与需求矩阵又会反哺后续需求,使任务越做越快,最终形成迁移飞轮。

    状态落盘

    复杂的迁移长任务中,会话中断、上下文压缩和验收返工都很常见。流程进度如果只保存在对话中,中断后只能依赖Agent回忆,容易续接错位置,也可能把已确认的结论当作新需求重做。因此,流程推进过程中,各阶段进度、产物的位置和待确认事项等都会实时写入状态文件,对话本身不承担记录进度的职责。

    中断恢复按固定优先级进行:先处理中断前待用户确认的事项,再处理未通过审查的方案,最后继续未完成的执行。恢复前先校验状态文件本身:结构损坏、产物缺失这类不可用的状态直接停止恢复,报出原因交给用户;只是写法不规范的仅做提示,不阻塞恢复;无法判定的一律请用户确认,状态不明时不继续执行。

    迁移飞轮

    鸿蒙端的迁移与生成需求会持续出现,不同需求之间常常遇到同类问题;同一需求拆成多个阶段推进时,前序阶段解决过的问题也可能在后续阶段再次出现。如果经验不能沉淀和复用,这些问题就会被反复处理,成本始终降不下来。因此,流程中设计了迁移飞轮,让每次任务沉淀的经验、模式与解法,在后续需求和后续阶段中持续复用。

    复用的前提是经验本身可信,错误的经验一旦被主动采用,会误导后续实现,危害比没有经验更大。因此,经验的入库与生效都按可信度分级管理。问题修复后,先判断它有没有沉淀价值,只有技术性问题才进入经验库。新入库的经验只作参考,经用户确认有效后才正式采用;在多个需求中重复出现且根因属于平台层约束的,固化为自动生效的平台规则。已有的经验也可以降级:验收中证实与实际不符的,降为参考,不再主动使用;被推翻或被更优方案取代的,标记为废弃,并保留记录供后续排查参考。

    △ 图 3-9 经验按可信度逐级升格的迁移飞轮

    除经验外,需求矩阵本身也会保留下来,用于后续复用。源端功能持续演进,如果每次都做全量重迁判断,已经核对过的行为点就要重新梳理。因此,每次迁移完成后,需求矩阵会和当时对照的源端版本一起保留;下次迁移只比对这个版本之后的源端变化,变化的部分增量重迁,没变的行为点沿用已有结论。这样,需求矩阵就不只是单次交付的核对清单,也成了可以跨版本复用的长期资产。

    △ 图 3-10 增量重迁

    GEEK TALK

    04

    端到端交付与实践

    第三章按四条标准分别介绍了各项能力,本章把它们放回一次交付的实际顺序里。主流程依次经过七个阶段:项目探测、需求读取、需求澄清(含跨端参考)、规划、执行、验收、经验沉淀。对应到第三章的环节,前三个阶段属于理解,规划(含方案审查)属于规划,执行属于实现,验收属于验证,经验沉淀服务于持续推进。

    阶段的先后由数据依赖决定:需求澄清产出模式判定和基线来源,迁移模式下在此梳理出行为基线;规划把行为点分配到各个阶段,产出任务清单和需求矩阵;执行按任务清单落代码,同时记下源端与鸿蒙的对应关系,以及无法迁移的条目;验收再对照行为基线逐点核对。缺了上一步的产物,下一步就没有输入,所以阶段不能跳过,也不能调换顺序。

    方向性决策集中在需求澄清确认、方案确认和最终功能验收三处,由用户裁定;高成本手段的授权、无法迁移项的处理等确认按需发起,其余阶段由Agent默认自动推进。验收不通过就退回执行修复,修复后重新验收,通过后才推进下一阶段。

    △ 图 4-1  端到端交付流程

    4.1 案例:随听频道迁移

    把这套机制放到一次迁移中检验:以iOS端的源码实现为基线,将随听频道「听音乐 / 听军事」功能迁移到鸿蒙端。整个过程记录在一张需求流转单上,从范围圈定、拆解、落地到最终验收,每一步都可回溯核对:

    △ 图 4-2 随听迁移的需求流转单

    迁移首先确定本次要交付的6条需求,再对照iOS实现逐条梳理,得到52个行为点和17条验收标准,覆盖正常流程、分支、边界和异常情况。范围确定后,按复杂度纵向拆分为6个可独立验收的阶段、30个任务,逐个推进。整个迁移跨越多个会话,中途多次中断,每次都依据流转单和落盘状态从断点继续。

    落地阶段,每个行为点都要对应到代码,并在流转单上注明与源端的关系。多数行为点与源端行为等价,只是实现路径不同;少数需求本身要求与iOS表现不一致,这类行为点按需求覆盖源端,依据记录在单上,不计为漏迁。鸿蒙缺失的能力另行设计等价实现,折叠屏、平板等形态同步适配。最终,52个行为点全部有明确结论:46个行为等价,5个注明理由后主动排除,1个经用户确认后显式放弃。这一结果由验收规则保证:任一行为点没有结论,验收即被阻塞并退回执行。

    验证按成本分层推进。12个设备套件、65条用例,每条用例都绑定到具体的需求、验收标准和行为点;纯逻辑层有部分用例受测试环境限制没能运行,折叠、平板等形态由人工确认。下面是真机层的运行录屏,Agent 在真机上驱动用例执行,并留存截图和日志作为运行证据:

    分层验证拦截了单次跑通无法发现的问题。同一回调上的同类缺陷先后出现三次,分别由真机用例和独立审查发现并修复,最终沉淀为一条经验:同一时机触发的处理逻辑须收敛到一处统一执行。 另有一个真机套件的通过结果被证实取决于测试素材的时长,而非被测行为,该套件随即被下调可信度,不再计为可靠通过。验收时,6个阶段全部通过,每条需求和验收标准都能对应到代码证据与运行结果;未完成的部分与通过项一并写入验收报告,前文介绍的行为基线、需求矩阵对账、分层测试和状态落盘等设计都来自类似的真实迁移:先在实践中发现问题,再逐步总结推理建设对应的机制,并在后续实践中进行验证。

    △ 图 4-3  随听迁移最终验收报告总览

    4.2 能力边界

    需要明确说明的是,基线之外的遗漏无法完全排除,只能靠交叉核查和真机验证尽量压低;时序、并发和线上实验实际命中的分支,静态分析判断不了,只能留给真机验证;功能好不好用、体验好不好,门禁判断不了,要靠人工验收。

    GEEK TALK

    05

    结语

    AI Coding时代,编码已不再是交付的瓶颈,但是交付是否达标却不能交由模型主观判定。为此,流程把这一判定拆成可客观检查的规则:行为点逐条给出结论,结论逐条附上运行证据;门禁未能执行的不计为通过,偶然通过的用例下调可信度。模型负责产出,判定交给流程。

    这一思路不只适用于鸿蒙迁移,只要预期行为能逐条列出、结果能逐条核对,同样的做法也适用于其他端和其他类型的需求。

    跳转微信打开

    我们放弃了"全自动生成代码" —— 网盘 Coding Agent 落地与迭代实录

    2026年10月13日 18:00

    原创 欢迎关注的 2026-10-13 18:00 上海

    网盘团队放弃"一键生成代码"的全自动流水线,转向人机多轮的 Agentic Engineering Loop:先澄清需求、再分轮验证,让每次交付都可检查、可回溯。

    。图片

    点击蓝字,关注我们

    图片

    作者 | 三石

    导读 

    introduction

    "全自动最大的风险,不是它会犯错,而是它错了还在自信地往前跑。"网盘团队在把 Coding Agent 接入真实研发链路后,彻底想明白了这句话:流程能从头跑到尾,不代表跑出来的东西是对的。本文作者复盘了他们从"一次性全自动流水线"转向 Agentic Engineering Loop(人机多轮反馈循环)的完整过程——执行前先做需求调研、把不确定项挂账;执行中分轮验证、过程全程可观测;人、Agent 与工程工具各司其职。这不仅是技术方案的迭代,更是对"自动化与可控性如何平衡"的工程思考。

    全文 3693 字,预计阅读时间 4 分钟

    从一次性全自动,到人机多轮的 Agentic Engineering Loop,我们为什么要这样改

    GEEK TALK

    01

    流程能跑通,不代表结果是对的

    网盘很早就在探索 Coding Agent 怎么融入"需求进、代码出"的研发链路,也搭了一套从需求分析到质量检查的自动化流程。可一旦接上真实的迭代需求,问题就来了:流程能从头跑到尾,不代表跑出来的东西是对的。

    有的需求做到一半,被还没就绪的服务接口卡住;有的任务把所有阶段都走完了,代码却建在一份没人确认过的需求理解上。等到验收才发现对不上,只能回头返工,改规格、改设计、改实现。更麻烦的是,过程记录一旦不全,连偏差最早是在哪一步跑偏的都说不清。

    慢慢我们想明白:能不能生成代码,其实不是最难的;难的是让它在真实、复杂、一直在变的研发环境里,靠可靠的上下文把活干对。早期做法太指望每个阶段的输入都完整、都可靠,可现实里的需求、历史知识和外部依赖,往往都带着没确认的部分。流程得有本事把这些不确定性先认出来,再处理掉。

    最初的五阶段流程

    原来的流程按需求规格、技术设计、任务拆分、代码生成、质量检查一路往下走,每个阶段自动接住上一阶段的产物,中间没有专门确认关键假设的节点。

    问题在于:只要上游产物里混进了没验证的判断,这种一路传递就会把偏差带到后面。

    GEEK TALK

    02

    真实迭代里暴露的七类问题

    把踩过的坑摊开看,大致是两类:一类出在执行过程——看不见、也难追溯;另一类出在任务输入——信息和依赖条件不够。

    执行过程:信息越堆越多,出了问题却难定位

    上下文堆起来之后,关键事实反而更难保持一致。一个任务要穿过好几个阶段,原始资料、中间结论、临时推断不断往上叠。我们碰到过字段引用错、接口判断失准,也碰到过把早期的推断当成确定事实继续用。光是把上下文喂得更多并不解决问题,还得把事实、约束和待确认项分清楚。

    偏差一旦出现,往往缺少定位的抓手。运行记录只留了各阶段的结果,排查的人很难还原:当时到底用了哪些输入、做了哪些判断。结果常常只能扩大排查范围,或者干脆把流程重跑一遍,排查和返工的成本都上去了。

    执行状态也没有一个统一的视图。任务进度、卡在哪、质量检查结果、模型资源消耗,分散在各处,研发同学很难及时判断该不该介入,团队复盘也没有一个共同的依据。

    任务输入:需求、经验和依赖都还不到位

    需求描述常常有歧义。一句话需求,或者一份不完整的产品文档,可能既没写清业务口径,也没覆盖异常分支和验收标准。要是 Agent 自己把空白补上,而后面的设计和测试又都沿用这同一套理解,就会出现实现和测试彼此自洽、却整体偏离业务目标的情况。

    存量经验还没显式化。历史代码为什么这么设计、有哪些兼容要求、团队有哪些约定,有一部分还装在研发同学脑子里。Agent 拿不稳这些知识,写出来的实现可能局部逻辑没错,却漏掉了系统长期演进中沉淀下来的约束。

    知识图谱的覆盖也还不全。自动检索能补上下文,但结果受制于知识覆盖面、更新是否及时、关联关系是否完整。没检索到相关约束,不等于约束不存在。

    外部依赖会直接把执行卡住。部分接口还没就绪,或者状态不稳定,流程就没法做真正的验证。原来的实现缺少足够的暂停、恢复和替代验证手段,一处局部阻塞,很容易拖累整条链路。

    这些问题最后都指向同一件事:全自动流水线把"不确定"当成"确定"一路往下传,而错误偏偏会在最贵、最靠后、最难定位的地方才冒出来。

    全自动最大的风险,不是它会犯错,而是它错了还在自信地往前跑

    GEEK TALK

    03

    重新划分人、工具和 Agent 的分工

    对着这些问题,我们重新界定了确定性工具、Agent 和研发人员各自管什么。

    路径、分支、编译、校验、日志上报这类有明确规则可查的事,交给脚本和质量门禁去做,省得每次任务都重复判断一遍。当然,这些检查结果也受规则本身是否正确、测试覆盖够不够、执行环境稳不稳定的影响,不能拿来当完整的业务验收。

    而需求口径、方案取舍、历史兼容、体验好坏这些要结合业务背景拿主意的事,还得人来定。Agent 可以把证据理清楚、把候选方案摆出来,真正有分歧的地方交给对应责任人拍板。人只在重要决策节点上介入,范围清楚的常规执行还是自动往前推。

    在这个基础上,我们把一次性执行改成了多轮反馈:每一轮围着一个明确目标做修改和验证,再决定下一步怎么走。

    这就是我们从一次性全自动流水线,转向 Agentic Engineering Loop 的起点。

    GEEK TALK

    04

    Agentic Engineering Loop:把一次性执行改成多轮反馈

    新的工作方式我们叫它 Agentic Engineering Loop——人机协作的工程反馈循环。它保留了规格驱动开发(Spec-Driven Development,SDD)的核心思路:先把目标、约束和验收标准定清楚,再去组织实现和验证。

    任务进来,先理解需求、确认方向,然后围着"观察—决策—修改—验证—复盘"转:看当前的代码和反馈,定下这一轮要达成什么,在边界内动手改,跑对应的检查,再根据结果决定下一轮。等满足验收条件,交给研发人员反馈确认,这才算交付完成。

    和原来的做法比,变化主要在这几处:

    需要说明的是,这里变的是工作的组织方式,并不是说"循环天生就比流水线好"。一条完善的流水线一样可以有反馈、有可观测;反过来,换成主 Agent 来协调,也不会自动把长上下文的问题解决掉——事实来源、任务边界、每一轮需要哪些信息,这些照样得管。

    GEEK TALK

    05

    循环之前,先把需求打磨成可验证的起点

    多轮反馈要真起作用,得先有一个能讨论、能验证的起点。输入里的关键歧义要是没澄清,循环也可能围着一个错误前提反复打转。

    所以我们在执行前加了一道需求调研:研发人员借助调研工具,把业务描述整理成目标、工程约束、改动范围和验收标准。

    调研不只是梳理文字,还要去对真实实现:找到相关的文件和调用关系,顺着提交历史理解当初为什么这么设计,核对可能的原因,划清楚哪些范围要改、哪些行为必须保持不变,再拆成一个个能独立验收的单元。需求、验收标准和改动计划各自编号,方便在实现和验证时一一对上。

    这样做,能在动手之前就把需求歧义和知识缺口暴露出来。研发人员负责把业务目标和现有系统的约束对齐,Agent 则在这些划好的边界里继续分析和执行。暂时确认不了的信息,就先挂成待确认项,而不是直接当成实现前提写进去。

    GEEK TALK

    06

    让执行过程看得见、可回溯

    为了能及时介入、事后也能复盘,我们把执行过程接进了一个统一的观测视图。

    本地执行通过上报机制,把每一轮的事件、指标和迭代记录汇到远端平台,整理成运行、任务、事件、产物这些结构化记录。"SDD 运行记录"看板就靠这些数据,展示任务阶段、执行耗时、token 消耗与成本、质量门禁结果,还有上下文占用等信息。

    这些记录在三个层面上帮到我们:

    • 执行过程落进日志和看板,复盘时每一步都能回看;

    • 交付结果沉淀成产物和报告,出了问题能追回源头;

    • 记录攒下来形成趋势,慢慢就成了团队的经验资产。

    看板给了我们一个理解任务过程的入口。但真要复盘,还得结合记录是否完整、验证覆盖到哪、具体产物是什么,把执行完成、检查通过、业务验收通过这三件事分开看,别拿其中一个状态当成交付结论。

    GEEK TALK

    07

    现在走到哪一步,接下来做什么

    这套工作方式已经用进了网盘的日常研发。下面说说目前攒下的能力和还没解决的问题——这里讲的是能力建设的进展,不等于已经量化验证过的效率收益。

    已经跑起来的环节

    • 需求进循环之前,先做一遍证据化的成熟度打磨;

    • 把一次性全自动,改成了人机多轮、随时能停下来纠偏的循环;

    • 执行过程能上报到平台、看得见,也能回头复盘。

    还没解决的问题

    • 需求相关的知识图谱覆盖还不全,Agent 自己检索上下文的能力也被这个卡着;

    • 一部分依赖的服务接口后置,仍是瓶颈;

    • 把存量经验沉淀成能复用的能力(Skills),还在慢慢攒;

    • "自动化程度"和"可控性"之间的平衡点,也还在不断调。

    GEEK TALK

    08

    结语:从"生成代码"到"可验证的交付"

    这次调整,把我们的关注点从"生成一次代码"拉到了整个交付过程上。需求理解得准不准、改动有没有越界、验证能不能撑住结论、出了问题能不能回溯——这些才是自动化能不能真正发挥价值的前提。

    需求确认、分轮验证、过程记录这些确实会多花一些功夫,值不值得,得放到完整的交付周期里看。接下来我们会结合不同的任务类型,持续盯着人工介入、端到端耗时、返工和验收结果,看看这些机制在不同场景下到底带来多少收益。

    对网盘团队来说,这次迭代也把人、Agent 和工程工具的协作关系理得更清楚了:

    Agent 负责组织分析和执行,工程工具落实那些能被检查的规则,研发和业务责任人确认关键的取舍与验收结果。

    这条路我们会继续走下去:让生成的代码更容易被检查,让执行过程更容易被看懂,也让每一次交付都留下一份清晰、可复查的依据。

    跳转微信打开

    国庆免费领!

    2026年9月30日 12:00

    原创 欢迎关注的 2026-09-30 12:00 上海

    国庆福利来啦!多档好礼免费领,关注百度Geek说,后台回复【国庆活动】即可参与🎁

    。

    点击蓝字,关注我们

    🇨🇳 国庆假期要到了!

    假期除了出门玩、宅家休息,
    也别忘了来百度Geek说领一份国庆福利🎁

    这次准备了多档好礼,
    免费参与,就有机会把心仪奖品带回家!

    存一些可爱的表情包

    🎁 国庆好礼,等你来领

    🏆 惊喜大奖
    小度智能屏 X10-第二代1台 共1份
    价值约800元

    🎉 特等奖
    小度智能音箱-大金刚1个 共2份

    ⌨️ 一等奖
    度熊键鼠套装-度熊形象系列1套 共4份

    💳 二等奖
    京东卡100元1张 共3份

    💳 三等奖
    京东卡50元1张 共5份

    💳 四等奖
    京东卡20元1张 共5份

    从智能好物到实用京东卡,
    总有一份适合你的国庆惊喜✨

    表情包-狗

    参与方式:

    关注百度Geek说微信公众号

    后台回复“国庆活动”即可参与

    跳转微信打开

    1.395元复现Jev原型:百度千帆Token Plan最佳实践

    2026年9月23日 18:00

    百度Geek说 2026-09-23 18:00 上海

    2026年9月,TypeSafe AI发布了“System One Model”——Jev,随即引发热议。

    。

    点击蓝字,关注我们

    2026年9月,TypeSafe AI发布了“System One Model”——Jev,随即引发热议。Jev不生成文本、不进行自回归解码,而是通过单次前向传播直接输出带校准概率的结构化决策,支持并行采样,响应时间可达70毫秒。相比“生成文本—解析—验证”的传统路径,这种方式为分类、路由、审核等自动化场景提供了一种新思路。

    百度千帆Token Plan致力于帮助开发者以更低、更可预期的成本搭建Jev原型、验证技术方案。我们用Opencode在llama.cpp里复现Jev的核心机制,把“单次前向传播做结构化决策”变成400行C++。而这段“把理念变成现实”的完整旅程:读懂概念、翻遍源码、编译调试、撰写成文,全部由AI自主完成。这次验证基于百度千帆Token Plan个人版,共消耗313.9积分,折合的总花费是:1.395元。

    最佳实践总览

    图片

    整个开发流程由Opencode(以Token Plan个人版中的DeepSeek-V4-Flash为基座模型)自主完成,Token Plan覆盖了全部token消耗。

    1.1 开发全流程

    图片

    关键数字:313.9积分,1.395元。

    1.2 为什么Token Plan适合AI开发

    AI开发不是一次调用,而是反复试错的迭代过程。探索代码库时AI读了几十个文件,其中很多与最终实现无关。调试时跑了好几轮编译,第一次因为对API理解错误而失败重来。写文章反复修改了好几版。

    这些“浪费”在按量计费模式下会让人心疼——用GPT-4o光是试错就可能花掉20多元。但在百度千帆Token Plan下,所有试错成本加起来才1.395元。

    预付200元,45000积分随便用。不需要盯着消耗计数器,不需要在每次调用前犹豫“值不值”。放手让AI去探索、去犯错、去修正——这才是AI辅助开发的正确姿势。

    实现了什么?

    图片

    2.1 工作概述

    本次在百度千帆Token Plan支持下,AI(DeepSeek-V4-Flash)核心完成了一项针对推理底层机制的改造成本验证:将传统的“文本生成”模式改造为“单次前向传播的结构化决策引擎”。

    2.1.1 攻克核心差异与机制改造

    • 传统LLM模式:对复杂多问题场景需要“逐字生成→提取文本→正则解析”,速度慢且极易出现格式崩塌。

    • Jev决策机制:打破自回归生成,将5个业务问题打包在一个Batch中,直接对每个序列最后一个Token的Logits进行Softmax提取,无需生成任何文本,仅凭单次llama_decode()就同时完成全部推理与概率校准,响应时间缩短至70ms级。

    AI深入源码库,在llama.cpp中精准定位并编写了约400行C++核心代码,修复了多序列logits位置索引偏移等调试硬骨头,成功在开源大模型上调通了这一机制。

    2.1.2 实现标准化的输入与结构化输出

    改造后的引擎具备了极高的工程实用性,实现了输入与输出的标准化解耦:

    输入:标准JSON配置,输入当前场景状态(如“客户退款、包装损坏、3年老会员”)及待决策的多个问题列表。

    输出:结构化JSON,一次性返回所有问题的决策选项(如escalate / refund)以及对应的置信度概率分数(Confidence)。

    (注:整个机制改造与源码调试过程经历了多轮报错与重新编译,全部由AI自主完成,而Token Plan让人完全无需担忧试错成本。)

    2.2 实测结果

    用Qwen3-0.6B-Q8_0.gguf,输入客服场景(客户退款、包装损坏、3年老会员),同时回答5个问题:

    图片

    5个问题,1次推理,0次字符串生成。每个决策附带概率分数,软件可以直接消费。温度从0.8降到0.3,action的deny置信度从62.5%飙升到89.4%——温度越低模型越自信。

    但需要明确:置信度不等于准确率。置信度反映的是模型对自身输出的确定程度,温度调低只是让分布更尖锐,模型自然显得更“自信”,但这不意味着答案更可能正确。本次测试没有标注好的测试集,无法计算准确率。从结果表现看,客服场景中“流失风险”和“优先级”这类有明确信号的问题,模型在合理温度下给出的决策方向符合直觉;而“客户情绪”这类主观判断,模型的置信度偏低(55.9%),这个低置信度本身是有意义的信号——它在告诉下游系统“这个判断不太确定,建议人工复核”。这正是结构化概率输出的价值:即使答案不一定对,软件也能根据置信度做路由决策。

    2.3 与Jev原版的差距

    图片

    Jev从模型架构和训练方法(RLCD)层面支持结构化决策。我们是在现有LLM上模拟。但核心机制——单次前向传播、并行决策、概率输出——已经跑通。而验证这个理念是否可行,只花了1.395元。

    与Agent交互的

    Prompt实践

    图片

    整个开发过程不是一句话指令“帮我实现Jev”就完事,而是分阶段的、有结构的对话。下面还原关键的交互流程和Prompt思路,供其他开发者参考。

    3.1 整体交互流程

    图片

    3.2 关键Prompt实录

    第一步:确认开发基础(概念)

    不要只说“实现Jev”,而是给出全部素材和明确的三步目标:

      请你基于[博客HTML路径]和[GGUF模型路径]实现jev模式推理
      我希望你:
      1. 梳理路径
      2. 修改llamacpp实现jev

      关键点:同时给出博客原文(Agent需要自己理解Jev是什么)和模型文件路径(Agent需要知道用什么模型)。明确交付物。Agent会自行抓取博客、探索代码库、确定实现方案,不需要逐步指导。

      第二步:验收

      Agent说“完成了”之后,不要直接接受。需要指定验收标准:

        请基于下述场景,进行测试:客户xxxx,客户情绪是 A B C D。

        这一步的意图是:用一个业务场景(客服情绪分类)测试Agent的输出是否真的可用。结果确实暴露了问题——0.6B小模型上label-token方式的概率接近随机,所有选项置信度都在0.25左右。Agent被逼着去解决位置偏好问题,最终实现了排列去偏和continuation scoring两种方案。

        第三步:结果纠偏

        拿到测试结果后,对技术结论做纠偏:

           反馈1: 零幻觉和高置信度jev是无法保证的,jev只是保证输出类型安全
           反馈2: 温度越低置信度自然越高,但置信度不等于准确率,没有测试集无法计算准确率

          这是最重要的交互——人对Jev的理解比Agent更准确。通过人工复核修正Agent撰写的结果,从而使得整个结论更加合理可靠。

          3.3 Prompt经验总结

          图片

          核心原则:Agent负责执行,人负责判断。Agent能快速读几十个源文件、写几百行C++、编译调试,但技术结论的准确性需要人把关。特别是“零幻觉”“校准概率”这类概念,Agent从博客原文照搬,但工程上需要更精确的表述。

          百度千帆Token Plan

          让探索性开发成本趋近于零

          图片

          用Opencode(以Token Plan个人版中的DeepSeek-V4-Flash为基座模型)在llama.cpp中复现Jev推理模式,将自回归LLM改造为并行决策引擎。1.395元即可完成一次从论文阅读、代码实现到文章撰写的完整开发周期;200元的Token Plan套餐,足够跑143次类似任务。

          图片

          Jev模式的核心洞察是:很多AI应用需要的不是文本生成,而是结构化决策。传统LLM通过“生成文本->解析->验证”的迂回路径实现决策,Jev模式直接从logits提取决策概率,跳过了字符串生成和解析的开销。需要强调的是,Jev保证的是输出类型安全——答案一定在预定义选项内,但答案本身是否正确仍取决于模型能力。置信度也不等于准确率,它只是模型对自身判断的确定程度。真正有价值的是:软件可以根据置信度做路由,低置信度的问题转人工,高置信度的问题自动处理。

          而百度千帆Token Plan的价值在于:它让这种探索性开发的试错成本趋近于零。1.395元验证一个前沿AI理念是否可行——不需要几万元的API预算,不需要纠结每次调用的花费。放手让AI去探索,这才是Token Plan的意义。

          如果你也想用1.395元这样的成本,去验证一个自己感兴趣的技术想法,那这次实验里用到的百度千帆Token Plan个人版,可以直接上手。

          它是面向个人开发者与AI重度用户的大模型订阅服务,定位是“个人的AI算力流量包”,一份订阅、一个额度池,覆盖AI Coding、Agent构建、智能问答、内容生成、学习研究等场景。

          图片

          跳转微信打开

          Agentic Harness Workflow 框架:把 AI Coding 变成工程化流程

          2026年9月10日 18:00

          原创 欢迎关注的 2026-09-10 18:00 北京

          AI 编码的工程化实验:把开发拆成固定流水线,每阶段由专职子代理执行、主代理把关,配合状态落盘与人工门禁,让 AI 写代码从"碰运气"走向"可交付"。

          。图片

          点击蓝字,关注我们

          图片

          作者 | 李忠泽

          导读 

          introduction

          把整段需求直接丢给 AI 写代码,结果越写越偏、中途断了还接不上?本文作者给出的答案是:别去造更聪明的 Agent,而是给 AI 编程套上一副"工程框架"。他自研的 Agentic Harness Workflow,把一次开发拆成需求澄清、方案设计、编码实现、审查验收、提交归档等阶段,每阶段交给一个只干一件事的子代理,由主代理统一调度把关,关键节点留人拍板;配合状态落盘,中断、换人、换工具都能无痛续跑。文末还附上了完整实战复盘与踩坑清单。

          全文 8019 字,预计阅读时间 6 分钟

          GEEK TALK

          01

          为什么需要 Harness

          相信大多数开发者都亲身体会过,如果把一个真实需求一次性丢给一个长上下文 Agent,会面临如下几个问题:

          1. 上下文膨胀与结果漂移:需求、方案、代码、测试、日志全堆在一个上下文里,越到后面它越容易忘了前面说好的约定,慢慢偏离你最初想要的东西。

          2. 跳过必要的工程步骤:Agent 可能直接写代码,遗漏需求澄清、方案评审或测试设计。

          3. 过程不可恢复:会话被压缩、重启或中断后,很难可靠判断“现在在哪一步、正在等待什么、哪些任务已完成”。

          4. 自动化过程缺少人工门禁:没有明确的门禁和人工确认点,错误方向可能一路运行到最后,之后返工会消耗更多的人力。

          所以我的思路是,不是"再造一个很聪明的 Agent",而是给 AI 编码套一副"工程框架"——把一个需求从提出到归档拆成一条固定的流水线,每个阶段交给一个只干一件事的 Sub-Agent,主会话 Agent 负责调度、管状态,并在每个要紧的地方停下来等人拍板。

          GEEK TALK

          02

          三类应用拓扑对比

          从概念上来讲,目前有如下三种结构:

          我设计的这套 Harness:Workflow 为主,阶段级 Multi-Agent 协作,并保留 Human-in-the-loop。

          注:这里并不是真正意义上的 Multi-Agent,只是目前 Coding Agent 工具,比如 Claude Code、Codex 等自带的 Sub-Agent 能力。

          GEEK TALK

          03

          总体架构

          3.1 一条完整的生命周期

          一个需求沿固定顺序推进:

            init → specify → plan → tasks → test-plan → plan-review
              → implement → code-quality → e2e-run → human-acceptance
              → commit-push → archive 

            其中,implement → code-quality → e2e-run 是自动执行区;其余大多数阶段在完成后会停下来等待用户确认。human-acceptance 和 archive 没有独立 Agent,由 Manager 负责呈现、验收和收尾。

            3.2 CLAUDE.md:框架入口与项目知识库

            CLAUDE.md 在这套框架里承担两件事:一是框架的入口,二是项目知识库。

            一、框架入口。 Coding Agent 在会话开始时会自动加载 CLAUDE.md,这是整条链上唯一会被"自动"读到的文件。所以它本身不写任何流程逻辑,只做三件事:点明阶段流程、指向三份规则文件(流转表 state-graph.json / 通信协议 protocol.md / 状态字段说明 state-schema.md)、以及最关键的一句——主会话必须始终遵循 .harness/rules/manager.md。Manager 的行为准则、状态机字段含义、阶段次序,全都在那几份文件里;CLAUDE.md 只负责把它们挂上来,harness 就算 Ready 了。

            二、项目知识库。 Harness 本体是通用的,但它跑在什么项目上是特定的——有哪些代码库、怎么起服务、连哪个测试库、提交要建什么卡、代码库之间谁依赖谁。这些"项目事实"全部登记在 CLAUDE.md 的知识库索引里,目前分四块:

            这里有一个约定:只有Manager读 CLAUDE.md,所有Sub-Agent一律不自己读。 Manager 按当前需求的相关性,从知识库里挑出需要的片段,通过 input 的具名字段下发——比如把环境表相关内容装进 environment_knowledge 给 e2e-run,把建卡空间装进 icafe_space 给 commit-push,把文档链接装进 knowledge_refs 给 plan。

            这么设计有三个好处:

            1. 不让每个 Sub-Agent 都把整个知识库吞进上下文——它只拿到与自己这一步有关的那几行;

            2. Sub-Agent 保持通用——它只认 input 里的字段,不认某个项目的具体布局,所以换个项目只需要换一份 CLAUDE.md,agents/ 和 rules/ 一行都不用动;

            3. 知识变更只改一处——新增一个代码库就在表里加一行,不用去改十个 Agent 文件。

            还有一条是被实际测试坑出来的原则:不假设、缺就问。 不同代码库的配置位置和形态可能完全不一样(我们这里有一些服务的配置是在 conf/servicer/*.toml,但那不是通用规则)。某种意义上,CLAUDE.md 就是知识层插件:rules/ 是骨架、agents/ 是阶段,都是通用件。

            3.3 调度者:主会话 Manager

            这个 Harness 的核心是主会话 Manager。它一个人分饰三个功能:

            • 调度——决定这一轮该派哪个阶段的 Sub-Agent 执行,是往前走还是往回退。

            • 状态管理——它是唯一有权写 workflow-state 的人,也负责把需求在"进行中 / 挂起 / 已归档"几个目录之间搬来搬去。

            • 对话输出——Sub-Agent 只跟它用结构化协议对话,你只跟它用自然语言对话,两边的话都由它来转。

            Manager 有一条我设计的铁律:它只认 Sub-Agent 回传的那个结构化协议,不读任何产物的正文(spec、方案、任务、测试、报告),也不读业务代码。 它只从协议里取"结论"(通过 / 打回 / 要你确认),从状态文件里取"进度"。

            因为 Manager 从不把一堆产物正文和代码吞进自己的上下文,主会话才能在一个需求走完十几个阶段、来回折腾很多轮之后,仍然是轻的、稳的、不飘的。你要是问它"刚才那条结论为什么这么判",它也不会自己去翻代码回答你,而是把问题重新丢回给当初给出这个结论的子代理,让它来解释。

            这里的调度不是单靠 Manager 自己的理解,我们把状态之间的流转设计成了一张“图”,存放在了state-graph.json,这样 Manager 就很清楚的知道下一个阶段该是什么,并且每一个后置的阶段都可以回退到上一个阶段,这里是通过 Sub-Agent 的“建议”,以及 Manager 对于用户输入的理解判断,共同决定。

            3.4 执行者:阶段 Sub-Agent

            每个 Sub-Agent 有一个独立的 Agent.md 文件来控制这个 Sub-Agent 是做什么的。而每个阶段干什么、产出什么,列个表:

            每一个阶段都会通过定好的结构化输出协议来和 Manager 进行通信,Manager 会将 Sub-Agent 的输出整理呈现给用户,Manager 不用去读取每个 Sub-Agent 的阶段产物,只需要 Sub-Agent 定好一个对人可读性友好的输出即可。

            而且这里有一个小设计,就是将“裁判员”和“运动员”分开设计,不让 Agent 自己设计自己评估,分成两个阶段 plan 和 plan-review,由一个 Sub-Agent 进行技术设计,另外一个 Sub-Agent 进行评估,整体设计参考了对抗性的思想,但凡涉及到审查的环节(比如技术设计、测试),都需要挑战设计中的假设,而不是确认正常流程能跑通。

            3.5 状态机:workflow-state

            流程状态不依赖聊天记忆,而是落在每个需求目录的 workflow-state.json 中。最重要的字段包括:

            • current_state:当前阶段;

            • pending:当前等待点,例如等待前进确认、澄清、回退确认、人工验收、推送确认或 CR 评审;

            • states:阶段历史、状态和产物路径;

            • review_findings:门禁发现的问题及其应跳转的阶段;

            • loop 计数、涉及仓库、验收服务等运行数据。

            其实这个设计思想就是,我们不应该让 Agent 完全依赖本身自己的上下文记忆,应该有一个 Handoff 机制,我举个例子,如果你当前在用 Claude Code 做到某一个阶段,接下来由 Codex 接手,如果 Codex 不具备 Claude Code 的记忆,那么他其实并不知道当前执行到哪里了,而且尽管在同一个 Coding Agent 内部,如果他的上下文压缩了、Memory 清空或者开了一个新的会话,都可以继续接手执行。

            那么整体的交互如下:

            3.6 协议:protocol

            Manager 与每个阶段 Sub-Agent 之间只使用一个协议对象,它是一个双向协议:派发时由 Manager 填请求侧字段,返回时由 Sub-Agent 返回响应侧字段。两侧共用同一套字段约定。

              {
                "state":        "派给哪个阶段(Manager 填)",
                "user_message": "用户这一轮的原话(Manager 填)",
                "input":        { "本阶段所需上下文(Manager 填)": "..." },
                "status":       "ok | needs_input | fail(Sub-Agent 填)",
                "output":       { "结构化结果(Sub-Agent 填)": "..." }
              }

              逐个说明:

              注:protocol.md、各阶段模板、业务代码,都是 Sub-Agent 自己读的,不由 Manager 传。

              3.6.1 请求侧:input 

              各阶段的input专属 Key 是提前定义好的,这也是"Sub-Agent 保持通用"的关键:

              请求侧三个字段:state 是派给哪个阶段,user_message 是用户原话逐字透传,input 是这一阶段需要的上下文。input中每个阶段的 Key 由 manager.md 的调度规则定义。

              而且协议里有三个通用可选 Key,只在特定情形出现:

              3.6.2 响应侧:status  + output 

              响应侧只有三种 status:

              • ok —— 这一阶段做完了,等用户确认后前进;

              • needs_input —— 没做完,需要人介入(多轮澄清、环境卡住、或要回退到上游补东西);

              • fail —— 阶段失败,output.next_state 给出建议打回的目标(比如 e2e-run 不过 → implement)。

              output 里有四个通用字段(几乎每个阶段都有),加上各阶段自己的小字段:

              个别阶段的output也有自己的专属 Key:

              注:响应侧的信息会包装在一个control-result里面,这是让阶段 Sub-Agent 结构化输出,Manager 去解析的一个规则。

              3.7 执行到测试的 Loop Engineering

              之前 Codex 发布了/goal这个命令,实现一个需求,直到 Agent 做完它才会停止,后面也推出了 Loop Engineering 的概念,我的这里其实也参考了这个 Loop 的设计。

              Agent 可以自动连续完成“implement 写代码 → code-quality 静态审查 → e2e-run 跑系统测试 → implement 定向修复”,但自动化不是无限循环。我给每条自动修复的循环都设了次数上限,达到阈值后还没过,就停下来把问题呈现给用户,让用户三选一:继续修、直接放行、或者有疑问要阶段 Sub-Agent 解释。

              3.8 阶段回退:判根因、过门禁

              这套框架里所有回退都走同一套机制,不管触发它的是谁:

              1. 用户主动推翻上游(做到 plan 才想起需求说漏了);

              2. 下游 Sub-Agent 报出上游缺口(test-plan 发现 plan 没定义接口路由,写不出可执行用例);

              3. 门禁打回(plan-review 审出问题,指向最早出问题的那个阶段);

              4. 自动执行区的测试打回(code-quality / e2e-run 不过 → 回 implement)。

              人工验收不通过、或者 CR 评审有意见时,Manager 照一张固定的映射表判目标:

              回退的目标阶段必须在流转表 order 里位于当前之前,且在这个需求的历史里已经真正完成过。这防止"回退"变成乱跳。

              校验通过、用户确认之后,Manager 在同一次写入里完成状态转移:当前阶段落终态、目标阶段由"已完成"改回"进行中"、current_state 指向目标阶段,并把刚才那个回退原因作为 rollback_reason 放进目标 Sub-Agent 的 input,让阶段 Sub-Agent 知道这次回来要做什么、补什么。

              这里有个细节:等待用户确认的期间,当前阶段一直是"进行中",终态只在真正转移的那一次写入里才落到状态及文件。 "已完成"严格意味着"用户已经拍板、流程已经离开它",绝不在等确认的时候提前写。这是为了让冷启动恢复时状态永远是正确的,任何时刻至多一个阶段处于"进行中",且它必然等于 current_state。

              3.9 Human-in-the-loop:人需要确认的地方

              状态文件里有一个 pending 字段,它表示的是每个阶段都要停下来等人拍板,每一个类型都明确记着"在等什么、用户确认后去哪个阶段":

              GEEK TALK

              04

              从 Worktree 到验收:多需求如何具备隔离性的工作

              4.1 工作目录结构

              Harness 工作空间目录结构

                <工作目录>/                              ← 主会话(Manager)的 cwd
                │
                ├── CLAUDE.md                            ← 框架入口 + 项目知识库索引
                │                                          (环境表 / 研发流程 / 依赖顺序,Manager 从这读取作为 input 下发)
                ├── .mcp.json                            ← MCP 服务(Playwright,给 e2e-run 跑前端)
                │
                ├── .harness/                            ← ★ 框架主目录
                │   ├── rules/                           ← 规则与模板("插件"里的规则层,可替换)
                │   │   ├── manager.md                   ← Manager 规则(always active,主会话必遵守)
                │   │   ├── protocol.md                  ← 通信协议(协议结构 + message 话术规范)
                │   │   ├── state-schema.md              ← workflow-state.json 字段与状态置位时机
                │   │   ├── state-graph.json             ← 流转表:order(阶段次序)+ next
                │   │   ├── spec-template.md             ← ↓ 各阶段产物模板
                │   │   ├── plan-template.md
                │   │   ├── tasks-template.md
                │   │   ├── test-plan-template.md
                │   │   ├── plan-review-template.md
                │   │   ├── code-quality-template.md
                │   │   └── e2e-run-template.md
                │   │
                │   ├── active/<index>-<slug>/           ← 正在做的需求,全局至多一个
                │   ├── process/<index>-<slug>/          ← 已开始、挂起的需求
                │   ├── archived/<index>-<slug>/         ← 已完成归档的需求
                │   └── worktrees/<index>-<slug>/        ← 本需求的 git worktree 根
                │       ├── <仓A>/                       ← 每个涉及仓一个子目录(implement 在此施工)
                │       └── <仓B>/
                │
                ├── .claude/
                │   ├── agents/                          ← ★ 阶段("插件"里的阶段层,加/删/改即改流程)
                │   │   ├── init-agent.md
                │   │   ├── specify-agent.md
                │   │   ├── plan-agent.md
                │   │   ├── tasks-agent.md
                │   │   ├── test-plan-agent.md
                │   │   ├── plan-review-agent.md
                │   │   ├── implement-agent.md
                │   │   ├── code-quality-agent.md
                │   │   ├── e2e-run-agent.md
                │   │   └── commit-push-agent.md
                │   │                                    ← human-acceptance / archive 无 agent(Manager 自己管)
                │   └── skills/                          ← ★ 可插拔能力("插件"里的能力层)
                │       ├── huibo-test-mysql/            ← 连测试库
                │       ├── huibo-test-redis/            ← 连测试缓存
                │       ├── icafe-card-assistant/        ← 建 iCafe 卡
                │       ├── icode/                       ← 建远程分支 / 推 CR
                │       └── get-ugate-token/
                │
                ├── <业务仓A>/                            ← 主仓(各自独立 git 仓;顶层不是 git 仓)
                └── <业务仓B>/

                单个需求目录(<index>-<slug>/)内部

                  .harness/active/<index>-<slug>/
                  ├── workflow-state.json                  ← ★ 状态文件(Manager 独占写)
                  │                                          current_state / pending / 各阶段 status /
                  │                                          repos / skip_gates / acceptance_services /
                  │                                          review_findings / 三个 loop 计数
                  ├── spec.md                              ← specify 产物
                  ├── spec_user_message.md                 ← 用户原话存档(抗上下文丢失)
                  ├── plan.md                              ← plan 产物
                  ├── plan_user_message.md                 ← 用户原话存档(抗上下文丢失)
                  ├── tasks.md                             ← tasks 产物(可勾选清单)
                  ├── test-plan.md                         ← test-plan 产物
                  └── reports/                             ← 审查与测试报告
                      ├── plan-review.md                   ← 惰性:只有打回过才产
                      ├── code-quality.md                  ← 每轮追加
                      ├── e2e-run.md                       ← 每轮追加
                      └── screenshots/                     ← e2e-run 前端 TC 的 Playwright 截图
                          └── TC-003-xxx.png

                  4.2 需求空间隔离

                  我们设计这个框架,本质是希望可以兼容多需求并行的场景,所以这里的设计是用了git worktree,在Implement阶段之前,Manager 根据 tasks 阶段产出的仓库集合,为每个业务仓建立同名特性分支和独立 worktree。实现、静态审查和 e2e 都复用同一 worktree;修复轮不重建,归档时才清理。这样就让多个需求之间完全隔离,我们的根目录下面,只需要有全部的代码库,而且每个代码库都及时同步 master 分支保证最新的代码,每个需求会根据当前最新代码新建git worktree,而且每个需求下都有自己的workflow-state.json及阶段产物。

                  这个设计有三个直接收益:

                  1. 主工作区不被临时产物污染;

                  2. 代码审查看到的是同一份改动,而不是每轮重新推导的快照;

                  3. 中断或回退后可以继续已有任务,已勾选的 task 不需要重复执行。

                  4.3 提交代码的依赖关系

                  commit-push 分为两段:

                  1. prepare:整理改动、建立 iCafe 卡、生成提交确认表;

                  2. execute:用户确认后才真正 commit、push 和创建 CR。

                  CR 评审由人工完成,Harness 只根据评审结果继续下一层或归档,不代替评审者合入主分支。归档阶段负责停掉验收服务、迁移需求目录、删除 worktree 和已合入分支。

                  多仓代码库一般会有一个公共库的设计,这样避免同一份代码文件散落到不同代码库中需要多份维护,所以我们在commit-push做了一个特别设计,我们的代码库依赖关系会写到CLAUDE.md,Manager 会把这部分内容带给commit-push ,commit-push会先提交依赖代码库的 CR,然后等待用户反馈是否合入(因为目前 icode CR 还需要人工 +2,或者如果有 Skill 能直接去 icode 拉取评分,这块可以改成自动化),合入了之后,会派发implement去修改其他代码库的依赖关系(比如go get xxx@latest),这里有一个设计就是在implement阶段加了一个可选 Key skip_gates,这样刚才介绍的“执行到测试的 Loop Engineering”  就可以只执行然后直接跳过测试(因为本身也存在一些自测需求或者小的改动,不需要进行复杂的 e2e 测试)。等这部分准备好后,commit-push 会继续提交其他仓的 CR。

                  GEEK TALK

                  05

                  DeepSeek Harness:"Everything is a Plugin"

                  DeepSeek Harness 是 2026 年 8 月开源的一套 Agent 框架(MIT 协议,命令行叫 dsh),它最核心的一句话就是 "everything is a plugin"(一切皆插件):模型、工具、技能、会话、沙箱、存储、循环、调度、连 UI,全都是可以随意替换的插件;甚至驱动每一轮对话的那个 agent loop 本身,也是一个能从配置里换掉的插件。它的哲学被总结成一句很妙的话——"从一个已经能用的完整 Agent 出发去替换零件,而不是从一堆零件出发去攒一个 Agent"。底层它还有一条 append-only 的会话日志,resume、fork、replay 都基于这条事件流。

                  在这几个月我逐渐研究 Harness Engineering 的时候,我觉得这个东西也应该是一个“框架”,如果这个 workflow 实现了,那么其中所有的“组件”,不管是需求澄清还是实现代码的 Agent 都可以被替换,用户也可以根据自己的设计添加 Hook、Tools、Skill 包括 CLAUDE.md,这些“组件”都可以根据业务自身去做定制化,包括这套设计,中间是一个极简、几乎不动的核心(Manager),外面的一切都是可以替换、可以定制的"文件插件"。

                  具体到能换什么:

                  • 每个阶段都是插件。 一个阶段就是一个 markdown 定义的 Sub-Agent 文件。你想改某个阶段的行为,就改那个文件;想加一个新阶段(比如插一道"安全审计"),就加一个 agent 文件、在流程表里排上;想去掉某个阶段,删掉就是。

                  • 能力(skill)是插件。 查库、连缓存、建 iCafe 卡、推 iCode CR、用 Playwright 驱动浏览器……这些都是按名字挂上去的可插拔技能。

                  • 规则和知识是配置。 通信协议、流程次序、状态字段、各阶段模板、以及项目知识库(哪些仓、怎么起服务、连哪个库),全是框架外的文件。流程次序想调整,就改流程表那个文件;换个项目,就换一份知识库,核心逻辑照旧。

                  • 进度也是可恢复的。 前面说的"状态全落盘",本质上和 DeepSeek 那条 append-only 会话日志是同一个诉求——让流程能被恢复、被接续。

                  当然也有不一样:DeepSeek Harness 是个通用的 Agent 运行时,连 agent loop 都能换;我这套是专门为"编码这件事的生命周期"定制的、带固定阶段流水线的 Harness。但在这条流水线内部,阶段、能力、规则、知识确实都是可替换、可定制的插件——Manger 极简、阶段技能皆可换,这一点是共通的。

                  GEEK TALK

                  06

                  一次真实的冒烟测试

                  我按一个真实需求,把整条流水线从头到尾跑通的记录。我特意覆盖了各种路径:正常前进、多轮澄清、中途改需求回退、门禁打回后逐级复审、自动执行区的打回-修复循环、冷启动恢复、提交建 CR、最后归档。这是一张总览:

                  具体耗时:

                  GEEK TALK

                  07

                  还没解决的问题,和接下来想做的

                  跑下来也踩到不少坑,如实记在这儿,也是后面要改的方向。

                  1. Sub-Agent 每轮都在重新加载上下文。 那些需要多轮澄清的阶段(比如 specify、plan),子代理每一轮都得把它默认要读的那批东西重新加载一遍,挺浪费。想法是复用类似"Sub-Agent 会话 ID"的机制,这一点其实我发现在使用 Claude Code 的时候,如果在某一阶段,提问类话术,Manager 会自动找到上一个 Sub-Agent 的会话 ID 继续,让同一阶段的多轮交互延续同一份上下文,而不是每轮重来——这其实也是 Multi-Agent 架构可以解决的,只是现在的调度还没做到这一层。

                  2. plan 阶段没有搜索边界,容易超时。 plan 实测跑到过一个小时,严重超时(这里声明不是每次,而且有的时候是模型首包延迟过长)。plan 的活确实需要读代码,但现在的规则只是让它"自己去 Grep/Read",没划边界。得给它补上知识库,利用渐进式索引,让 Agent 能快速定位、定位的准、读得少,本次允许读哪些仓、最多翻多少文件、调用链最多追几层、多久没收敛就该停、范围太大时该反过来问用户什么。

                  3. 产物和状态不是原子完成的。 实测碰到过:test-plan.md 已经在、也标了 Ready,但重新进流程时 Manager 很难判断——文件到底完整不完整?是 Sub-Agent 其实做完了只是结果丢了?该不该覆盖?能不能直接往下走?得把"写产物"和"改状态"做成原子的、可校验的一步,重入时才能可靠判断某阶段到底完没完成。

                  4. Manager 越界替用户答疑。 审查类阶段(比如 plan-review)会把打回结论和理由抛给用户;用户一有疑问,Manager 有时会自己跑去读代码来解答。这其实破了"Manager 不读正文/代码"的规矩,正确做法是把疑问回灌给出结论的 Sub-Agent 去解释(这条后来已经在规则里收敛掉了,经过几次测试发现不会产生)。

                  5. 前端设计需要更多能力兜底。 研发自己做页面,难免缺前端设计的详细描述,又不能全交给 AI 自由发挥。我实测第一次 AI 设计的界面就过度复杂了——功能是实现了,但交互和样式都不够简洁。这块可能得让前端或设计介入,提供一些前端实现/设计规范类的 Skill 来约束。

                  6. 云端 memory 的自进化还没做。我理想中的 Harness Engineering,应该是每跑完一次流程,就把这次遇到的实现问题、测试 bug 沉淀下来——我之前看到过一个说法大概是这个意思,面对 bug,第一优先级不该是让 AI 去想"怎么修这个",而是"怎么让下次不再产生"。现在虽然跑完会往本地 memory 里存,但换台机器这部分就丢了,得做一个云端共享的 memory,让经验能跨机器、跨会话攒起来,真正形成自进化的闭环。

                  7. 工作目录的结构设计对团队使用不友好。目前虽然我将所有内容都放在了一个 git 仓库,但是使用却不是这么用的,曾经看了其他团队的文章,使用了git submodule的方式,本项目的这个设计放在 git 上是作为云端存储,在本地,当前工作空间的根不能是一个 .git 目录,后续应该维护成一个团队友好的 WorkSpace 目录。

                  8. 未建立完善的线上运行的可观测性日志与监控。现在框架的产物其实只有两类:一是各阶段的产物与报告(spec / plan / 审查报告 / 测试报告 / 截图),二是状态机文件里的状态快照(当前在哪、在等什么)。这两样可以做到"单个需求怎么走完的",但无法观测某个阶段是否执行的正确,调用链路、读取内容是否符合预期,就跟传统线上业务,需要有监控、日志、报警一样,Agent Workflow Framework 同样需要具备这些能力(可以自定义 Hook 或者 Coding Agent 内部的 Hook 去采集)。

                  跳转微信打开

                  什么样的业务经验值得做成 Agent:从个人工具到组织资产

                  2026年9月8日 12:00

                  原创 欢迎关注的 2026-09-08 12:00 北京

                  业务经验反复被问却久困个人,本文给出三条判断标准,讲清哪些经验值得沉淀为 Agent,让个人工具升级为组织资产。

                  。图片

                  点击蓝字,关注我们

                  图片

                  作者 | 谢雨杉

                  导读 

                  introduction

                  团队里总有几个"被反复问的人":指标口径、取数路径、诊断顺序……回答得越好,被问得越多。问题出在经验只能一对一交付,困在个人身上。本文结合 E-SAGE 电商 Agent 服务平台实践,给出三条判断标准——咨询频次高、判断路径固定、结论因人而异,符合两条就值得做成 Agent。更关键的是,门槛不在编程能力,而在业务理解:谁能把判断说清楚,谁就能让经验变成组织资产。不妨从那个"你今年已回答过很多次、每次答案都差不多"的问题开始。

                  全文 3222 字,预计阅读时间 4 分钟

                  GEEK TALK

                  01

                  一个组织级的问题:经验困在个人手里

                  每个团队都有几位「被反复问的人」。指标口径怎么算、这个数从哪张表取、这类商家该先看哪个指标——问题一再出现,答案八九不离十,但每次都得由同一个人重新讲一遍。回答得越好,被问得越多。

                  这不是沟通效率的问题,而是经验的交付方式问题:专业经验长期只能以「一对一」的方式交付,一次投入只服务一次咨询。经验留在个人身上,既没有被组织沉淀,也无法被别人直接使用。

                  1.1 AI 工具并没有改变这件事

                  市面上的通用助手类产品大多面向个人使用:技能加载于个人会话中,效果取决于使用者的提问方式,更换使用者即需重新交代背景。它让「本来就会的人」更快,却没有让「不会的人」变会——经验依然留在个人手里。

                  1.2 差别落在交付物上

                  Skill 与工具交付的是工具,使用者需自行判断该用哪个、如何组合;Agent 交付的是可直接承接任务的执行主体,使用者只需说明需求。前者是一次投入服务一次,后者是一次投入反复调用。

                  由此产生一个更实际的问题:既然经验可以被沉淀成一个能自己干活的主体,哪些经验值得这样沉淀,哪些不值得?这是本文想讨论的重点。

                  GEEK TALK

                  02

                  形态之别:从个人会话到组织可治理的资源

                  关键的变化不在模型更强,而在 Agent 的存在形式:它不再是一问一答的个人会话,而是一份持久化的 Agent 定义加一套执行环境——角色设定、工具、技能、记忆、工作区与触发方式被固化下来,可长期复用、团队共享,用以承接完整且可重复执行的业务流程。

                  就能力构成而言,业界主流方案并无本质差异,都是「指令 + 工具 + 技能 + 记忆 + 工作区 + 触发」的组合。真正拉开差距的,是能否把 Agent 变成组织内可治理的资源:可创建、可测试、可发布、可共享,并配套权限管控、操作审批与全程审计。缺少这一层,Agent 就只能停留在个人工具的形态。

                  2.1 一次装配,两侧受益

                  可治理的前提是分工清晰:懂业务的人负责表述判断,使用的人只管提出需求,通用的工程能力由平台统一承担。

                  • 建设侧:设定角色 → 绑定能力 → 选型配置 → 调试发布。全程无需编写工程代码;执行链路与工具调用全程可见,可自行定位问题、独立迭代。

                  • 使用侧:选择 Agent → 自然语言描述需求 → 获取结果。Agent 会主动就时间范围、口径、维度反问确认,对齐后再执行,一次交齐结论与依据。

                  • 平台侧:运行环境、长任务调度、权限管控等各 Agent 通用、且与业务逻辑无关的能力,统一提供,不必重复搭建。

                  2.2 云原生多会话并行:调度与状态外置

                  挑战:传统Agent将 Agent Loop、状态和执行环境绑定在单机或单进程中,这种模式适合单人使用,但很难支撑组织场景下的多人共享、并发执行和统一管理。随着同一 Agent 被更多成员、更多 Session 同时使用,固定机器绑定会带来资源利用率低、故障恢复困难、状态迁移复杂等问题,也难以真正做到 Agent 级治理。E-SAGE 通过云原生架构对 Agent Runtime 进行解耦:

                  解法:产研自建Agent云原生架构cns(Commerce Neural Stack, 电商智能中枢栈)

                  • 三层解耦: 将 Agent Loop、状态、执行环境从单机实例中拆分,形成彼此独立的运行层

                    • 状态统一外置持久化,不再依赖具体机器,计算节点故障或迁移不影响会话连续性

                    • 执行环境按 Agent 隔离,Shell、Browser、Code、File 等资源互不污染

                    • 各层生命周期独立,可分别调度、扩缩容和恢复

                  • 分布式执行: Agent Loop 作为独立计算单元运行在分布式集群中

                    • 不同 Session 可分散到不同节点并行执行,实现计算资源池化和水平扩展

                    • 单 Session 通过租约机制保证同一时刻仅由一个 Worker 执行,避免并发写冲突

                    • Worker 异常或租约超时后可由其他节点接管,实现故障转移与自动恢复

                  • Agent 级治理: 将管理粒度从“机器 / 进程”提升到 Agent

                    • 同一 Agent 可被组织内多人、多 Session 复用,而无需绑定固定运行环境

                    • 平台统一完成调度、权限、资源和运行状态管理

                  GEEK TALK

                  03

                  判断标准:哪些经验值得沉淀成 Agent

                  真正稀缺的从来不是技术能力,而是可被清晰表述的业务经验。但并非所有经验都适合沉淀——投入之前,先用三条标准做判断。

                  3.1 符合任意两条,就值得建

                  ① 咨询频次高

                  同一类问题年内已多次解答,且每次结论基本一致。

                  典型:指标口径确认——问的人不同,答案却大同小异。

                  ② 判断路径固定

                  处理该问题有明确的判断顺序与标准,能讲清「先看什么、再看什么」。

                  典型:经营诊断——先看分层,再看门控,再看流量与转化。

                  ③ 结论因人而异

                  同一事项由不同人处理,结论常不一致,口径依赖个人经验。

                  收益:这类场景沉淀后不只是省时间,更重要的是口径终于统一。

                  3.2 两类场景暂不适合

                  • 需要临场判断、每次标准都不相同的场景。此类问题本身缺乏可表述的规则——连本人都写不出判断依据,Agent 自然也学不会。

                  • 一次性、不会重复出现的问题。沉淀的价值来自反复调用;只做一次的事情,投入产出并不成立。

                  3.3 一个更简单的自问

                  如果三条标准还是不好判断,可以只问自己两句话:「这个问题今年我回答过几次?每次答案是不是差不多?」——若答案是「很多次」且「差不多」,它就该被沉淀下来,而不是继续留在自己身上。

                  GEEK TALK

                  04

                  门槛在业务理解,而不在编程能力

                  这个判断有事实支撑:已上线的 Agent 应用中,建设方以业务角色为主,而非 Agent 研发工程师;覆盖场景也早已不限于数据,商机洞察、直播冷启诊断、招商选品都是由熟悉该业务的产品、运营同学自行建成并使用的。

                  结论并不复杂:谁最熟悉某类业务,谁就适合成为该 Agent 的建设者。

                  4.1 建设者需要投入什么

                  4.2 两个常被问到的问题

                  • 建成后效果不佳如何处理?调试工作台会完整展示每一步推理与工具调用,建设者可自行判断问题所在并即时调整,不必等待研发排期。

                  • 建成后无人使用怎么办?这恰恰回到第三章的标准——如果它解决的是被反复咨询的真实问题,就不会没人用;如果无人使用,多半是这个场景本就不该沉淀。

                  GEEK TALK

                  05

                  两个例证:符合标准的场景长什么样

                  下面两个 Agent 分别来自数据类与业务类场景,可以作为前述标准的参照——它们的共同点是问题被反复咨询、判断路径可以讲清楚。

                  5.1 电商数据口径 Agent

                  Agent 介绍

                  面向业务、运营与数据分析人员,帮助快速确认指标口径、定位可用数据源,并生成可执行取数方案。

                  适用场景

                  • 查询 GMV、订单量、用户数、转化率等指标的定义与统计范围

                  • 确认某指标是否可取、从哪里取、按什么粒度取

                  • 将业务问题拆解为数据维度、过滤条件与时间范围

                  • 输出 SQL 取数思路或数据需求说明

                  核心能力

                  5.2 电商直播冷启诊断 Agent

                  Agent 介绍

                  面向电商平台运营与小二,帮助快速定位冷启期直播商家的经营问题,自动完成多维取数与归因,并输出可落地的诊断报告。

                  覆盖范围

                  当前聚焦直播通路下商家冷启阶段的诊断,后续将逐步扩展至所有通路下的经营诊断。

                  适用场景

                  • 对单个冷启直播间做深度诊断,定位流量不足、转化偏低或开播门控未通过的根因

                  • 批量扫描冷启商家,按阈值筛出问题清单并标注命中场景

                  • 查询某直播间的分层档位、门控判定结果与同类目中位对比

                  • 对比多个维度指标,跨维度归因首因并生成可执行的下一步建议

                  • 输出结论前置的诊断报告(Markdown 与可视化 HTML 双形态)

                  核心能力

                  典型提问方式

                  • 这个 room_id 的商家冷启为什么没起量?帮我诊断一下

                  • 这个 room_id 的商家 X 月 X 日流量特别差,是什么原因?

                  • 帮我扫一下这批冷启商家,看看哪些门控没过

                  • 这个商家流量有但转化低,问题出在哪?

                  • 帮我生成 room_id XXX 本月冷启的完整诊断报告

                  • 这个商家的分层档位是什么?该优先做什么动作?

                  GEEK TALK

                  06

                  写在最后

                  把经验做成 Agent,本质上是一次表述的工作:先要说清自己是怎么判断的,才谈得上让它被复用。很多经验之所以一直困在个人身上,不是因为它太复杂,而是因为从来没有被完整表述过一次。

                  所以真正值得先做的,往往就是那个你今年已经回答过很多次、而每次答案都差不多的问题。

                  跳转微信打开

                  都在开源 Harness,Codex 和 DeepSeek 到底有什么不一样?

                  2026年9月3日 18:00

                  原创 欢迎关注的 2026-09-03 18:00 上海

                  同一个词,两家公司,开源的却是两层完全不同的东西。

                  。图片

                  点击蓝字,关注我们

                  图片

                  作者 | 医疗产品部

                  导读 

                  introduction

                  模型能力趋同后,竞争下沉到了"怎么把模型用好"。2026 年 8 月,DeepSeek 与 OpenAI 先后开源 Harness:一个开"整套零件",一个开"调教好的实习生"。本文用"天才实习生"的比喻讲透 Harness 的五大能力,并拆解两家打法的本质差异——要主权,还是要省心? 读完后你会明白:功能清单会趋同,但"没人下令时它怎么做"才是真正的护城河。

                  全文 6658 字,预计阅读时间 5 分钟

                  前言

                  GEEK TALK

                  同一个词,两家公司,完全不同的故事

                  2026年8月,AI编程工具赛道发生了两件看似相同、实则完全不同的事。

                  先是 DeepSeek 开源了 DeepSeek Harness,两天冲上9万多GitHub Star——这个速度,几乎破了开发者工具的历史纪录。没过几天,OpenAI也宣布开源 Codex 的 Harness 层:CLI、app-server,还有官方SDK。

                  如果你只看标题,会以为他们在打同一场仗。但如果你真的翻开代码,会发现一个反直觉的事实:他们开的是两层完全不同的东西。

                  TL;DR(30秒速读卡)

                  这篇文章只做三件事:

                  1. 用最直白的话讲清楚 Harness 到底是什么;

                  2. 拆开 Codex 这次到底开源了什么——核心亮点藏在哪里;

                  3. 说清 Codex 和 DeepSeek 的本质差异。

                  GEEK TALK

                  01

                  先建立一个坐标系:Harness 到底是什么

                  在聊任何细节之前,先认识一个人——一个没有经验的天才实习生。

                  他聪明得离谱:你随便说个需求,他立刻能给出思路;给他任何文字,读一遍就能复述、改写、翻译。

                  但他有四个要命的短板:

                  • 没记忆:上一分钟交代的事,下一分钟就忘干净,每次都得从头讲。

                  • 没背景:没见过你们公司的代码在哪、文档在哪、谁负责什么。

                  • 没手脚:不会打开文件、不会运行程序、不会查数据库——除非你给他工具,并告诉他"现在可以用"。

                  • 没分寸:分不清哪些事自己能做主、哪些事必须停下来问你,很容易越界闯祸。

                  问题来了:这样一个实习生,你要怎么把他用起来?

                  你大概率不会让他直接上手干活——你会做一整套"带新人"的事。而这一整套"带新人"的东西,就是 Harness。

                  1.1 一张表看懂:怎么"带"这个天才实习生

                  这个比喻后面会反复用到——这个实习生一会儿是 Codex,一会儿是 DeepSeek,两家对他的"带法"完全不同。

                  1.2 一句话定义

                  Harness = 模型之外的一切。

                  实习生本身只会“按要求干活”,他不知道项目背景是什么、工作规范有多大边界、如何使用趁手的工具。就像模型一样,本身只会“预测下一个词”,不会开文件夹、不会跑脚本、没法实时联网搜索。

                  把这些事全做起来的那层"外壳",就是 Harness。

                  拆开来看,它主要包含五样东西:

                  1.2.1 上下文管理

                  给模型看什么、不看什么、什么时候把旧内容压缩掉

                  实习生第一次接手项目,你不能把公司十年的邮件全倒给他,也不能只甩一句"你自己看着办"。你得挑出跟这次任务最相关的那几份文档,并且随着对话变长,把已经没用的旧信息收走——否则他会越来越慢、越来越跑题。

                  1.2.2 工具调用

                  让模型能碰文件、跑命令、查接口

                  实习生光会想、能干没用,得给他趁手的工具:配电脑、开权限,并告诉他"简单小铺可以换礼品,跟同事协同要用如流"。工具是他的手和脚。

                  1.2.3 执行环境与沙箱

                  把模型行为约束在安全边界内

                  实习生再聪明,也不能让他直接在正式环境里干活。你得先给他划一块"随便折腾也不影响别人"的试验田——比如一个独立的开发分支、一套隔离的测试环境。他在里面改代码、跑测试、试新方案,哪怕把整个试验田炸了,一键就能恢复如初,不影响线上业务。

                  1.2.4 审批与权限

                  哪些动作自动放行、哪些必须问人

                  实习生自己整理需求文档、画原型草图?可以自动放行。但要把需求正式同步给研发排期?必须等你确认过逻辑再发。

                  你得给他一张清晰的"权限地图"——绿灯的事他自己干,红灯的事他必须拉起警报等你来拍板。

                  1.2.5 会话与状态

                  跨轮次记住进展、失败后从哪恢复

                  他跟进了两周的客户,每轮沟通的要点、对方提的疑虑、下次跟进时间——如果没系统记下来,客户问"上次说的那个问题后来怎么样了",他一脸茫然,信任瞬间归零。

                  你得给他配一块"进度白板":当前做到哪一步、哪些方向试过但行不通、哪些结论已验证、下一步该干什么。这样他每天开工能无缝续上,而不是对着空白屏幕从头想"我昨天干嘛来着"。

                  一句话:模型是那个会思考的脑子,Harness 是那套让他能在真实世界里安全干活的整套装备。 脑子决定上限,装备决定他能不能把活干完、干好。

                  1.3 再放一张表,彻底理清模型 vs Harness 的分工

                  一句话:当模型能力趋同,竞争就开始从"模型"下沉到"模型之外的那层壳"。

                  1.4 再澄清三个常见的误解

                  误解一:Harness = 提示词(Prompt)。 不对。提示词只是"你怎么跟模型说话",属于上下文管理里的很小一块。Harness 还包括工具、沙箱、审批、会话状态——是一整个运行环境。

                  误解二:Harness = Agent 框架(比如 LangChain 那类)。 也不对。框架帮你"搭骨架",Harness 更偏"真实落地时的那整套壳"——包含框架,但远不止框架。一个框架可以拿来写 Demo,一个 Harness 得扛住生产。

                  误解三:Harness 是模型厂商的边角料。 恰恰相反,当模型拉不开差距时,壳就是护城河。在当下阶段,做好 Harness,可能比模型本身更值钱。

                  GEEK TALK

                  02

                  Codex 这次到底开源了什么

                  继续用带实习生的例子,假设你第一次带实习生没有经验,不知道该如何提升,Codex 本次就给了你三样东西,你可以开箱即用。

                  2.1 三样东西,三种用法

                  2.1.1 Codex exec:让他坐你旁边,你当面指挥

                  这是最直接的方式,就像你让实习生坐在你旁边,随时派活儿、随时验收。不满意?当场指导并让他重来。

                  在操作角度上,它就是一个电脑终端(相当于一个对话窗口),你只需要对着它说话:“把这个 MRD 再改改”、“这个代码有 bug”,Codex 就可以直接帮你干活,并把结果贴给你审核。

                  它还有一个"自动模式":你把一份任务清单甩给他,说"今晚把这几件事跑完,明天早上给我报告",他跑完把结果整理好,顺便在报告封面上贴个"成功/失败"的标签。最适合那种"每晚自动跑一遍例行检查"的重复性工作——比如电商大促前,每天自动查一遍价格配置有没有异常。

                  2.1.2 app-server:给他配一个总机号码,谁都能打电话叫他干活

                  你不需要亲自坐他旁边了。给他开一个"公司邮箱地址"(实际上是一套标准接口),任何有权限的人——产品、运营、甚至你们公司的内部系统——都可以往这个邮箱发任务。他收到就干,干完把结果发回来。

                  比如:产品经理发一封邮件(在 Jira 里创建一个任务)"生成这周的上线检查清单",系统自动接进来叫他干;运营发一封"生成昨日数据简报",他立刻开始跑数、写简报。你不用专门开个窗口跟他聊天,他已经变成了你们公司内部的"公用实习生"——谁有需求都能给他派活儿。

                  它跟第一种方式的核心区别是:你不再是"唯一能差遣他的人",而是"给所有人开了差遣他的权限"。 至于怎么开、谁有权限开,你自己说了算。

                  2.1.3 官方 SDK:把他打包成一个外包团队,你们公司的程序可以直接下单

                  前面两种都是"人直接叫他"。但如果想把他集成到你们自己的产品里呢?比如你们的内部工具想加一个"AI 帮你自动生成周报"的功能——不需要重新开发,直接调用他就行了。

                  SDK 就是"程序怎么调用他"的操作手册。你写好代码,你们的程序就能自动:开一个会话、让他跑任务、实时收到进度——甚至他能干活干到一半,程序判断"不对,这块权限不够",直接喊停,换个权限再让他跑。

                  它跟前两种的核心区别是:不是人叫他,是程序叫他。 你不需要有人坐在电脑前点按钮,流程可以全自动跑起来。就好比你不是"给公司招了个实习生",而是"把这家外包公司的能力接进了你公司的系统里,你们的程序自动下单,他自动接单干活。"

                  2.2 AI 干活长什么样?

                  前面说了三种"叫他干活"的方式。但不管你怎么叫他,一旦他开工了,一次完整的工作过程长什么样?

                  OpenAI 把"一次 AI 干活"拆成了三层结构,用三个词就能说清楚。

                  拿"让实习生帮你跟进一个大客户"来举例:

                  • 会话(Thread):从你第一次说"帮我跟进一下这个客户"开始,到最终方案确定、合同发出、客户确认——整件事从头到尾算一个"会话"。就像一张工单,开的时候写了个标题,关的时候已经有了结果。

                  • 回合(Turn):会话里面,你每交代一件事、他做一轮动作、再回复你——这算一个"回合"。比如你先说"整理一下这家客户的背景资料",他去查、回来告诉你"整理好了,发你邮箱"——这是一个回合。然后你说"帮我起草一份针对他们的报价方案",他去写、回来发给你——这是下一个回合。一次会话,就是若干个回合串起来的。

                  • 条目(Item):每个回合里,具体发生的每一件事,都是一个"条目"。你说的话是一个条目,他去查资料是一个条目,他写好的一份方案草稿是一个条目,他发起的一次审批请求也是一个条目。

                    会话:跟进华东区一个大客户的续约(从开工到收工)

                      回合1(你派活儿 → 他做背景调研)
                        条目1:你说"这个客户下个月合同到期,你去摸一下情况"
                        条目2:他查阅了客户近半年的使用数据
                        条目3:他翻出了上次沟通的会议纪要
                        条目4:他告诉你"客户最近三个月活跃度下降了15%,主要集中在新功能模块"

                      回合2(你补充信息 → 他出方案)
                        条目5:你说"把去年给他们的折扣政策也考虑进去"
                        条目6:他计算了三种报价方案的成本和利润空间
                        条目7:他草拟了续约方案,发给你确认

                      回合3(你修改 → 他发起内部审批)
                        条目8:你改了其中一个折扣系数
                        条目9:他更新了方案
                        条目10:他发起审批请求:"申请走特殊折扣流程,等你批"

                      回合4(你批准 → 他准备正式文件)
                        条目11:你点了"批准"
                        条目12:他生成了正式报价单和合同草稿
                        条目13:他回报"文件已备好,可以发给客户了"

                    关键点来了:当你把一次工作拆成"会话→回合→条目"之后,它就不再是一个"黑盒"了——你随时可以:

                    • 插进去:比如在回合3的条目10那里,审批系统拦住它,等你看完方案再放行。

                    • 回头看:比如一周后想查"当时给这个客户的报价逻辑是什么",你可以把整个会话的每一条都翻出来。

                    • 只看想看的:比如你只关心"他改过哪些数字",可以只过滤"计算报价"这类条目,其余不用看。

                    2.3 怎么带好实习生?OpenAI 的两个锦囊

                    1. 实习生看不到的东西,就相当于不存在

                    你让实习生"去给华东区这个大客户出一版续约报价方案"。

                    在你脑子里,这件事很清楚:一个月前你们内部已经协调定了"85折底线",实习生按要求出方案就行。

                    但在实习生那边,他翻遍了入职时领到的资料包:产品手册里有标准报价模板,过往案例里有几份历史合同,邮箱里躺着一封三个月前的客户沟通纪要。"85折"这三个字,从来没出现在他摸得到的任何一份材料里。

                    于是他按标准流程出了一版——95折,公司统一折扣,挑不出毛病。

                    这是一个"你以为他应该知道,但他压根没渠道知道"的问题。

                    解决方案?OpenAI 把这件事做成了工程,而不是靠口头提醒。

                    他们把所有"实习生应该知道但可能不在场"的东西,全部硬写进他能访问的地方:一份目录式的指引文档,告诉他"遇到什么该去哪里看"——不给他300页手册,只给他一张"地图";一个结构化的知识库,放所有历史决策、讨论结论;甚至派一个"文档园丁"Agent定期扫描,发现过时信息自动更新。

                    这套做法的核心就一句话:别指望他"在场",把该让他知道的,放到他伸手就能够到的地方。

                    2. 把"品味"变成机器规则

                    你让实习生整理投诉报告。你心里想的是"登录相关的问题归一类",他交上来的是"密码找回失败""账号无法登录""手机换绑收不到码"——三件事拆成了三类。

                    你问他为什么这么分。他说:"客服填表的时候就是分开填的,我照搬了。"

                    你没脾气——逻辑上挑不出错,但你想要的"合并同类项"他压根没意识到。这种"归类感"是你干了两年才长在身上的东西,实习生刚来两周,指望他"悟"?

                    这是一个"你的品味没有变成流程"的问题。

                    解决方案?把"什么叫好"翻译成自动检查的规则,然后派个"质检员"天天扫。

                    ① 定规则:

                    • 所有分类必须先查"标准标签库",库里没有的才能新建

                    • 每一项分类必须注明归类依据

                    • 每周跑一次健康检查,把"一人一类"的孤岛标签揪出来

                    ② 天天扫:

                    质检员每天扫描所有报告,发现偏离规则的地方,自动发起修改申请。你只需要确认"这个合并对不对",而不是从头翻一遍。

                    ③ 持续还:

                    今天扫出来三个分类没按标准来,修掉。明天又发现两个,再修掉。永远不让"坏品味"攒成大山。

                    OpenAI 给这个机制起了一个很妙的比喻:像垃圾回收。

                    年底大扫除 vs 垃圾回收:坏习惯攒半年,一次性整改,改动巨大、没人敢动,拖到下一年不了了之。每天顺手清一点,永远不会有"还不起的债"。

                    实习生用不了两周就学会你的分类方式了——不是因为他变聪明了,是因为"什么叫好"从他第一天干活起,就嵌在他每走一步都会撞见的那道流程里。

                    GEEK TALK

                    03

                    Harness 的分水岭与护城河

                    • DeepSeek 公开的是"整套带人系统的图纸和零件"。他的产品是一棵启动时组装的插件树——连"这个实习生怎么思考"(agent loop 本身)、模型适配器、工具注册表、会话日志,都是可以换的零件。相当于给了你一箱乐高和图纸,告诉你"这个人的手脚、脑子、记忆、行为准则都可以拆下来换"。前提是——你自己得会拼。

                    • Codex 公开的是"一个已经调教好的实习生,加上怎么把你的产品接到他身上"。他不让你换"思考方式",而是把上下文、工具、权限、验证、恢复这条工作回路,校准成一条普通用户无需重新设计就能走通的路。相当于直接派了一个"培训已完成、上岗就能用"的实习生过来,你只需要把公司门禁卡(你的产品接口)发给他,他就能干活。代价是——他必须用 OpenAI 配好的那套"工作方式"。

                    Codex 开源的是"怎么把能力接进你的产品",DeepSeek 开源的是"怎么把整套系统拆开重组"。 其余差异——语言、许可证、成熟度——都只是这个核心差别的投影。

                    有人会把这事概括成"DeepSeek 更开放,Codex 更封闭"。这是错的。两边其实都开放,只是方向相反:DeepSeek 开放的是深度——向下,直到运行时的每一个零件;Codex 开放的是宽度——向外,直到任何你想接入的产品形态。

                    这背后是两种不同的确定性交易:用 DeepSeek,你买到的是"未来仍能改变系统的权利"——不被任何单一产品锁死;用 Codex,你买到的是"默认就能拿到可验收结果"——不用自己设计那套工作回路。没有哪个天然更好,取决于你要的是主权,还是省心。

                    Addy Osmani 有一个犀利的观察:这些 harness 长得越来越像,比它们背后的模型还像——「look more like each other than their underlying models do」。上下文管理、工具调用、沙箱、审批、会话状态,谁家都会做,功能清单三个月后就会趋同。真正的护城河不在"有没有",而在于两个更深层的东西:

                    • 有没有"沉默的经验":当实习生面对一个模糊任务——"帮我把登录修好"——他是直接动手改,还是会先复现问题、追调用链、写失败用例、跑全量回归、检查有没有误伤?这套"没人下达的指令"才是真正的"经验"。它不在功能清单上,但它决定了交付质量的上下限。

                    • 默认路径有没有被校准过:Codex 的默认路径是被自己那条"人类不写代码"的极限路径验证过的——从空仓库到百万行代码,3.5个PR/人/天,它的默认行为已经被反复打磨。DeepSeek 给你的是"选择的权利",但默认值好不好用,需要你自己去校准。

                    功能清单会趋同,但"没人下令时它怎么做"不会——那才是护城河。

                    落到具体选择上,关键看自己更接近哪种处境:

                    • 想尽快见效的小团队:好用 = 少接管。你不想在设计"实习生的工作回路"上耗费精力,Codex 这类"替你扛默认"的更容易直接见效。

                    • 在建公司级 Agent 平台的团队:好用 = 关键能力不被单一产品永久锁死。你需要"换掉某个零件"的权利,DeepSeek 的"组合控制权"更有价值。

                    • 两种都想要:这两者不互斥。真正成熟的下一代 Harness,很可能是"该自由的自由,该约束的约束"——内核给组合权,外壳给接入权。

                    GEEK TALK

                    04

                    结语:Harness 不是"给 Agent 加一层壳",而是"给 Agent 造一个能稳定运转的世界"

                    回到最开始那个实习生。

                    DeepSeek 的选择是:把"带新人"系统里的每一个零件都做成可插拔的——换个"入职手册"、换个"工具台"、连"这个人怎么思考"都能换。你拿到一箱乐高,自己拼。

                    Codex 的选择是:先把一整套"带新人"的流程搭好、校准好,在百万行代码上证明它稳定运转,然后把接口打开,让你往里面接你自己的产品。你拿到一个已经上岗的实习生,给他发门禁卡就行。

                    两种选择,没有对错。它们只是把"模型之外的一切"这件新事物,从两个相反的方向各推了一步——一个向下探到了运行时的最底层,一个向外拓到了产品的最大面。

                    而对我们来说,模型会越来越强,Harness 会越来越成熟,但真正决定 AI 能不能在真实世界里稳定地干活,答案还在路上。

                    跳转微信打开

                    ❌