铃阅
❌

普通视图

Qwen4-Max 正式上线!

2026年11月16日 11:16

阿里技术 2026-11-16 11:16 福建

图片

我们正式发布 Qwen4-Max——与你并肩工作、创作和探索的全天候 AI 新同事。Qwen4-Max 基于 Qwen4 系列全新结构,拥有 2.4 万亿参数,具备原生视觉能力,支持百万 token 上下文窗口。

Qwen4-Max 以更强的专业工具运用、长程任务执行与成果交付能力,推动真实世界生产力的提升。从专业工作的深度到无限创意的广度,从 3D 建模与游戏开发到复杂精密的工业制造,从金融、法律、医疗到前沿科学探索,在与你的协作中,Qwen4-Max 能够理解工作全貌并持续推进项目,让每一个目标都拥有抵达现实的路径,实现人与 AI 协同工作的全新可能。

Qwen4-Max现已上线千问 AI 平台对外提供 API 服务,用户也可通过阿里Token Plan调用新模型,或在千问办公、Qoder、千问APP、Qwen Studio 等应用中直接体验。Qwen4 系列的中小尺寸模型将陆续开源发布。

性能表现

编程、办公及长程任务综合性能对比

相比 Qwen3.8-Max,Qwen4-Max 的整体能力提升如下。

图片

Code Arena:WebDev 

Qwen4-Max 前端编程能力在 Code Arena盲测榜单中位居全球前列。

图片

Token 效率与成本

Qwen4-Max 以更少的 token 消耗取得了优于 Qwen3.8-Max 的性能:在 Work360 上,Xhigh 和 High 两档推理强度下的 token 消耗分别减少约 24% 和 35%;在 Terminal-Bench 4.0 上,分别减少约 48% 和 49%。与此同时,相比 Qwen3.8-Max,我们全面下调了 API 定价,尤其大幅降低了缓存命中价格。在我们 Work360 的评测中,单个任务的平均费用从 26.58 元降至 11.16 元,降低了 58%。

Work360 与 Terminal-Bench 4.0 的 token 效率。

预训练

Qwen4-Max 采用 Qwen4 系列的全新架构,拥有 2.4T 总参数,每个 token 激活 71B 参数,另有 328B N-gram Embedding 参数。该架构围绕Attention、Residual 和 Embedding三个方面对稀疏 MoE 模型进行系统升级,优化计算效率、模型容量和训练稳定性:

  • GDN + Qwen Sparse Attention(QSA): 每四层中,三层 Gated DeltaNet 将历史信息压缩为固定大小的状态,另一层 QSA 通过轻量级索引器,以 block 为粒度选择相关上下文,降低长序列的注意力计算与索引开销。

  • Gated Residual(GR): 将残差流扩展为四条并行分支,通过动态读写门控增强跨层信息传递,提升训练稳定性。

  • N-gram Embedding: 根据局部上下文查表,在第二层引入局部 token 模式的额外表示,以较低的额外计算开销扩展模型容量。

图片

Qwen4-Max 模型结构

在 2.4T 参数规模下,Qwen4-Max 的预训练过程平稳,loss 持续下降,全程未出现 loss spike。这主要得益于模型架构和训练优化的改进。

图片

Qwen4-Max 平稳的预训练过程

在知识、代码、问答和 STEM 四类内部评测中,Qwen4-Max-Base 的每字节比特数(BPB)在全部五个参评模型中均为最低。相比 Qwen3.8-Max-Base,在总参数量同为 2.4T 的情况下,其各领域 BPB 下降约 5–13%,同时每个 token 的激活参数减少约 25%。

图片

内部评测:指标为 10 × BPB,越低越好。参数量按激活参数 / 总参数标注。GLM-5.3 和 Kimi-K3.1-Pro 为后训练模型,后训练可能影响其与基座模型的比较。

驱动真实生产力

Qwen4-Max 深度融入千行百业的复杂工作流,以更强的专业能力推动高质量成果交付,成为驱动真实生产力的 AI 新同事。

工业与专业应用

为全面提升模型在工业与专业场景中的协作能力,我们构建了 Work360 综合场景建模框架。该框架对复杂行业场景进行系统解构与细粒度分类,建立了涵盖 26 个一级领域、182 个二级子领域和 721 个三级细分领域的层级分类体系,实现对工业与专业场景的全方位覆盖。基于这一分类体系,我们构建了极具挑战性的 Work360 行业基准测试。在最新评测中,Qwen4-Max (52.69 分) 相较于上一代模型 Qwen3.8-Max (47.74 分) 取得了显著进步,在更广泛的行业场景中成为更强大的专业生产力工具。

Qwen4-Max vs Qwen3.8-Max 模型对比

图片

任务样例

图片

三维世界理解与生成

Blender:三维建模与场景创作

三维创作能力方面,Qwen4-Max 能够熟练使用 Blender 工具,串联几何建模、场景搭建、材质配置与灯光渲染等环节,将创意逐步转化为细节丰富、风格鲜明的三维作品。

从建筑与室内空间,到自然景观和科幻场景,Qwen4-Max 展示了对空间布局、物体结构与视觉效果的综合把握。

这种三维创作能力被进一步应用于游戏开发场景,并通过 3D 打印成为实体作品,将数字创作与后续开发、制作流程相衔接,为设计探索、内容创作和原型制作提供支持。

游戏开发:基于专业引擎的游戏创作

Qwen4-Max 能够熟练驾驭 Unity、Unreal Engine、Godot 等主流游戏引擎。 只需简单的自然语言需求,它就能合理利用外部资产,独立完成场景搭建、玩法逻辑开发、资产整合、材质配置、HUD 设计与特效制作,交付一个上手就能玩的游戏。

开发过程中,它会实际运行游戏,根据画面与交互反馈调整各种细节,如镜头跟随、角色动作、命中效果与打击感、光影与节奏配合,通过持续的运行测试与迭代,将场景、玩法和视听效果整合为可直接运行和体验的 3D 游戏。

喵出法随:Qwen4-Max 在 Unreal Engine 中打造猫咪法师冒险游戏。玩家可施放多种法术、选择能力强化,并挑战逐波敌群与首领。

汽车制造:从产线规划到零件设计与加工提效

在三丰智能装备、泛海统联精密的实际生产场景中,Qwen4-Max 将图纸理解、参数化建模与专业工具调用等能力融入工程流程,支持汽车制造中的产线规划、零件设计与加工验证等任务。其将设计生成、工具执行与反馈验证串联起来,展示了贯穿汽车制造全链路应用能力,带来可量化的效率提升。

在产线层面,Qwen4-Max 根据二维布局图与工艺参数,调用既有设备库构建三维产线,并开展节拍仿真与 PLC 虚拟调试;在零件层面,它完成车门总成、摩擦轮等部件的建模与设计,并辅助开展加工工艺规划、刀路生成与仿真核验。Qwen4-Max 通过根据仿真反馈迭代加工方案,在上机前发现过切、少切等问题。

在所展示的加工案例中,单个工件加工编程所需的人工投入由约 475 分钟降至 24 分钟,减少约 95%。

Agentic 视频创作

借助 Qwen4 与万镜一刻,您可以构建端到端的视频创作工作流。从打磨分镜脚本、搭建静态资产,到在白模预演中驱动相机动画、渲染生成独立片段,最终剪辑成连贯的多场景影片。

Qwen4 强大的语言、多模态以及智能体能力给复杂视频创作带来了知识注入、可控性和稳定性:

  1. 知识以文本或参考图prompt的形式注入到生成模型,使得生成更能反应创作者的知识和逻辑。

  2. 参数化白模预演确保复杂静态资产中几何结构、比例尺度与空间关系的一致性,也可精确控制动态运镜中的相机路径、动作和事件的时间轴卡点。

  3. 人机交互的自然语言化以及预演的可控性使得最终的成品更加稳定可解释。期待您使用Qwen4创作更多精彩的内容。

金融、法律、医疗落地实践

在专业垂直领域,Qwen4 深入金融投研、法律尽调与临床医疗三大高门槛场景,不仅可以处理繁杂的原始资料,更能完成深度的逻辑推演与证据链溯源,真正实现从“信息检索”到“专业交付”的跨越。

金融投研

Qwen4 可熟练调用 90 个 MCP 工具,全面获取 A 股、港美股、债券、基金及衍生品市场的行情、财务、利率与分红数据,并结合搜索对公开资料进行交叉核验。面对复杂的投研需求,它能够跟踪行业供需与订单变化、研判宏观利率与信用利差、比较股债性价比,并开展多因子回测以评估风格暴露。

以下案例以沪深 300 股指衍生品为例,展示了模型如何综合资金成本、股息率与合约期限计算理论基差、分析实际贴水,并考察隐含与历史波动率的差异。

最终,投研成果以 Excel 底稿和可编辑的 PPT 报告形式交付,并提供双重溯源保障:一是来源可查,点击单元格链接即可直达原始数据出处;二是图表可对照,PPT 图表与 Excel 底稿完全对齐,研究人员可随时从报告回溯至底稿,精准核对数值与计算公式。

企业 IPO 法律尽调

处理长程复杂法律实务方面,Qwen4-Max 面对客户分批提供的 198 份格式混乱、命名不一的散乱底稿,模型能有效排除干扰,按实质内容重命名并归类为 14 个目录,自动编制底稿文件清单;同时主动检索工商登记、知识产权、司法及信用等公开信息,与底稿进行多源交叉核验,核实发行人相关事实。

在核心的风险把控上,模型能深挖协议细节并剖析法律风险(如精准识别“对赌协议恢复条款”等潜在隐患),进而提供可执行的整改建议。

最终,它按严苛的实务标准交付了一份 86 页、6 万余字的完整尽调报告,全面覆盖历史沿革、股权架构等 12 个模块及 14 项具体法律问题,且所有结论均附有底稿引用以便追溯,在大幅提升尽调效率的同时,有力支持律师将精力聚焦于核心风险判断。

危重症临床医疗

在危重症临床医疗场景中,患者往往并发症多、病情变化快,伴随高频次的检查化验,产生了体量巨大且形态各异的医疗数据——包括几十份检验单、上万字的病程记录、多份医嘱以及 1,433 张原始影像。

视频中的患者在颈动脉支架术后经历室颤并复苏,拔管后出现胸痛,并于第六天再次插管。Qwen4 在单次对话中通读了整份复杂病历,完成了从信息提取到辅助决策的闭环:查指标(跨日期精准定位特定 CRP 结果)、理病程(将六天内的复杂事件对齐为清晰的时间线)、读影像(将影像归为六类序列,定位目标胸部 CT,通过多窗口并行读取数百张原始图像,准确识别出“双肺背侧实变”,与主管医生诊断完全一致)、做决策(综合多模态信息进行权衡,给出四条处置建议,与医生当日医嘱逐条对应)。

通过深度的医疗协同,模型能够高效整合多源证据,为临床一线决策提供坚实可靠的辅助支持。

驱动长周期智能体(24/7 Agents)

Qwen4-Max 支持智能体全天候推进长周期任务,通过自主规划与持续迭代,分阶段交付可用成果,兼顾自主执行与用户掌控。

持续交付:边做边交付,方向全掌控

长程智能体经常蒙头做事,缺少阶段性反馈,导致用户难以实时掌握进展、发现偏差和调整方向。为此,Qwen4-Max 融入 Live Delivery 能力,先交付可用首版,再持续交付更新版本,逐版扩展内容、提升质量。用户可依据每版交付成果评估进展、校准方向,Agent 可结合用户反馈动态调整计划,让长程任务的交付进展可见、执行方向可控。

我们同步开源 Qwen-Live-Delivery-Plugin,安装插件即可体验持续交付能力。

云资源调度:

提升模型自身应用、推理与训练的资源效率

Qwen4-Max 具备围绕复杂目标与约束进行运筹建模、求解与验证的能力,从而交付高质量的优化决策方案。该能力在阿里云真实业务场景中落地,实现了模型自主迭代并优化自身所需调度方案的闭环,涵盖数据标注中的多模型调用调度、云计算 GPU 资源的在线分配调度,以及云计算 CPU 资源的离线重调度。

在这一过程中,模型根据任务设定自主生成候选算法,协同阿里自研求解器 MindOpt 对可行性、目标值与耗时进行评估并获得反馈,进而通过修改代码、交叉验证来迭代更优策略。从上层模型调用到底层云资源调度,Qwen4-Max 依托可量化的反馈持续进化,直接优化了支撑其自身应用、推理与训练的运行系统,而由此带来的成本降低与资源效率提升,又将为下一轮模型迭代提供更坚实的算力支撑。

在相应场景中,数据标注场景模型调用调度费用对应参考基线平均降低 10.42%,GPU 在线分配相对基线的整机空闲容量时长提升 4.62%,CPU 离线重调度场景中达到最优目标的求解速度提升超 14.61 倍。

图片

驱动科学发现

干湿实验闭环:

Qwen4自主设计与合成新型冷却液材料

面向下一代高功率芯片给数据中心带来的散热挑战,Qwen4依托深度原理Mira提供的一体化干湿实验环境,自主完成了一种新型冷却液分子的设计、实物合成与测试验证,最终获得真实材料样品。

在连续48小时的自主Agent运行中,Qwen4全自动完成路线调研,构建包含270万个分子的候选空间,并依次开展结构筛选、MPA性质预测、第一性原理计算、逆合成设计与实验规划。

Qwen4进一步调度自动化湿实验室完成真实物料的配制、合成、分离纯化与测试,将屏幕上的分子结构转化为实验室中的实体样品。经过4轮“分子设计-合成测试-主动学习”的闭环迭代,Qwen4最终获得经过实验验证的新型冷却液分子。

从用AI探索材料,到用材料支撑AI基础设施建设,本次任务为破解数据中心散热难题探索了新的材料路径,展现了Qwen4跨越数字世界与物理世界的长程科学发现能力。

药物发现:

以自主科研探寻延缓认知衰退的新路径

阿尔茨海默病逐步损害患者的记忆与认知能力,也给家庭和社会带来长期照护负担。神经炎症是其重要病理环节,参与这一过程的 NLRP3 炎症小体,为探索新的干预策略提供了重要研究方向。

围绕这一靶点,Qwen4-Max 在深势科技 PharmMaster 平台上,展示了贯穿靶点研究、分子优化设计与计算评估的全链路能力。它不只是生成分子结构,更将文献与专利理解、专业工具调用和计算反馈融入持续迭代的科研流程。

在这一过程中,Qwen4-Max 自主检索文献与专利证据,选择参考分子并建立评估基线,随后通过多轮结构设计、性质预测与分子对接,根据评估反馈调整优化方向,最终结合跨轮指标比较与相对结合自由能(RBFE)评估完成候选优选。整个流程累计调用工具 454 次,完成 3,239 项计算指标评估,设计优化 24 个候选分子,将证据检索、设计生成、工具执行与反馈验证串成一条完整链路。

相比专利起点,最终优选分子在多项核心计算指标上实现全面改善。RBFE 计算估计显示,其与目标靶点的名义结合亲和力达到起点的约 3.6 倍。深势科技的专家认为,该分子具有较高的研究价值,值得进一步开展湿实验验证。从疾病相关靶点到高潜力候选分子,Qwen4-Max 将证据驱动的设计、专业工具执行与计算反馈相结合,展示了自主推进长程科研任务、持续优化分子并形成有价值研究成果的能力。

图片

“模型-框架-产品”协同设计

在 Qwen4-Max 的研发过程中,我们与 Qoder 等产品团队紧密合作,协同设计模型、智能体运行框架与产品。我们从用户在日常办公和专业设计中的实际需求出发,明确模型需要解决的问题,并以端到端任务的交付质量检验整体效果。在此基础上,持续提升任务执行能力、优化用户体验,帮助用户把想法落到实处,交付可直接使用的成果。

安全

我们以六大人工智能发展原则为指导,即:以人为本、包容诚信、隐私保护、安全可靠、可信可控以及开放共治,将模型治理贯穿于整个模型生命周期——从最初的设计与研究,到开发、训练、部署以及实际应用——确保负责任的人工智能是原生内嵌于设计之中,而非事后补充。

在软件工程训练任务中,我们在功能性检查的基础上新增了代码安全检测,以增强模型的内生安全编码能力。在 Last Secure Code Bench 的“无安全提示代码重建”及“功能与漏洞双重检验”中,Qwen4-Max 的函数级功能与安全双通过率从前代(Qwen3.8-Max)的 22.0% 提升至 31.8%;在函数,文件,仓库三个粒度上的同时生成安全代码比例从 8% 提升至 14.7%,接近翻倍。

模型在规避注入、内存安全和越权访问等核心风险上表现尤为突出,能显著减少默认生成的代码漏洞,协助开发者从源头压缩系统受攻击面。 

在网络安全方面,我们按任务的具体用途筛选,保留用于漏洞验证、检测和修复等防御任务的数据,剔除用于提升攻击能力等进攻任务的数据。经过内部安全专家对长程任务运行轨迹(包含完整 CoT)审查发现,Qwen4-Max 的网络安全防御能力大幅提升,针对攻击性用途的防护能力也显著增强。尚未发现模型产生大规模网络安全风险的能力。 

在 CBRN 方面,我们设计了安全数据并在安全后训练阶段提升了 Qwen4-Max 的内生安全。在内部评测中,Qwen4-Max 在未产生过度拒答的同时,识别出更多含有潜在风险的请求并给出安全回答。经过内部专家对模型作答(包含完整 CoT)审查发现,模型提出的方案不具备真正的创新性,也无法端到端的完成任务。尚未发现模型能够将相关知识转化为显著提升使用者能力的风险。

总结

Qwen4-Max 是面向工作、创作与探索场景的全天候人工智能协作伙伴。

它融合先进推理、原生视觉与长程任务执行能力,将复杂目标转化为可用的交付成果与具体的研究产出。依托持续交付(Live Delivery)机制,以及模型、智能体运行框架与产品层面的协同设计,Qwen4-Max 能够持续推进项目,根据用户反馈进行动态调整,并提供可供审阅和进一步拓展的成果。Max 只是 Qwen4 的第一款模型,系列中的小尺寸模型也将陆续开源:同源的技术路线、同一代的训练与对齐积累,面向小模型真正擅长的场景做取舍。 

作为新一代智能协作伙伴,Qwen4-Max 现已就绪,可随时响应用户的协作需求。

图片

图片

欢迎留言一起参与讨论~

跳转微信打开

基于本体的 AI 数据研发落地:淘宝行业经营分析实战

2026年11月13日 18:01

左文雯 张哲旸 2026-11-13 18:01 浙江

为 AI SQL Coding 提供精确输入

这是2026年的第 81 篇文章

( 本文阅读时间:约 15 分钟 )

AI 写 SQL,快不等于能交付。在阿里的业务体系中,一个经营分析需求往往要关联数十甚至上百张表,同名字段在不同场景下含义不同,指标口径还会随业务迭代不断变化。更棘手的是,大量业务规则从没写进文档,只存在于历史生产代码和资深研发的经验里。新人要花几个月才能上手,团队的经验也很难复制。由于缺少对业务知识的了解,当大模型开始帮忙写 SQL时,这个问题就变得突出。

为此,我们引入本体(Ontology),从生产代码中自动抽取隐性的业务规则,把它们变成 AI 可读、可追溯的结构化知识。为 AI SQL Coding 提供精确输入。

01

AI 生成 SQL 的三类典型错误

当大模型作为辅助开发工具进入数据开发场景,矛盾变得突出:模型的代码生成速度远超人类,但做出正确判断所需的业务知识,它无从获取。

1.1 一个看似简单的需求

以一个常见需求为例:业务方说「帮我查一下上月各品类的 top 品牌成交额及同比数据。」

需求只有一句话,看上去也不复杂。通用大模型几秒就能生成一段语法完整的 SQL,SELECT、FROM、WHERE、GROUP BY 结构齐全,逻辑通顺。但对照需求细看,问题就会暴露:品类下的品牌数据该从哪张表取?成交额对应哪个字段、是否包含退款?同比的口径又是什么?

这些判断在 SQL 里没有标准答案。研发凭经验秒懂,模型只能猜。

1.2 三类高频错误

真实开发中上述问题很常见,我们把通用 AI 的生成错误归纳为三类:

① 选错表。同一数据域下常有明细表、汇总表、快照表等十余张相似表,粒度各不相同。AI 分不清这些表之间的区别,容易选一张看着对实则不满足需求的表。

② 用错字段。同名字段在不同表中含义不同,同一含义在不同表中对应的字段名也不同。AI 直接按关键词匹配字段名,很可能选中与需求不符的字段。

③ 口径对不上。指标计算往往有一套约定俗成的口径:分子分母各取什么、是否剔除特殊数据、时间窗口怎么定义。成交额是实付金额还是剔退款金额?这些约定通常不在需求文档里,而在历史代码和个人经验中。

1.3 共同特征:SQL 能跑,数据不对

这三类错误有一个共同特征:SQL 能正常执行、能返回结果、不报任何错,但数据就是不对。这也意味着它们无法被常规测试拦截:没有异常、没有报错,只有错误的数据流进看板。AI 缺的是做出正确判断所需的业务知识。

下一章拆解这个「业务知识」具体缺在哪。

02

根因分析:AI 的知识缺口

在谈解法之前,先要看清AI生成SQL时,缺的业务知识到底是什么?拿两个需求拆开看。

第一个:"店铺类型"。听着是一个语义明确的业务概念,但在不同场景下对应完全不同的计算逻辑:决策域、服饰行业、国际行业分别依据不同的分类字段做判定。同一个业务概念对应多套判定逻辑,模型无法判断当前需求应走哪一套。

第二个:全网品牌归一。目标是把多源品牌名称自动对齐到唯一品牌实体,包含多项难点:

模型看到的只是字面字符串,它不知道"Apple"和"苹果"指向同一实体,不知道 Nike 和耐克是跨语言同指,更不知道宝洁和佳洁士是母子关系。这些隐藏映射关系的处理依赖不同算法,模型不知道。两个案例指向同一个根因:语义理解(表和字段的业务含义)、规则理解(指标口径与实体关系处理),这两层业务知识 AI 都获取不到。

由此可见,AI 生成 SQL 的准确性问题并非源于模型能力。实测中,同一需求换用更强的模型后,选表与语法的稳定性确有提升,但指标口径仍然存在偏差。原因在于:无论模型能力多强,都无法获取从未出现在上下文中的业务约定。

如果想让 AI 写准 SQL,就必须先让这些业务知识变得可读、可召回、可验证。这正是本体(Ontology)要解决的问题。

03

本体:将隐性业务理解结构化

既然瓶颈在业务理解,解法就要回答一个问题:如何让 AI 真正读到业务?我们的答案是本体(Ontology):把指标口径、字段语义、业务规则、历史代码经验等隐性知识,沉淀为一份可复用的结构化业务资产。有了它,AI 才有稳定的业务上下文,把 SQL 写对。

3.1 本体是什么:数据研发的「业务说明书」

一名有经验的数据研发接到需求时,脑海里的知识大致包括:这个业务域有哪些核心表、每个字段代表什么、关键指标怎么算、历史上有哪些坑、同类需求以前怎么写。本体要做的,就是把这套个人经验变成团队共享、AI 可读的资产。本体的价值体现在三个层面:

  • 消除歧义:把「店铺类型」这种多义词,绑定到具体业务域、具体字段、具体枚举;

  • 补全规则:把散落在历史代码里的 CASE WHEN、映射表、兜底逻辑显式化;

  • 可迭代:每一次人工修正、每一次 bad case,都可以回流本体,让系统越用越准。

3.2 本体与相邻概念的区别

在展开技术方案之前,先把「本体」和几个常见概念做下区分:

简单区分:数据库管「数据在哪」,语义层管「口径统一」,知识图谱管「关系推理」,本体管的是「让 AI 具备写对这类 SQL 所需的完整业务理解」。

3.3 本体的三层架构

我们参考 Palantir 的三层本体框架,并重新界定了每一层在数据研发中的边界:

本体三层架构

3.4 本体包含的五类知识

具体而言,本体承载五类知识:

上述知识全部结构化存储,每条规则可追溯到线上代码的具体位置。基于此,我们构建了基于本体的 AI 数据研发工具:OntSQL Agent = 本体资产 + 按需召回 + 飞轮迭代。

OntSQL Agent 架构

04

从生产代码中自动抽取本体

本体是什么讲清楚了,下一个问题:本体从哪来?这是工程落地中最核心的挑战。我们的答案是:不靠人工逐条整理口径,而是让模型从生产资料里自动抽,再让机器反过来验证。

4.1 四种方案对比

对上述方案进行逐项分析:

① 只给 DDL 无法解决语义问题。 DDL 里只有字段名和类型。以上述品牌归一需求为例,给出 DDL 后 AI 知道有某个品牌 ID 字段,但不知道它什么时候该用、和另一个字段什么关系、映射不上该怎么兜底。DDL 给的是「表长什么样」,我们缺的是「这张表该怎么用」。

② 人工整理知识库方向对,效果好,但维护不动。以我们的真实业务场景为例,线上表逻辑和数据口径一直在变。靠人读 SQL、写文档、再持续更新,写的时候慢,写完很快过期。

③ 让 AI 把文档编译成知识库是最近流行的做法,也是一些 LLM-Wiki 的建设思路:先把零散文档编译成结构化知识页,查询时优先查知识库。这个思路我们认可,本质上和我们一样,都是「先编译再查询」。但落到数据研发场景有两点不同:

  • 知识来源不同。知识库依赖人写的文档,而实际生产中大量需求是语音会议形成共识、协作平台上给一句简短描述、数据同学就直接开发。更关键的是,许多口径并无文档或文档不完整,补齐文档本身的成本最高,因此我们选择直接读取生产代码。

  • 产物不一样。知识库方案编译出的是自然语言知识页,例如「按层级逐级匹配」这类表述,机器无法判断其与当前线上代码是否仍然一致。需要说明的是,文档编译方案可整合多种格式的资料,覆盖面更广、建设周期更短。我们则更专注于 SQL 生成:输入为业务知识资料包,产出为 SQL。

4.2 本体构建入口:核心表 + 血缘

我们不是拿到一份 SQL 就分析构建规则,然后等待下一份输入,而是从核心表进去,顺着它的上下游把该带的表和知识一起带出来。先说入口。从业务交付表、看板展示表自动识别出这个场景真正在用的表,也就是核心表,再由数据研发同学手动补充、核实。这批表是起点,不是边界。顺着核心表的上下游又带出一批,最终本体里有四成的表,是靠血缘分析找出来、确认有价值后才建的。

以某品牌核心表为例,通过 DataWorks SKILL 读它的生产 SQL,血缘信息自动解析出上游表,且每张都能自动分析它在这条链路里干什么,这就是为什么最终本体中的表资产比核心表清单多。核心表决定从哪儿进去,上下游决定能捞回多少东西。

4.3 抽取形态:结构化三元组,而不是一句话

我们不让模型写自然语言描述规则,而要求它输出三元组。我们的做法是从生产环境中自动抽取运行中的SQL与元数据,让模型把每条 SQL 中的业务 CASE WHEN 抽取为结构化三元组。

以“店铺类型”判断为例,抽取结果如下:

case_group:        shop_type                    # CASE组
branch_order:      1                            # 分支序号
condition_sql:     shop_name IN (条件A,条件B) # 判断条件
action_sql:        结论A                        # 结果动作
source_sql_hash:   bbbd38537a7ba41e             # 源码指纹
evidence_sql_node: 308513553                    # 生产节点ID

使用结构化保存,不是因为模型看不懂自然语言,而是一句话没法校验:说不出它对应 SQL 哪一段,也说不出有没有过期。写成条件和动作,规则就能和 SQL 分支逐条对上,脚本自动对齐写法差异,算出指纹逐条落库,并绑定生产节点。

我们要的不是给人看的文档,是机器自己能查的资产。

4.4 三道关校验:专防模型幻觉

大模型幻觉在真实生产中难以避免,哪怕是旗舰模型也会抽错、也会编出 SQL 里根本没有的规则。所以抽完的规则不能直接用。

第一道:对指纹。每条规则都算一个指纹。算之前先把空格、大小写这些不影响语义的差异抹平,所以只要说的是同一段 SQL,人写的和模型抽的指纹就一定一样。实测上述品牌案例中人工写的规则,模型全都抽到了,指纹条条对得上。

第二道:回溯 SQL。把本体里的每条规则拿回生产 SQL,看它到底对应哪个分支。要是有哪条在 SQL 里找不到落脚点,那就是模型编的,直接删掉。实测某核心表留下关键分支规则,条条都能对上 SQL,没有一条是多出来的。

第三道:查格式。检查每条规则该填的字段有没有填全、格式对不对。这三道关只解决一件事:抽出的规则和生产代码逐条对得上。

4.5 人工只在两处介入

一处是核心表第一次进本体时人工过一遍,验证、复核、补充。另一处是线上发现生成得不对时(校验规则未通过、发现逻辑冲突等),人工看一眼是不是本体的问题,再决定要不要改本体。

除了这两处,拉元数据、抽规则、对指纹、回溯 SQL、表刷新后重新检查,全是机器自己跑。

把上述品牌需求 case 从头连起来看:一张核心表进去,自动带出上下游、规则、时间切换、数据血缘信息,每条规则都查得到它来自线上哪个节点,人只在最后检查一遍。首次接入一张再难的表,只需要一个权限账号加一次人工校验;之后口径变了,机器自己能发现并提示刷新。原来最重的知识库维护工作,从人工整理变成了机器抽取加少量把关。

05

本体如何进入 AI 生成链路

上一章节说清了本体怎么建,这一章讲清本体怎么用。

5.1 本体资产构成

在真实业务场景中,我们自动化构建了表本体、业务规则、指标定义,外加 SQL 事实、血缘、值域等生产证据和一层召回索引。复杂业务场景的真正难点,不在选哪张表、用哪个字段,而在口径怎么定、逻辑怎么算。因此,业务规则是整套本体资产的核心。

本体资产

除了表本体和业务规则,还有几类单张表装不下的知识:

  • 时间切换:某业务的映射表是按业务日期选表的,某个日期之前用旧版映射、之后用新版,生产上是用 UNION ALL 加 label 字段实现的。这条规则不写在任何字段注释里,AI 不知道就会只读一张表,历史数据直接算错。

  • 血缘:记清每张表的上下游和引用位置。

  • 值域画像:记录字段的真实取值分布。

  • SQL 事实:记录这张表惯用的写法,比如逐级降级、去重方式。

5.2 按需召回:给材料,不给硬规则

本体里上千条规则,每次写 SQL 不能全给,上下文太长,反而稀释关键信息。这不是我们的独有发现。业界把这个问题叫注意力稀释:上下文窗口的「物理容量」和「有效容量」是两回事,一个塞满无关信息的长上下文,有效容量可能还不如一个精心裁剪的短上下文。我们的召回机制对应的正是业界所说的渐进式披露(Progressive Disclosure),只在需要时才加载需要的知识。

召回模拟的是老研发接到需求时的思维过程。 Agent 判断这是一个 SQL 生成任务后,按规则约定自动调起召回,拿到上下文包之后才开始写 SQL。召回结果包含:

  • 需求相关的表本体与字段语义;

  • 相关的指标口径定义;

  • 触发条件匹配的业务规则;

  • 历史相似 SQL 的写法参考;

  • 值域、枚举、异常处理等生产证据。

以上述品牌需求为例,一次召回是七路并行的:相似实现、时间切换、血缘、值域画像、表族信息。相关度最高的那张表本体,召回没有全复制,只挑了和本需求最相关的规则,召回的规则恰好就是这个需求最容易踩坑的地方。

召回结果

这里有一个刻意的设计,也是我们踩过坑之后换来的:召回给的是材料,不是硬规则。

我们不改写 AI 的输出,也不强制它必须用哪条规则。早期试过把召回约束得很死,把规则写成必须遵守的指令,结果反而把模型能力限窄了:它从「聪明的 AI 工具」退化成「蠢笨的规则执行器」,遇到规则没覆盖的情况就不会推理了,生成质量不升反降。

这和 Agent 设计里「从防御到赋能」的思路是同一件事:与其用更多约束去堵错误的出口,不如把该看的资料找全,打开正确的入口。现在本体只负责供给证据,用不用、怎么用交给模型判断。另外,召回内部是确定性的程序逻辑,召回什么不由模型临场决定,同一个需求跑多少次结果都一样。

5.3 迭代飞轮:三条反馈链路

本体不是一次性调优的产物。静态知识库一定会老化,代码重构了但知识没跟上,口径变了但规则还是旧的。为了解决这个问题,我们设计了三条反馈链路,把真实使用中的修正持续回注本体:

研发真实修改 diff:对比 AI 初稿与最终上线 SQL,把人工补的字段、过滤、join、CASE WHEN 和口径修正回流;

评测集驱动:构建客观评测集,将扣分 case 拆解为本体缺口 / 召回不足 / 模型误用 / 需求隐含条件,用来补规则、补证据、调召回;

线上使用日志:Qoder、千问办公等平台给业务使用后的提问、结果、失败日志和人工修正,补充场景规则与使用约束。

三条链路的反馈汇入反馈池,经人工确认后写回本体,驱动下一轮本体修正。

飞轮闭环:三条本体反馈链路

5.4 技术复用:跨场景、跨平台

技术复用有两个维度:生成本体的技术可跨业务域复用,沉淀的本体资产可跨平台移植。

  • 跨场景复用:生成本体的技术方案不与具体业务场景绑定。同一套「自动抽取 + 飞轮迭代」能力,可以快速复用到其他业务域。

  • 跨平台复用:本体不绑定 AI 平台。资产标准化为 Turtle / JSON / Markdown + 索引文件,SQL 生成日志、采纳统计、反馈、回归测试等链路均为独立 Python 模块。通用Agent等平台只需保留薄入口,读取同一套资产即可。

我们已在不同平台跑通真实需求链路,验证了入口、资产、链路均可替换。换工具不换知识,这让业务知识真正沉淀为团队的资产,而不是某个工具的附属品。

06

效果验证:技术评测

方案做出来不等于真的有效。我们构建了一套贴合真实业务的评测体系,从评测集构建、规则设计到效果分析,验证「本体 + 飞轮」是否真正让 AI 从「看不懂、写不准」进化到「读得懂、写得对」。

6.1 评测集:真实需求,持续扩充

评测集的 case 全部来自真实业务工单,每条 case 包含需求信息、依赖表、Agent 需求输入等完整上下文,并绑定已上线的生产 SQL 作为 Ground Truth。

评测集不是一次性维护的静态集合,而是通过定时抓取 + LLM 自动分类实现自动入库,随业务需求增长持续扩充。

6.2 五层递进检测

我们设计了五层递进检测,从语法到最终数据结果逐层校验。不通过时自动归因到具体层级和原因,结果回流飞轮,形成「生成 → 评测 → 归因 → 修正」的自动闭环。

评测链路由「拉取评测集 + 预处理」与「AI 生成 SQL + 五维评测」两个 Skill 串联,实现全流程自动化。前者从线上评测集增量拉取 case,预处理后为每条 case 生成三份文件:评测集元数据、需求原文与 Ground Truth(下称 GT)SQL。后者在限定本体条件(有无本体、本体版本)后,由 LLM 生成 SQL 作为待评测代码。

代码生成过程遵循两条硬规则:① 禁读 GT SQL,同时禁止通过节点 ID 反查代码,防止模型直接复用标准答案;② 仅读取当前版本本体,禁止读取其他版本、共享生产版本或个人工作区版本,以保证版本间可比。

五维评测对语法、选表、字段、业务规则、数据结果五个维度分别赋权 10、20、20、40、10,合计 100 分。其中业务规则维度权重最高,因为该维度是 AI 当前最薄弱的环节,也是本体价值最集中的地方。每条 case 依据总分划分为「通过」与「不通过」两类。引入打分机制,是为了量化对比不同版本本体的优化效果;而最终结论采用 0/1 二分呈现,则可使结果更为清晰直观。

6.3 有无本体的实测对比

语法和选表已稳定通过评测,字段维度提升最为明显,目前模型瓶颈主要集中在复杂业务规则的完整还原上。业务规则维度表面仅提升 1 分,但每个需求包含多条规则,评分按"全部命中"计算;实际拆解来看,无本体时,AI 生成的映射规则基本错误,代码不可用;引入本体后,此前完全依赖模型猜测的规则分支,已通过历史代码和值域分布补齐,规则完整度有明显改善。以上述品牌需求为例:

07

效果验证:业务落地

引入 OntSQL Agent 后,数据开发的工作方式发生了明显变化:AI 承接业务理解并撰写代码初稿,研发从“逐行手写代码”转向“审核与兜底”。

需求承接统计:从需求交付节奏看,引入 OntSQL Agent 后月均需求处理量提升数倍,单需求交付周期大幅缩短。这说明 AI 不仅提升了单需求开发效率,更实质性放大了整体的需求吞吐量。

承接需求量

需求开发效率

AI行占比统计:月均 AI 代码行占比持续提升,从个位数提升至八成以上。这些数字共同说明,AI 已经从辅助工具升级为数据开发的实际生产力。

AI行占比指标统计

08

总结:数据研发角色的重新定义

综合全文,当前通用模型写 SQL 的瓶颈不在模型能力,而在于能否获取足够且准确的业务知识:模型不缺代码生成能力,缺的是用哪张表、取哪个字段、指标口径怎么算这些规则。模型擅长执行已经被定义清楚的规则,而规则本身需要人来定义,数据研发的「重新定义」正是发生在这条边界上。

所谓重新定义,不是 AI 取代数据研发,而是人与系统重新划分分工:模型承接确定性,人专注不确定性。

模型负责确定性、可复现、依赖信息检索而非业务判断的环节:逐行编码与语法实现,查阅历史逻辑、追溯血缘与下游影响,对齐字段口径、套用既有计算范式。这些过去占据一个需求大部分工时的重复性劳动,本质是执行既有规则,因此可以被系统稳定承接。

人负责需要业务知识输入、需要价值判断、无法从既有信息推导出来的环节:定义业务规则、做方案取舍、把关结果质量。AI 越强,系统越能把人定义清楚的东西执行好;而定义的精确程度,决定了产出的质量上限。

这一分工带来的直接变化是效率:一个需求的整体耗时从数个人日缩短至约一个人日。省下的时间并非凭空消失的工作量,而是从「执行」转移到了「定义与判断」。数据研发的角色随之升级,从代码的执行者转向规则的定义者,从逻辑的实现者升级为质量的把关者。

图片

图片

欢迎留言一起参与讨论~

跳转微信打开

授人以鱼不如授人以渔:我对企业级 AI 研发提效的思考与实践

2026年11月12日 18:01

原创 吴佐衍 2026-11-12 18:01 浙江

关于企业内部 AI 研发提效的、为什么选择做这些事,以及在业务域中实际效果如何,本文或许能够提供一些经验和参考

这是2026年的第 80 篇文章

( 本文阅读时间:约 20 分钟 )

导读

过去一段时间,Cursor、Claude Code、Codex 这些 AI 工具已经进入到团队日常研发的过程中,不知道大家是否经常遇到下面这些场景:

  • 你是不是每天都在“人肉给 AI 打工”? 当你把内网的需求文档或页面链接发给 AI,它反馈说:“这个文档或页面我读不到、或者我不能操作,你能帮我复制下吗?”;当 AI 改完一段代码,它停下来说:“代码写好了,你去手动验证一下,验证完再把异常贴回给我”;当排查线上问题时,AI 又说:“我已经加好日志了,但我读不到日志,你能帮我粘贴下日志吗?”。如果这些对话每天都在发生,你会发现你在不断的给 AI 打零工。这背后的原因是: AI 根本没有接入你的工作上下文与验证环境。

  • 为什么个人用 AI 干活变快了,团队整体的效率提升却不明显? 一方面,和 AI 协作经常像电影《初恋 50 次》里的女主每天醒来记忆都会清零,男主角每天都要重新认识她一遍:一个人已经花很多时间教会 AI 的业务知识(比如关联哪几个仓库、一休实验怎么配、端上从哪条用户动线点进去验证),换一个同事、开启新会话,AI 的记忆就清零了,又得从头来一遍;另一方面,少数同学摸索出来的高阶用法与最佳实践,也没法在团队内快速推广,第一个人踩过的坑,后面的人继续踩坑。这些问题的是 我们缺乏把“个人经验”转化为“团队经验”的机制 。

  • 当 AI 干活越来越快,我们怎么判断它做得对不对? AI 可以在很短时间内产出大量的代码,如果一名工程师进入自己陌生的业务域或技术栈,如何判断 AI 做得对不对、好不好?

在此前的《跨越临界点:大模型能力、应用形态与工程体系的六年演进(2020–2026)》与 《从 Spec 驱动转向环境与验证驱动》 两篇文章里,我系统回顾了模型能力、应用形态与工程体系的演进。其中一个核心判断是:模型能力的提升,让工程逐步移除早期用于弥补模型短板的规则与脚手架;与此同时,应用场景的拓展,又推动工程向外部数据、执行环境、验证反馈与组织协作延伸。

这篇文章试图把这个判断放回我们自己的工作中。聊聊我是怎么思考企业内部 AI 研发提效的、为什么选择做这些事,以及在业务域中实际效果如何,欢迎大家一起交流拍砖。

01

为什么 Coding 越来越快,交付却没有同步变快?

我在此前的 《从 Spec 驱动转向环境与验证驱动》 中提到过一个自己的经历:顺手买的一个交互实验需求,终端改码加本地验证,1 个小时就能完成;但要让它在线上生效,还涉及 O2、ZCache、一休、BUY2、Trade-Hub、奥创等多个平台的关联发布,又恰好遇上大促封网,从编码完成到上线,实际用了 3 周。

这 3 周里除去封网等待外,大量时间实际上消耗在跨平台查改配置、对齐上下游依赖与环境验证上。它和开篇提到的“人肉给 AI 打工”共同揭示了一个问题: 当局部编码越来越快,决定交付速度的瓶颈,会逐渐暴露在编码之外——如果获取信息与验证结果的方式没有变,整体交付效率依然很难提上去。

从研发提效的角度看,开发人员的日常工作包含需求沟通、编码、排查问题以及其他各类日常事务,编码只是其中的一个环节。但作为程序员,大家很容易把注意力放在自己最擅长的领域,而忽略了那些相对短板的地方。从木桶理论来看,综合效率的提升往往取决于最短的那块短板——就像谷爱凌说的,大家往往只看到她很努力,但选择方向更重要。因此,我们要做的是一个覆盖研发日常各主要场景的工作台,而不仅仅解决“标准需求编码”的逻辑。

同理,现在很多人把 AI Coding 的重心放在死磕“如何教 AI 写出更完美的技术方案”上,却依然让人去干查配置、搬日志、手点验证的跑腿活。但在人本身具备架构判断力的情况下,这样做并没有发挥出人机各自的比较优势,而是陷入了同质化竞争。一个团队里有各种各样互补的人才才是最强的。就像一支球队如果场上 11 个人全是前锋是赢不了球的,又或者像一台外科手术,主刀医生的核心价值在于关键判断与决策,哪怕他跑腿拿化验单的速度比助手还快,也不应该去和助手比拼跑腿。

02

那我们应该做什么?

首先我们不做 Coding Agent,因为现在模型公司与应用公司已经把通用 Coding Agent(代码理解、任务规划、工具调用、上下文管理等)做得足够好,而且仍在快速进步,我们只需要站在巨人的肩膀上就行。那我们应该做什么?不妨考虑这样一个问题:如果没有 AI,一个新人入职公司时我们会给他提供什么?我们能提供给他的东西基本是一样的:一个账号,让他可以访问各个内部平台;一台办公设备(电脑 + 显示器),让他能动手做事并验证结果;以及一个靠谱的团队与业务,让他了解目标与业务约束,并融入团队的日常沟通协作。多年之后,每个人依靠自己的主观能动性,在各自的团队和业务里做出成绩。

所谓“授人以鱼不如授人以渔”,对于通用编码与推理能力已经很强的 AI,我们需要做的也是相同的事情:给它配齐相关的账号、设备、团队知识与协同机制。内部平台连接相当于账号背后的系统访问能力,执行与调试环境相当于办公设备,团队沉淀的业务知识与历史经验相当于师兄带教,在此基础上再让它逐步融入组织的日常协同。这样随着模型能力的持续增强,我们在内部系统打通、可验证环境与业务知识上的投入,创造的价值也会越来越大。

03

如何拉齐 AI 与人的工作上下文

要让 AI 进入我们的工作上下文,首先需要看: 作为工程师在公司内部完成一项工作时,日常能够接触和操作的工作上下文有哪些?

  • 办公与知识协同 :办公通讯在钉钉,协作文档在钉钉文档,企业内网与技术社区在 Work 和 ATA;

  • 需求、代码与部署 :需求管理在 Aone,代码托管与评审在 Code,构建与部署则分别在 O2(前端)、MTL(客户端)和 Aone(服务端);

  • 业务平台与配置实验 :具体业务的搭建与承接在一休、奥创、VOID 等业务平台,实验分流在 AB 平台,配置与开关在 Switch、Diamond、Orange;

  • 监控、日志与基础保障 :线上监控与问题排查依赖 JSTracker(前端监控)、Sunfire(服务端监控)、魔兔(客户端监控)以及 SLS 日志,底层还离不开账号、权限与审批等系统。

因此,从表面上看,打通内部研发平台是在给 AI 增加工具;但从完成任务的角度看, 它实际上是在拉齐 AI 与人的工作上下文,让它的可见范围与可操作范围逐渐接近工程师完成同一项工作所需的范围。

当这些平台打通之后,AI 就不再局限于本地的代码目录,而是可以串联起完整的研发动作:直接从 Aone 需求空间或钉钉文档里读取需求文档与历史方案,从 Code 平台拉取对应的多端代码仓库并创建变更;完成编码之后,可以通过 O2、MTL、Aone 触发各端构建与部署,到一休、奥创、VOID 等业务平台及 Switch、AB 平台上完成配置与实验变更,再去 SLS、JSTracker、Sunfire 中查询运行日志与监控结果,甚至通过钉钉同步进展并发起评审。前一步获得的信息可以直接用于下一步判断,大幅减少人在不同系统之间搬运材料、重新解释背景的成本。

做完之后,AI 就可以像人一样操作内部平台。在这里有两个关键点:

  • 需要做好关键操作的门禁措施,由人来确认,避免 AI 误操作带来的问题。

  • 建立完整的评测体系确保平台的操作准确与可靠,避免出现“看起来可用,但实际上一点不好用”的情况 ——例如经常操作错误,或者读取到的平台数据不准确等。

关于这些内部平台自身的演进方向,我还想补充一个判断:企业内部有非常多的研发系统与研发平台, 从长期来看,这些平台自身 GUI(图形界面)的重要度会越来越低,慢慢会演化为服务化底座,通过 SDK、Skill 或者 MCP 对外提供服务 ,由上层工作台按需连接和调度。

04

如何让 AI 自主验证?

有了上下文和工具,AI 能做的事情多了,但要让它持续推进任务,还需要回答另一个问题:它如何知道自己做得对不对?

在上一篇文章里,我们讨论过编程 Agent 为什么能够较早成熟。一个重要原因是,软件工程天然具备编译、测试与版本回滚机制,模型可以反复经历“修改—执行—读取报错—修正”的循环。进入企业研发后,我们同样需要把这条反馈链路延伸到真实业务环境中。

对于终端开发而言,研发过程强依赖真实的终端环境(例如浏览器、APP 等环境):代码编译通过,并不意味着页面渲染正确;接口返回成功,也不代表端上的交互状态就一定对。对于 Web 浏览器环境,目前已经有比较成熟的方案(例如基于 Chrome CDP 等协议),AI 可以直接获取页面 DOM 结构、网络请求与控制台状态。但移动端的缺口尤其明显:对于 APP,虽然可以通过类似 Computer-Use 的方式去识别截图、模拟操作界面,但作为研发调试手段是远远不够的,因为仅靠外部界面操作无法获取详细的页面结构与 APP 内部状态信息。过去,这些结果需要工程师打开手机、操作页面、截取画面、读取日志,再转述给 AI。每一轮修正都依赖人工反馈,AI 的自主执行范围也就停在了这里。

为此,我们把移动端 APP 的截图、控件结构、点击滑动、网络请求、运行日志与 Mock,以及切账号、切环境(如日常、预发、线上环境切换)等能力一并开放给 Agent,让它能够直接操作真实环境,并根据结果继续排查。工程侧提供可操作、可观察的环境,模型则结合需求预期和当前运行证据,判断下一步应该查看什么、修改什么、如何验证。

另外,推进这件事还有一个绕不开的实际问题: 调试环境必须足够好拿、随手可用。 如果每次让 AI 调试验证,都得先装特定的安装包,等我环境折腾好,估计都够自己手动测好几回了。只有把调试能力提前预置好,结合云真机或即开即用的模拟器,让 AI 随时能低成本连上终端环境,这套反馈闭环才能在日常研发中高频转起来。

当这些都准备好了之后,AI 就可以像人一样调试开发,人机分工因此开始发生变化:人更多地负责目标、业务前提与体验判断,AI 承担修改、部署、操作和证据收集;人不再需要一步步盯着推执行,而是把精力放到关键节点的校准与验收上。

05

如何从个人提效转向组织提效?

前两项建设主要解决了 AI 如何获取工作上下文、如何在真实环境中执行和验证。但当越来越多同学开始使用 AI,我们会发现:一个人用得越来越好,并不意味着整个团队会自然跟着变好。

  • 少数人摸索出来的有效方法,如何在团队内快速复用? 团队的能力分布往往呈金字塔结构,在某方面特别强的人总是少数。如果少数人蹚出来的最佳实践只留在个人的 Agent 会话、配置或静态文档里,其他同学仍然需要重新摸索。

  • 分散在不同岗位手里的知识,如何汇集起来共用? 一个业务域通常由产品、运营、服务端、前端、测试、设计等多个岗位共同参与:产品熟悉业务规则与人群口径,服务端了解供给链路,前端熟悉用户动线与体验,测试掌握异常场景与验收要求。大家围绕同一个业务目标工作,各自掌握的知识相互关联,却往往分散在不同的人、文档和工具(如各自的 Codex、Qoder、Cursor)中,无法形成合力。

怎么把分散在个人手里的知识与经验沉淀下来,变成全团队推进下一个事情时都能直接复用的公共上下文? 为了解决这个问题,我们建设了 Team 的团队上下文管理:

第一步,构建业务域 Team,把全局上下文与实践经验组织起来。 一个 Team 既可以对应顺手买这样的具体业务小组,也可以对应性能优化、架构治理等横向专项小组。具体该往 Team 里放什么?不妨再次回到“新人入职”的视角:一位靠谱的师兄,实际上发挥着路由导航的作用——他会先帮新人摸清团队与业务,谁负责什么、需求在哪里、涉及哪些系统、代码分布在哪些仓库、遇到问题去哪里查;随着工作深入,还会告诉新人哪些规则必须遵守、哪些地方容易踩坑。

Team 承担的也是这样的职责。我们围绕具体业务域梳理出一张“全景导航图”,把开展工作所需的规则与经验以文档、Skill 等形式组织在里面,主要包括:

  • 团队与研发入口 :成员分工、Aone 需求空间、A/B 实验空间、数据口径与 A+ 空间、关联代码库、常用研发平台等,让 AI 知道一项工作涉及哪些人、系统与资料;

  • 业务与架构全景 :核心业务概念与规则、从供给到推荐再到消费的数据流转、C 端与 B 端用户动线、仓库组织方式、业务架构与技术架构等,让 AI 看清局部修改所在的完整链路;

  • 工程规范与实践经验 :实验配置要求、终端适配规范、常见踩坑点、历史决策及其适用条件等,让团队验证过的方法能直接复用到后续任务中。

知识建设的重点是梳理全景图与业务约束,易粗不易细,而不是把代码逻辑翻译成文档,因为 AI 自己就能直接读代码 。具体实现细节让它顺着导航去查代码即可,Team 重点维护单看局部代码看不出来的全局脉络与核心红线,避免把大量容易过期的代码细节堆成误导 AI 的负资产。

第二步,产研共用同一个工作台,在日常工作中直接使用 Team。 Team 建好之后,我们让同一业务域的产品、服务端、前端、测试等各岗位同学在同一个工作台里切入对应的 Team 开展工作。产研共用一个工作台,好处是不同岗位的上下文在日常干活时自然就打通了:产品补充的业务规则与统计口径,研发写代码时可以直接调取;研发梳理出的系统约束与实验规范,也能成为产品和测试后续评估与验收的依据。同时,工作台把前面打通的内部平台与验证环境也整合在一起, 底层执行 Agent 随时可以更换,而团队沉淀在 Team 里的业务知识、规则与经验则可以跨工具持续复用。

第三步,在日常迭代中持续更新 Team,把个人经验沉淀为团队资产。 业务和系统一直在变,Team 里的内容如果只靠集中整理,很快就会过时。因此我们把更新融进日常工作,形成两条回流路径:

  • 由人在使用中发现问题并顺手提交更新 :比如产品发现少了某个人群分层的定义、服务端发现供给链路说明已过时、前端发现终端适配漏了前提条件,直接在当前工作中提交修正,CR 合入后全团队马上就能用上;

  • 由 AI 在需求结束后总结经验并发起 CR :一个需求上线后,可以让 AI 回顾这次任务补充了哪些新知识、踩了哪些坑、形成了什么可复用的做法,整理后提交人工评审把关。这里尤其需要人来判断适用范围,避免把单次需求里的临时处理误当成全团队长期遵循的规则。

06

从“人找 AI”到“AI 找人”:当 AI 融入组织的社会协同

当通过前面三件事帮 AI 配齐了账号(内部系统打通)、设备(可验证环境)与团队知识(Team)之后,我们进一步在思考与探索的第四个方向是: 如何让这位“新人”融入组织的日常协同?

现在的 AI Agent 大多还是单向的“人指挥 AI”,当 AI 进入团队后,人与 AI、AI 与团队其他成员之间同样需要建立顺畅的协作关系。目前在这方面很明显的一个卡点: 异步交互链路往往是断的 。例如,我们可以让 AI 去咨询问题,但钉钉的消息回馈是断的;可以让 AI 发起一个 CR,但还需要我们去提醒它看看 CR 进展;AI 去申请权限,但申请是否通过又要我们去提醒它。当 AI 遇到困难时,能否直接找到对应的同学寻求帮助?大家能否直接在钉钉群里 @AI 让它去解决问题,或者在协同文档里 @AI 让它去做分析?它又能否作为 PM 协助进行项目推进管理?

这背后其实对应着人机协作模式的一次转变。一个人每天在线时间是有限的,而 AI 却可以 7x24 小时随时在线。一方面,让任务在人离开办公电脑后仍能继续推进,为此我们支持了云端与 Mac mini 多设备模式,白天在工位开启的任务,离开后可无缝移交到 Mac mini 或云端后台执行,人在手机端随时可查看或接续;另一方面,协作模式慢慢从“人盯着 AI”转向“ AI 在关键节点找人 ”。前面提到的等 CR、等权限审批、等消息回馈,很多通过定时器或事件回调就能自动接续,等到真正需要人做判断时再带着上下文通知人;而再往后的主动找人求助、群与文档内协同、项目推进,则更偏向于“个人管家”或“个人助理”的角色。

一旦进入这个阶段,最需要关注的核心问题就是: AI 要清楚知道哪些事情可以做,哪些事情不能做 。当 AI 代表个人或团队在组织里发消息、找人、响应群内呼唤时,必须有明确的身份标识、上下文路由与权限边界。比如别人呼叫它时,它可以回答事实问题、帮忙排查分析,但涉及代码变更、发布部署或排期承诺等有副作用的操作,必须回来找号主本人确认;同时在主动找人或跟进项目时也要克制打扰频率,避免给团队制造额外噪音。这部分边界与机制,我们目前也还在持续探索中。

07

回到实际场景:这套模式在日常研发中是如何运转的?

把前面这些能力整合在一起,我们希望带来的使用体验就是“开箱即用”。举个不一定恰当的比喻:对于企业内部的研发场景,原生的 Cursor、Codex、Claude Code 就像配置很高的组装 Windows 电脑,基础能力很强,但每个人拿到手后,还需要自己装驱动、配软件、接内部系统,才能进入具体业务干活;而我们希望自己建设的研发工作台“三眼仔”像 MacBook 一样,把内部平台连接、终端验证环境与团队上下文预先整合好,减少每位同学开始工作前重复准备的成本。 落到每位同学身上,就是不用再重复折腾平台接入、环境配置和背景解释,打开工作台就能直接进入业务干活。

当团队成员开始一项工作时,只需要 选择对应的业务 Team (比如顺手买 Team),AI 就能利用已经配置好的平台入口、业务知识与验证环境,围绕需求沟通、编码实现、问题排查等场景推进工作:

  • 查实验、排查问题与口径对齐 :无论是日常查一个 A/B 实验、排查线上报警与数据异动,还是在需求沟通阶段核对业务现状,因为 Team 里已经配置好了空间映射与业务规则,AI 可以自动关联到对应的研发与监控平台,直接去读取一休上的实验配置、拉取线上数据或日志并分析原因;如果在这个过程中,PD(产品同学)发现某个统计口径、人群分层或对账规则需要调整,直接在工作台里提交对应上下文或 Skill 的更新,经 CR 确认合入后,后续研发和数科同学沟通与分析时就对齐到了最新口径。

  • 从读需求、跨仓编码到真机自验证 :当推进一个具体需求实现时,AI 可以自动关联钉钉文档或 Aone 读取需求内容,顺着 Team 里的架构与仓库地图找到对应的前后端代码仓库完成编码;写完代码后,AI 会根据 Team 里记录的 用户动线 ,自动打开真机并导航到目标业务场景,将页面资源 替换为本地开发地址 进行实时真机验证,还能根据测试需要 自主切换测试账号、自主部署预发环境 。

  • 代码 CR 与团队经验持续回流 :在功能验证通过、准备上线前,AI 可以发起代码 CR,并在收到评审意见后协助修复问题;而在整个过程中,如果发现某处上下文缺失或踩了新的坑,既可以 由人在过程中随时提交更新 ,也可以 在需求上线后由 AI 总结经验提交更新,统一经人工 CR 确认合入 Team ,让每一次需求迭代都沉淀为团队的公共经验。

从顺手买团队 2026 年 5 月至 9 月的交付记录看(对比首尾的 5 月与 9 月),需求从进入研发到上线的平均交付耗时由 16 天下降到 10 天。这些是团队同期的整体变化,也包含架构依赖治理与测试优化等工作的贡献,不能全部归因于 AI;但它们让我们开始从完整交付周期与工作范围的变化,观察 AI 在组织中的实际作用。

08

当 AI 干活越来越快,组织如何让人具备判断力?

随着 AI 干活越来越快,一个想法很快就能变成原型,一份方案很快就能落到代码。过去受限于执行成本而无法尝试的事情,现在可以在短时间内反复探索。在这个过程中,Taste(品味与取舍)会变得越来越重要:选择解决什么问题、采用哪种方案、什么样的体验才算好,都需要人来拍板判断。

但对于组织来说,仅仅强调个人的 Taste 还不够, 如何让人具备判断力是更重要的事。因为一旦跨入自己陌生的领域,人其实很难判断 AI 做得对不对。

举个全栈的例子:一个前端同学借助 AI 去做后端需求,如果他完全不了解后端的业务架构与工程最佳实践, 即使 AI 给出的技术方案本身是对的,在实际的生产环节中,单靠他自己,这个需求也是无法上线的 。AI 拓宽了人活动的边界,却不会自动帮他补齐陌生领域的判断力。因此,组织提效需要同时推进两件事:让 AI 更有能力执行,也让人更有依据判断。具体来说,需要在三个层面上补齐人的判断力:

  • 在实际业务场景里依然缺少不了“下苦功夫”,持续梳理整体的应用架构 。在 AI 时代,我们可以不了解所有的局部代码细节,但需要对整个系统的业务架构、技术架构、调用边界与工程最佳实践有清晰的宏观认知。只有脑子里有这张宏观地图,跨领域干活时才知道该看哪些关键点、如何评估生产风险。 换句话说,AI 时代对人的要求不是降低了,而是更高了。

  • 把验证过程变成人能核对的客观证据 。人在陌生领域很难单靠看代码判断对错,但看真实环境的运行结果就直观得多。如果 AI 只回一句“已经修好了”,人根本没法放心;但如果它能同时附上修改原因、操作路径、日志与请求变化,以及真机跑出来的页面截图,核对起来就有了明确抓手。借助前面打通的研发平台与真机验证环境,把这些运行证据直接摆到台面上,能大幅降低跨领域验收的门槛。

  • 把专家的判断过程显性化,并在跨领域关键节点保留组织校准 。值得沉淀进 Team 的内容,除了最终结论,还包括资深同学当时评估过哪些风险、依据什么做出的取舍,以及上线前必须核对哪些红线。同时,对于跨出熟悉领域的任务,在方案评审、核心 CR 与上线验收等关键节点保留领域专家的校准,让工作范围的扩展与个人判断能力的成长相互配合。

AI 越快,错误方向被放大的速度也越快 。Taste 帮我们选对要做的事,全局架构认知与客观验证证据帮我们把准结果对不对;而团队要做的,就是把这些判断标准沉淀下来、传承下去。只有人的判断力跟上了,AI 带来的执行提速,才能稳稳转化为团队最终的交付质量与交付效率。

09

结语:如何让自己真正站在风口上?

回看这段实践,AI 重塑软件研发已经是大势所趋。雷军曾说“风口来了,猪都能飞起来”,面对这场技术浪潮,我就期望自己和团队能成为风口中的那只猪。但这里恰恰有一个最关键的判断: 如何让自己真正站在风口上? 因为很多时候,最怕的是“不知道自己不知道”——明明做的事情还在旧流程、旧入口里打转,或者还在替模型补那些很快会被下一代模型内化淘汰的短板,却以为自己已经站在风口上了。

要跳出这种盲区,其实只需要问自己一个问题: 当下一代更强的模型发布时,我们今天做的事情,是会被它淘汰,还是会让它发挥出更大的威力? 对于业务团队来说,我们无法决定下一代模型会在什么时候跨过新的临界点,但可以把承接这些能力的底座先建好——这也是我们不做通用 Coding Agent,而是选择做企业级 AI 工作台“三眼仔”的原因。

所谓“授人以鱼不如授人以渔”:像对待一位新同事一样,为 AI 打通内部研发平台(账号)、提供可验证的终端调试环境(设备)、沉淀业务域的 Team 全景图(团队),并让它逐步融入组织的双向协同网络;与此同时,也倒逼团队里的每一位同学下苦功夫梳理宏观应用架构、提升跨领域的判断力。我们还在这个探索过程中,但至少目前的实践让我更加相信:当底层模型每进步一分,这套工作环境与团队的判断力就能把红利放大一分——这或许就是让自己真正站在风口上的方式。

图片

图片

欢迎留言一起参与讨论~

跳转微信打开

Qwen4-Max 预览版上线,Qwen Code 1.0 Preview 发布

2026年11月11日 11:45

阿里技术 2026-11-11 11:45 浙江

图片

今天,Qwen4-Max 预览版首发上线阿里 Token Plan,Qwen Code 1.0 Preview 同步开源。

Qwen4-Max 预览版首发上线

全新一代千问大模型 Qwen4 即将发布:知识理解更深入,世界感知更立体,Coding 与 Agentic 能力持续进阶。从复杂编程、专业办公,到前端设计、专业软件操作,Qwen4 在实际任务测试中,交出了让我们眼前一亮的成果。

现在,Qwen4-Max 预览版已首发上线阿里 Token Plan。同时,千问办公、Qoder、千问 APP、QwenStudio 等也已第一时间接入新模型。

欢迎大家抢先体验,把真实难题交给 Qwen4 试试看。

Qwen Code 1.0:以事件为语言,连接 Agent 与世界

智能正在走向更持续的理解与行动。围绕一个目标,Agent 理解上下文、制定计划,在执行中验证判断;面对新的信息,它重新评估已有结论,调整行动路径,继续推进任务。未来,更多智能将融入我们日常使用的应用。需求发生调整,Agent 理解变化对当前计划的影响;工具返回意外结果,它追查原因、尝试新的路径;协作者提出意见,它结合任务进展判断如何回应。智能需要在不断变化的环境中,理解发生了什么,以及接下来该做什么。

智能将无所不在,而每一处落地的智能,都需要 Harness 将模型能力嵌入具体的应用和流程。它负责接收外界变化、调用工具、管理任务,让 Agent 能在真实环境中持续工作。

Qwen Code 1.0 正是为这样的集成与嵌入而打造。今天,我们发布 Qwen Code 1.0 Preview,融合 Qoder 与 Qwen Code 的 Harness 能力并开源,为开发者提供可嵌入自身产品的 Agent 运行基础。

以事件为语言,用户要求、工具结果和系统反馈能够进入对应任务,推动后续处理。一次执行的结果,为下一步判断提供依据;一条新的反馈,补充任务上下文,让后续行动接续已有进展。事件将外界变化与 Agent 的工作连接起来。

开发者可以接入自己的工具与业务流程,将 Agent 嵌入已有产品,让智能融入用户熟悉的工作方式。用户提出目标、补充信息、参与关键判断,Agent 在相应的上下文中推进工作,减少反复传话和交代背景。

Qwen Code 1.0 架构演进示意

一起体验 Qwen4 与 Qwen Code 1.0

Qwen4-Max 预览版:https://platform.qianwenai.com/pricing/token-plan

Qwen Code GitHub 地址:https://github.com/QwenLM/qwen-code

同时,如果想快速体验最新的 Qwen Code,可以前往 https://qwen.ai/qwencode,下载安装后接入自带的 API Key,或登录 Qoder 账号领取免费额度快速试用。11 月 11 日至 11 月 24 日,在 Qwen Code 通过 Qoder 账号登录可领取 Qwen4 免费体验额度,领取后 30 天内有效。

图片

图片

欢迎留言一起参与讨论~

跳转微信打开

从淘小蜜分流模型的实践,聊聊 Jev 与 System One

2026年11月10日 18:01

原创 吴双 2026-11-10 18:01 浙江

关于最近大火的 Jev,本文或许能够提供一些技术实践参考

这是2026年的第 79 篇文章

( 本文阅读时间:约 30 分钟 )

前言

最近 Jev 很火,技术社区里也出现了不少复现项目。看完相关文档和项目后,我发现团队去年做的淘小蜜客服 Agent 分流模型和 Jev 要解决的问题有一些相似之处,技术方案上也存在可以互相验证的地方。

本文的初稿其实在去年九月份就已经写好了,当时的内容主要是总结淘小蜜分流模型的数据构建、训练和部署经验;最近分流模型又做了一轮优化,在线上部署和评测时踩了四五天坑,再加上 Jev 发布后大家都在猜它的实现方式,所以重新把之前的内容整理了一番。

先说明,Jev 没有公开模型结构和具体训练方法。本文对 Jev 的介绍以 TypeSafe 官方文档为准,对模型结构的讨论主要参考 SemIf、open-bonsai-jev、AlexWortega/openjev 等社区项目;社区项目只能说明某种方案可以实现类似能力,不能说明 Jev 内部一定采用了相同方案。

01

背景

淘小蜜客服 Agent 在回答用户问题前需要先判断应由哪个 Agent 承接,当前的分流模型主要把用户问题分成售前、售后、其他问题、意图不清四类,再根据分类结果路由到不同的 Agent。

这个任务表面上是一个普通四分类,实际做起来却没有那么简单。售前和售后的标准不是按照通用语义划分,而是按照不同 Agent 的能力边界划分。例如订单评价、取消订单、价保、退款后的优惠券和红包等问题属于售前。“退差价”也不能见词就判:因质量不符、重量不足、少件、描述不符等商家责任要求退差价,属于售后;没有这些商家责任原因的退差价,属于售前。猫超、国际、百补、小时达、闪购等自营场景的问题,如果超出当前 Agent 的承接范围,又可能归为其他问题。这些规则带有较强的业务属性,和通用大模型在预训练阶段学到的常识并不完全一致。

在分流模型的迭代过程中,主要经历三个阶段。

第一阶段是使用通用 LLM 做 ICL few-shot 分类。

具体做法是在 prompt 中描述分类规则,再放入一些示例,让模型直接输出分类标签。这种方案开发比较快,前期效果也能满足基本需求,但是存在几个问题:

  1. 大模型调用成本较高,响应速度较慢,大促高峰期还有系统稳定性的问题。

  2. 业务规则和通用常识冲突时,仅调整 prompt 很难完全纠正模型。

  3. 对于退款权益、红包、退差价等边界 case,继续增加 few-shot 的收益逐渐变小。

第二阶段是对 7B 模型做 SFT。

这一阶段用约 2.1 万条数据做 SFT,把业务知识教给 7B 模型,解决了部分通用模型不了解业务规则的问题。问题是标签直接写成“售前/售后”,输入格式、输出词和标签比例也长期固定。对只有几种分类的训练任务,模型很容易把训练集里的词和标签记成捷径,而没有真正学会判断条件。例如看见“红包”就倾向售前,但体验赔付红包可能属于售后;看见“退差价”就倾向售后,又会错过没有商家责任原因的售前 case。继续增加类似训练样本,线上没见过的用户 query 也未必能分对,这正是当时遇到的泛化问题。它不能简单归因于模型参数量大;数据分布、标签噪声和训练目标都在起作用。

另一个问题是训练数据天然不均衡。早期二分类数据的售前、售后比例约为 3:7,扩展成四分类后,售前、售后、其他问题和意图不清也不是等量的。标签直出时,这种分布直接反映到输出词上,模型容易形成“更常回答售后”的先验。后面我们把业务标签随机映射到字母,让同一个标签在不同样本中对应不同字母,正确答案的字母分布就能在统计上接近均衡。这里平衡的是输出 token 的分布,业务样本本身仍然不均衡;随机映射的有限样本也不保证每个字母数量完全相同,需要检查实际分布。

第三阶段是把分类改成选择题。

训练数据不再要求模型生成“售前”“售后”等标签,而是给每个标签分配一个选项字母,让模型学习预测正确字母。线上只做一次前向计算,读取候选字母 token 的 logits,取最大值对应的选项并映射回业务标签;实际生成出的答案文本不参与判定。输出由候选表控制,因此不会返回候选表之外的标签或一段解释。这和 Jev 所说的“不产生幻觉”有相似之处:解决的是输出越界,模型仍然可能选错候选项。

从任务形式来看,这类模型更接近一个带语义理解能力的决策函数:输入是一段对话和分类标准,输出是有限候选中的一个结果,以及每个候选对应的分数。模型不需要生成完整回答,也不需要解释推理过程。

分类模型本身并不是新的方向。BERT 一类编码器通常在预训练模型上增加输出层,再针对分类、自然语言推断等任务做微调。编码器一次读完整段输入,在固定标签任务上通常更省推理资源,后面会聊到的 Laya 就采用了这条路线。[9] 生成式 LLM 则成为 Agent 的常用底座,同一个模型可以通过 prompt 处理问答、生成、推理和工具调用,并直接读入新的业务规则。但是在 Agent 系统中,仍然存在大量只需要返回有限结果的高频判断,例如分流、打分、守卫、模型路由和是否重试。对于这类任务,生成能力并不是必需能力。

TypeSafe 把这类任务定义为 System One 任务:给定足够的信息后,可以在很短时间内完成的聚焦判断。对于复杂任务,官方建议拆成多个独立问题,再通过代码组合结果。[1] 这个定义和分流模型实际解决的问题比较接近。

02

谈谈 Jev

TypeSafe 在 2026 年 9 月 15 日发布了 Jev,并把它定义为首个 System One Model。Jev 接收文本或结构化状态,输出带类型的概率决策。官方公开的信息包括新的模型架构、并行 sampler,以及一套名为 RLCD(Reinforcement Learning for Calibrated Decisions)的训练方法,但是没有公布网络结构、参数量和训练数据等细节。[2]

官方给出的端到端响应时间是 70ms—500ms,并宣称在 System One 类型任务上,相比同等智能水平的 LLM 可以快 40—200 倍。TypeSafe 同时说明,部分演示使用了较短、信息密度较高的输入,对 Jev 相对有利;官网中 193.6 倍速度和 444.6 倍成本的数据来自收益较高的一组工作流,不能直接当成所有任务的通用结果。[1]

关于 Jev 的三种输出类型。

Jev 当前提供 Choice、Score 和 Noul 三种问题类型。三种类型不是同一份返回结构换一个名字,字段也不完全相同。[1]

类型

用途

返回字段

Choice

从多个无序候选中选择一个

choice、probabilities、confidence

Score

在多个有序等级上进行评分

score、legend、probabilities、confidence

Noul

判断一个命题为真的概率

noul,取值范围为 0 到 1

Choice 最多支持 255 个选项。如果分类体系超过这个数量,官方文档建议使用分层分类。一次请求中还可以针对同一个 state 提出多个问题,不同问题相互独立,并行返回结果。[1][3]

从接口设计上看,Choice 和我们的分流模型最接近,都是给出运行时候选并返回候选分数。Score 更适合严重程度、用户情绪等有序等级。Noul 则可以理解成一个二分类概率,例如“用户是否在申请退款”。

从返回字段继续往下看,这三种输出其实都可以从候选 logits 计算出来。假设模型能够为每个选项或等级输出一个 logit,经过 softmax 得到概率分布后,Choice 取概率最大的选项作为 choice;Score 对各等级编号和对应概率做加权求和,官方文档中的示例就是 0 × 0.0 + 1 × 0.57 + 2 × 0.43 = 1.43;Noul 只有“是”和“否”两个结果,所以返回“是”的概率即可。Noul 也可以写成两个 logits 的 softmax,或者等价地对两个 logits 的差做 sigmoid。[1][8]

类型

如果从 logits 还原

其他字段

Choice

probabilities = softmax(logits),choice = argmax(probabilities)

confidence 根据概率分布的集中程度计算

Score

probabilities = softmax(logits),score = Σ level_i × p_i

legend 来自输入等级,confidence 根据概率分布计算

Noul

noul = p(true)

二元概率已经能完整表示结果,因此没有单独的 confidence

TypeSafe 没有公开 confidence 的具体计算公式,只说明它由 probabilities 的分布形态计算,分布越集中,confidence 越高。[8] 因此,三种输出的核心数值都可以从 logits 出发计算,但还不能逐字段复现 Jev 的返回结果:legend 是调用方传入的元数据,两个 confidence 也缺少公开公式。这个结论同样不能说明 Jev 底层使用的是普通字母 token、special token,还是独立的分类 head。

关于Jev 所说的“不产生幻觉”。

TypeSafe 在发布文章中强调 Jev 不生成字符串,因此不会发生类型错误,也不会返回定义范围以外的值。[2] 这里的“不产生幻觉”主要指输出结构和取值范围,而不是模型在语义判断上一定正确。

例如 Choice 的候选只有售前和售后,Jev 一定会返回其中一个,不会突然返回一段解释或一个不存在的标签。但是它仍然可能把售前判断成售后。open-bonsai-jev 的实验中也存在模型以 0.998 的置信度给出错误答案的情况。[5] 因此类型安全解决的是结果能不能直接被代码使用,准确率和概率是否可信仍然需要单独评测。

关于「为什么大家都在用 Jev 玩游戏和做 Computer Use」。

TypeSafe 官方展示了 Doom 和 Wikiracing。Doom 演示中模型每秒需要做多次动作判断,输入是结构化的文本状态,不是直接读取游戏画面;Wikiracing 则需要在每一步从页面链接中选择下一跳。[2]

游戏和 Computer Use 比较适合展示 Jev,主要有几个原因:

  1. 动作空间通常是有限的,可以直接转成 Choice。

  2. 每一步都需要快速响应,LLM 生成带来的延迟比较明显。

  3. 多步任务中,单步错误会逐渐累积,更容易观察模型的实际决策效果。

  4. 游戏和浏览器操作可以录成视频,传播效果也比较好。

这些领域不一定是 Jev 最有价值的商业场景,但比较容易展示高速决策相对于普通 LLM 的差异。TypeSafe 在 Use Case Map 中给出的实际方向还包括模型路由、LLM guardrail、搜索排序、客服分流、风险判断和大规模数据处理等。[7]

社区对 Jev 实现方式的猜测。

目前社区项目采用的方案主要可以分为两类。

第一类是直接读取生成模型候选 token 的 logits,SemIf 和 open-bonsai-jev 都属于这一类。

SemIf 不训练新模型,而是使用冻结的普通开源模型,把 state、问题和选项拼成 prompt,然后直接读取候选选项的 logits,不生成答案文本。SemIf 使用同一个冻结的 Qwen3.5-4B,在 RTX 3090 上测试同一 state 下的 21 个二元问题,直接读取 logits 的中位耗时为 1.023 秒,生成一个精简 JSON 数组的中位耗时为 5.332 秒。另一个 37 个 state、每个 state 包含 21 个 criterion 的实验中,共有 777 个判断。逐条执行需要 333.1 秒,使用 shared prefix 和 parallel suffix 后降低到 38.8 秒。[4]

open-bonsai-jev 使用的核心方案和 SemIf 基本相同。项目自己的说明是“SemIf direct 模式的独立重实现”,使用了不同的 prompt,也没有直接复用 SemIf 的代码。它同样使用普通的 A、B 等字母作为选项 token,关闭 thinking,让 assistant 的下一个 token 对应答案字母,再对候选字母的 next-token logits 做 softmax。[5]

两者的主要差异不在打分方式,而在模型和项目目标上。SemIf 更偏向一套完整的实验实现,包含普通 Qwen 模型、shared prefix、parallel suffix、多种推理后端和评测工具;open-bonsai-jev 则把相同机制应用到 PrismML 的 Bonsai 低比特模型上,重点验证 27B 模型能否以 5.95GB 的文件在本地设备上运行。由于两边使用的模型、prompt、硬件和推理环境不同,实验数字不能直接横向比较。[4][5]

第二类是把生成模型改造成判别式分类模型,AlexWortega/openjev 属于这一类。这个项目对 Qwen3.5 做 NLI 后训练,使用最后一个 token 的 hidden state 接分类 head,输出 entailment、contradiction、neutral 三类概率,并使用普通交叉熵训练。做多选题时,可以把每个候选改写成一个 hypothesis,再按照 entailment 分数排序。[6]

Laya:另一条编码器路线。

Laya 也支持 Choice、Score、Noul,不过底座换成了 ModernBERT-large 或多语言 mmBERT,再接一个针对选项打分的 decision head。它不做自回归生成。项目在 T4 上报告单问题约 33—40ms,模型和测量条件都与 Jev 的托管 API 不同,这个数字只说明它自己的推理开销。[9]

Laya 的结果也很能说明“通用决策模型”有多难。项目自己的 typed-decisions 测试里,英文基础模型的零样本准确率是 0.362,针对这套任务训练后的 checkpoint 才达到 0.766;同一份报告里,10 类客服工单分流只有约 0.50。作者也明确建议在具体领域继续训练,并指出它的 Jev 对比数字不是同条件实测。[9][10]

其他开发者的复测同样有任务差异。Necati Demir 用公开的仇恨言论数据集测试,原始 Laya 准确率为 22.10%,只训练原有决策 head 后达到 82.75%,但仇恨言论召回从 77.97% 降到 41.43%。另有开发者复现了项目的英语意图 benchmark,换成自己的论文段落和工作笔记后,零样本结果低于简单的 TF-IDF 分类器;他也说明后者使用了任务标注数据,不能当作同条件的模型胜负。[11][12] 这些实验的共同提醒是:响应快和输出格式稳定,并不自动带来新业务上的准确率。

这些项目实现的都是类似 Jev 的决策接口,并不是真正复现了 Jev 的模型结构。目前能看到三种路线:冻结生成模型读取候选 token logits、在生成模型上训练 NLI 分类 head,以及像 Laya 那样用编码器和选项打分 head。实现方式不同,不能用接口相似推断 Jev 的内部结构。

03

淘小蜜分流模型是怎么做的

我们做分流模型,主要围绕训练数据、模型训练、线上推理和 hardcase 回流迭代。真正花时间的地方,除了业务标准和数据质量,还有线上筛选难例、二阶段训练、让不同 epoch 看到不同选项映射,以及保证部署后的候选 logits 与离线评测一致。

历史版本的主要优化。

最早我们采用标签直出的方式,输入历史对话和当前 query,让模型直接生成“售前”或“售后”。用约 2.1 万条数据做 SFT 后,发现模型容易拟合标签比例、关键词和其他浅层特征,没见过的 case 上泛化效果不太好。

V1 把标签直出改成选择题。在 prompt 中明确四类标签定义,为每个标签分配 A、B、C、D 中的一个选项 token,训练目标只保留正确答案对应的单个 token。但是这一版的标签与字母映射、选项顺序都没有 shuffle。售前始终对应同一个字母、出现在同一个位置,业务标签的样本比例也就原样变成了答案字母的比例。除了答案缩短成一个 token,它和标签直出的训练任务基本一致,模型仍然可以依靠固定字母和位置拟合,泛化问题没有解决。

V2 做了两个调整:把可用的选项 token 从 4 个大写字母扩到 26 个,同时 shuffle 标签与字母的映射,以及选项在 prompt 中的顺序。同一个业务标签不再绑定固定字母和位置,各类样本都可以把任意字母作为正确答案,答案 token 的分布也更均衡。只计算标签到四个字母的对应关系,只有 24 种映射;扩展字母池后,模型会看到更多映射,需要结合当次选项内容判断,而不能一直记住“某个词对应 A”。

V3 和 V6 使用 std_sigmoid(logits) 辅助筛选 hardcase 并回流训练。std_sigmoid 会先对单个样本内的候选 logits 做标准化,再执行 sigmoid:

    z_i = (logit_i - mean(logits)) / std(logits)
    score_i = sigmoid(z_i)

    我们在线上记录第一名和第二名的分差,从低分差样本中筛选 hardcase,标注后回流训练。直接对候选 logits 做 softmax,在 logit 差距较大时很容易得到接近 0 和 1 的结果,筛选边界样本不太方便。例如四个 logits 是 [10, 0, 0, 0],softmax 第一名约为 0.9999,std_sigmoid 则约为 0.85。标准化后再做 sigmoid,主要看候选在本次选项组内相对高低;它对 logits 整体平移和正比例缩放不敏感。这个处理不会改变候选排序,后面表格中的准确率提升来自数据回流和训练。std_sigmoid 的分数不合计为 1,也会抹掉 logits 整体缩放造成的绝对间距变化,我们把它作为挖掘难例的相对分数使用。[5]

    我们还在 V3 上试过多 pattern 投票:对同一个 case 构造多组选项映射,再对结果投票。两组实验的整体准确率分别为 92.42% 和 91.97%,都没有超过单 pattern 的 92.76%,所以当时没有采用。调试时也观察到,同一条“退运费”消息换了几组字母和选项顺序,仍然能正确判为售后;但另一些边界 case 会随映射变化。这说明模型已经能处理部分没见过的映射,稳定性仍然有优化空间。

    我们当时在 884 条 benchmark 上得到的单 pattern 结果如下。这组使用的是当时的标签标准和评测口径,和后面这次迭代分别看。

    版本

    主要优化

    Goodcase(685)

    Badcase(199)

    整体(884)

    较上一有效版本变化

    V1

    四选一,但字母映射和选项顺序均固定

    72.70%

    69.85%

    72.06%

    —

    V2

    扩展到 26 个字母,shuffle 字母映射和选项顺序

    97.23%

    69.35%

    90.95%

    +18.89pp

    V3

    std_sigmoid 筛选 hardcase 并回流训练

    97.96%

    74.87%

    92.76%

    +1.81pp

    V6

    继续增加 hardcase 训练

    97.52%

    80.40%

    93.67%

    +0.91pp

    V1 到 V2 的提升最大,但不能只归因于选项字母从 4 个变成 26 个。更关键的变化是映射和顺序终于打乱了,固定标签的输出先验和位置捷径被削弱。后续我们主要通过线上筛选 hardcase、标注回流再训练来提升效果,收益更多集中在 Badcase。

    我们在 Jev 发布前一年左右,就把这套候选 logits 打分方案用于客服 Agent 的生产分流了。去年 7 月 19 日,旧链路的准确率和召回率分别为 92.02% 和 84.73%;新模型逐步放量,到 9 月 3 日推全时,两项指标分别为 96.17% 和 94.24%。期间我们也修过推理 bug、调整过流量和分流标准,所以这组变化反映的是整套方案迭代的效果。至少对客服分流这个任务,我们已经验证了大模型做分类可以兼顾效果和线上效率。

    为什么这里继续用生成模型。

    我们当时没有用传统 BERT 分类器,主要由于除了四个标签以外,还需要读对话历史、判断最新消息是否覆盖旧意图,以及理解不断补充的业务边界。常见的 BERT 加固定分类 head 方案,输出维度与训练标签绑定;只改 prompt 加一条新规则,分类边界未必跟着改变。我们更希望复用指令模型读规则和候选描述的能力,也方便用 zero-shot 或 few-shot 快速验证新标准。Laya 说明编码器也能学习运行时候选,但同样要专门训练这个能力。[9]

    我们需要的也不只是识别句子里的关键词。比如同样问“退差价”,需要结合前文判断是质量不符,还是普通价差;用户只说“是的”,还要判断他确认的是哪个诉求。选择生成模型,是希望利用它已有的上下文理解和指令遵循能力。我们没有做过同数据、同训练预算的 BERT 对照实验,所以这里更多是方案选择的考虑。

    我们用同一句「这物流为啥往回返了?」做了两次调试:先按原来的四分类规则,把发货物流归入售后,模型返回 B,对应 B. 售后;再修改 prompt,把发货物流从售后中单独拆出来,增加 H. 发货物流,模型就返回了 H。两次都没有对话历史,这个 case 展示了模型跟随当前分类标准和候选集合判断的能力,而不是把“物流”固定对应到某个标签。当然,单个 case 不能代表整体泛化效果,新规则仍然需要成组样本验证。

    原四分类:物流归入售后,返回 B

    新增发货物流类别:返回 H

    因此,我们没有给 7B 底座再接一个四分类 head,而是沿用自回归训练目标,只让它预测正确字母。这样能复用已有的 SFT 训练、Whale 部署和候选 token logits 接口;标签和字母的映射可以每条样本、每个 epoch 改变,推理时也能把新标签描述放进 prompt。固定四维分类 head 如果换了标签含义,需要补充数据重新训练;增减类别时通常还要调整输出层。如果改成逐候选打分或运行时候选 head,又是另一套需要训练和部署的方案。这里只计算一个位置的候选 logits,不生成长答案,自回归底座的额外生成开销很小,但模型参数量仍然是 7B,速度和成本不一定优于专门训练的编码器。[6][9]

    线上推理时,Whale 请求只保留当前选项对应的候选 token,并限制模型只生成一个 token:

      generate_config
       = {     
      "return_logits": True,     
      "select_tokens_id": select_tokens_id,     
      "return_output_ids": True,     
      "max_new_tokens": 1,     
      "top_k": 1, 
      }

      服务获取候选 token 的 logits 后,取最大值对应的字母,再根据当前请求的选项映射还原成业务标签。

      最新一轮优化。

      九月底我们针对分流模型做了一次优化,这次我们重新实现了不同 epoch 间的动态映射,并对比固定映射和动态映射的效果。下面的 V4、V5 是本轮迭代使用的版本名。

      我们重新检查了 20000+ 条训练样本,修正 24 条高置信度错误标签,另外整理了 7000+ 条 hardcase 用于 Stage 2 训练。评测仍使用 600+ 条 Goodcase 和近 200 条历史 Badcase,再加上 20 条最新专项 badcase。

      每条训练数据包含对话历史、用户最新消息、分类规则和四个候选选项。模型需要根据对话内容选择正确的选项字母。例如:

        Q. 售前
        M. 售后 
        F. 其他问题 
        W. 意图不清

        训练目标只保留正确答案对应的一个字母。推理时同样只生成一个 token,因此生成长度固定,不需要解析长文本。

        这次训练数据分别按固定映射和动态映射构建。

        本轮的固定映射,是同一个 case 在不同 epoch 中使用同一组选项;不同 case 之间仍然随机映射,不是 V1 那种所有样本共用同一张字母表。动态映射则让同一个 case 在不同 epoch 中也换一组选项映射,并作为新的训练数据。我们是在构造数据时生成不同映射的版本,再调整训练数据的组织方式,让每个 epoch 读到对应版本。

        如果把四个业务标签分别映射到 26 个字母中的不同字母,只计算标签和字母的对应关系,理论上可以得到:

          26 × 25 × 24 × 23 = 358,800

          种映射。如果再把四行选项在 prompt 中的排列顺序单独计算,完整的 prompt pattern 是 358,800 × 4! = 8,611,200 种。实际训练不需要覆盖所有组合,动态映射主要是避免模型把业务标签和某个固定字母绑定。例如固定使用 A=售前 时,模型可能同时学习业务语义和字母先验;动态映射后,同一个售前 case 在不同训练数据中可能对应 A、Q、M 等不同字母,模型需要更多依赖输入和选项内容进行判断。

          我们也给同一份验证数据构造了三组不同映射,观察同一个 case 换一组字母后是否仍然得到相同的业务标签。这次还没有单独统计三组映射的一致率,后面可以继续补充。

          两阶段训练。

          第一阶段使用通用分流数据训练,主要学习整体业务标准。第二阶段使用历史 badcase 和新业务边界 case 继续训练,重点处理退款权益、红包、物流赔付、上下文继承和意图不清等问题。

          不同方案的结果如下:

          模型版本

          四分类准确率

          线上实际分流准确率

          最新专项 badcase(四分类)

          V4 Stage 1

          79.41%

          93.55%

          4 / 20

          V4 基线(Stage 2)

          80.20%

          94.57%

          5 / 20

          V5 固定映射 Stage 1

          79.07%

          93.89%

          18 / 20

          V5 动态映射 Stage 1

          79.86%

          93.78%

          19 / 20

          V5 固定映射 Stage 2

          79.19%

          95.48%

          20 / 20

          V5 动态映射 Stage 2

          82.35%

          95.81%

          20 / 20

          我们使用的 V4 基线已经是 Stage 2 模型,所以分析训练收益时,要把 Stage 1 和 Stage 2 分开看。V4 从 Stage 1 到 Stage 2,四分类和实际分流分别提升 0.79pp 和 1.02pp;V5 固定映射分别提升 0.12pp 和 1.59pp;V5 动态映射分别提升 2.49pp 和 2.03pp。

          同阶段比较,Stage 1 的动态映射相对固定映射,四分类提升 0.79pp,实际分流下降 0.11pp;Stage 2 的四分类提升 3.16pp,实际分流提升 0.33pp。这次重新实现后,动态映射与 hardcase Stage 2 的组合取得了最好的效果,尤其是四分类指标。我们目前只跑了这一轮训练,还需要重复实验,确认这个收益是否稳定。

          两组准确率差异比较大,是因为我们线上最终只有售前 Agent 和售后 Agent 两个承接方。售前进入售前 Agent,售后、其他问题和意图不清都进入售后 Agent。后三类之间预测错误会影响四分类准确率,但不会改变实际路由。所以我们一直保留两组指标:四分类看模型是否理解业务标准,实际分流看最终有没有交给正确的 Agent。

          部署精度问题。

          这次部署时,我们发现同一个 checkpoint 在 RTX PRO 5000 上的评测结果与单测、H20 不一致,V4、V5 多个 checkpoint 都受到影响。切回 H20 后才稳定复现,所以最后统一在 H20 上做对比。

          这个坑对单 token 分类特别直接。LLM 生成文本时,某一步的 token 排序变了,后面还有继续生成的空间,有时能靠上下文把意思“圆”回来,最终表达未必有明显变化。当然,这不是说生成任务不受精度影响,只是中间某个 token 的变化不一定直接改变最终结论。我们的分流没有这个余地:取的就是第一个输出位置的候选 logits,最大值对应哪个选项,就走哪个业务分支。候选排序一旦翻转,分类结果也就变了,没有后续 token 可以补救。排查下来,不能只确认 checkpoint 相同,还得对齐卡型、推理引擎、量化配置、prompt 模板、候选 token 和并发方式。

          这套 7B 分流模型经过两次双十一压测,均能稳定支撑千级 QPS,平均响应时间约 55ms,P99 约 150ms,能够满足客服链路高并发、低延迟的分流需求。

          04

          从分流模型的视角再看 Jev

          从公开接口看,Jev 和淘小蜜分流模型的共同点是:都把自然语言理解转换成有限候选上的打分问题,不依赖长文本生成,最终结果可以直接进入代码逻辑。

          两者的差异也比较明显。分流模型针对固定的四类业务标签训练,领域范围比较窄;Jev 的目标是支持运行时定义的问题和候选,并且提供 Choice、Score、Noul 三种统一接口。分流模型返回的是业务标签和候选相对分数,Jev 还强调经过校准的 probabilities 和 confidence。[1][2]

          关于 Jev 模型结构的判断。

          结合我们的分流实践和社区复现,我个人更倾向于 Jev 沿用语言模型的候选 token logits 来计算结果,而没有再接一套单独的分类 head。这里说的 logits 特指已有 lm head 输出的 vocab token 分数;分类 head 也会输出 logits,真正的区别在于用哪个输出层,以及如何训练。

          这个判断主要来自两个观察。首先,Choice、Score、Noul 的核心数值都能从候选分数计算出来;其次,SemIf 和 open-bonsai-jev 已经验证普通生成模型可以通过这条路线完成运行时候选判断,我们自己的分流训练也跑通了。[4][5] 在这个基础上,把单一业务的分类数据换成大量不同领域、不同候选和问题类型的通用分类任务,再用 RLCD 约束决策概率,是我觉得比较可能的一种方案。

          不过这些是我的猜测。TypeSafe 目前公开的是新架构、并行 sampler 和 RLCD,没有公布输出层和训练配方。[2] Jev 的多问题并行能力也需要推理侧的专门设计,不能只靠“取一次 logits”解释全部效果。

          候选分数和概率校准。

          社区复现中比较值得关注的是校准问题。open-bonsai-jev 在 WANLI-256 上的实验显示,Bonsai 2 27B 的准确率为 74.6%,平均置信度为 89.9%,原始校准误差为 0.176。通过温度缩放,校准误差可以降低到 0.088,但准确率不会变化。[5]

          这说明直接对候选 logits 做 softmax 可以得到一个总和为 1 的分布,但是这个分布不一定能直接解释成真实正确率。温度缩放可以让 0.8 更接近“同类样本中约 80% 正确”,但不能把错误答案改成正确答案。

          我们目前用 std_sigmoid 和 top2 分差筛选 hardcase,更多是利用相对分数。后面如果要按分数决定是否转人工、是否再调用大模型,我们还需要单独做校准,验证每个分数区间的真实准确率。

          动态选项映射还需要看什么。

          这次我们已经实现不同 epoch 使用不同映射,验证集也准备了三组映射,接下来主要看预测是否稳定。字母 token 在基座模型中已有预训练先验,不同字母的初始概率可能不同;对于得分接近的边界 case,换一组字母仍然可能改变结果。

          后面我们可以继续看几个方向:

          1. 在现有三组验证映射上增加一致率和最差映射准确率,而不只统计平均准确率。

          2. 对比线上固定映射和随机映射,确认随机映射是否真的带来收益。

          3. 对候选 logits 做温度校准,而不是直接把 softmax 或 std_sigmoid 当成真实概率。

          4. 对低 margin case 做二次判断或转交更大的模型。

          5. 如果后续实验发现普通字母偏置明显,再考虑扩展 special token 或独立分类 head,而不是提前假设一定需要修改词表。

          从业务内的规则适配,到跨任务的泛化。

          我们的分流模型并不是只能识别训练时固定的四个标签。前面的物流 case 就展示了,只改 prompt 中的规则和候选,也能把物流问题从售后中拆到新增类别。因此,调整业务标准不一定需要重训,可以先改 prompt,再用评测集验证;如果效果达不到要求,再补数据和训练。但目前我们验证得最充分的还是客服 Agent 分流,单个 case 的适配成功,不代表换到其他业务或任务后也能稳定工作。

          Jev 想覆盖的范围更广:调用方在运行时给出 state、问题和选项,同一个模型既能做 Choice,也能做 Score、Noul,还能一次处理多个独立问题。[1][2] 我更佩服的是它想实现的跨任务泛化:不只是客服内调整分类边界,而是换到搜索排序、风险判断或游戏决策,也尽量不需要为每个任务单独训练。这是它的目标,不是所有场景都已经验证可用;Laya 在不同任务上的效果差异也提醒我们,接入时仍然要拿自己的业务数据测试。[9][10]

          沿着上面的猜测,多任务训练应该很重要。我们的训练主要围绕客服四分类,随机映射能削弱固定字母和位置的捷径,但任务和领域的覆盖仍然有限。如果训练中混合大量通用分类任务,让候选数量、标签描述、问题类型和 state 都变化,模型就更有机会把“根据当前标准判断”的能力迁移到更多场景。我的理解是,RLCD 的目标还包括让模型更准确地表达不确定性,但多任务训练和 RLCD 各自对泛化贡献多少,仍要等官方训练细节。[2]

          System One 模型可能带来的变化。

          现在不少 Agent 把所有判断都交给负责回答的大模型:先读对话,再生成一段分类结果,随后决定查不查工具、要不要转人工,最后继续生成答案。每一步都让同一个模型展开推理,复杂问题确实需要这种能力;但“这句话是不是在催退款”“现在要不要中断输出”之类的判断,在高并发链路里反复消耗推理时间和输出 token。[7]

          System One / System Two 的分工可以更具体:慢模型负责理解复杂诉求、规划步骤、生成最终答复;快模型在每轮对话和执行过程中处理分流、守卫、工具路由、打断和结果校验。对后者来说,输出只需有限选项和可用的分数。TypeSafe 报告 Jev 在其测试条件下端到端为 70—500ms,并给出较低的输入 token 单价;这些是官方报价和演示指标,不能直接推出我们链路上的节省比例。[2]

          我们希望快模型能识别自己不确定的 case:稳定的简单 case 直接进入代码分支,低置信度的交给慢模型或人工。如果新业务没有学好,快模型先跑一遍,慢模型再重做一遍,RT 和成本反而增加。所以接入时,我们还会一起看准确率、概率校准、覆盖率、回退比例,以及整条 Agent 链路的 P99。

          实时 UI 操作、游戏和机器人也可能采用类似分工:慢模型定目标,快模型在目标确定后判断继续、停止、重试或切换动作。不过 Doom 和浏览器演示说明的是这种接口能跑起来;它们尚不足以证明模型能接管开放环境中的完整规划。[2]

          05

          结合客服业务场景的思考

          客服可能比游戏和 Computer Use 更适合这类模型,只是展示效果没有那么直观。用户发送一条消息后,系统往往需要先后完成分流、意图识别、双工判断、风险识别和工具选择,然后才进入回答生成。这里的大部分判断输出空间有限,但是每轮对话都可能执行,对响应时间和调用成本都比较敏感。

          以小蜜现有模块为例,可以大致对应到 Jev 的三种接口:

          客服判断

          适合的输出

          示例

          Agent 分流

          Choice

          售前、售后、其他问题、意图不清

          双工判断

          Choice

          ignore、continue、interrupt、discard、force

          意图或工具选择

          Choice

          查询订单、申请退款、修改地址、转人工

          是否需要转人工

          Noul

          当前问题是否已经超出 Agent 能力范围

          用户情绪、风险和问题复杂度

          Score

          从低到高的有序等级

          双工判断是一个比较典型的例子。客服 Agent 在响应任务未完成时收到用户的新消息,需要很快判断是忽略、继续回答、中断当前回答、丢弃结果,还是强制执行新的动作。这类判断如果每次都调用一个需要生成 JSON 的通用 LLM,延迟和成本都比较高;如果写成规则,又很难覆盖口语、省略和上下文相关的表达。

          一种可能的做法是让多个模块共用一个 System One 模型。请求中只传一次对话、订单和 Agent 状态,再并行提出多个问题:应该路由到哪个 Agent、用户是否打断了当前回答、当前意图是什么、是否需要转人工。TypeSafe 的接口本身支持对同一份 state 提出多个相互独立的问题,并把减少重复上下文计算作为主要能力之一。[1][7][8] 具体能减少多少延迟,还需要在客服的真实输入长度、并发量和部署环境中重新压测。

          对我们来说,共享模型还能减少重复部署和上下文处理,方便统一回流 hardcase。不过一次更新也可能同时影响分流、双工和意图判断,所以我们仍然要给每个模块保留独立评测集、阈值、监控和回退方案。

          从这个角度看,Jev 对客服的价值不一定是替代负责回答的 LLM,而是承接回答前后大量高频决策。LLM 继续处理知识查询、复杂推理和答案生成,System One 模型负责尽快判断“接下来应该做什么”。客服本来就是一个对 RT、成本和稳定性都比较敏感的场景,这部分能力可能比再换一个更大的回答模型更容易产生实际收益。

          回到我们这一年的实践,用大模型做分类任务是可行的。把输出缩成一个 token 只是开始,真正影响效果的是标签标准、样本分布、字母和顺序 shuffle、线上难例回流,以及二阶段训练。这次重新实现动态映射后,又进一步提高了效果。

          对 Jev,我更倾向于它也是从语言模型的候选 logits 出发,通过大量通用分类任务和 RLCD 把能力扩展到更多领域。如果这个判断接近实际,那么我们下一步值得尝试的,就是把分流、双工、意图判断等任务放在一起训练,看看能否用一个模型承担更多客服决策。

          最后,感谢一起参与分流模型建设和迭代的同学。这篇文章主要聊算法背后的逻辑,但从业务标准到模型上线,离不开工程、产运和算法同学的共同投入。

          参考资料

          [1] TypeSafe AI. Primitives (Questions),Choice、Score、Noul 的定义、输出字段和多问题调用方式https://docs.typesafe.ai/primitives

          [2] Diogo Almeida / TypeSafe AI. Introducing System One Models & Jevhttps://typesafe.ai/blog/introducing-system-one-models-and-jev

          [3] TypeSafe AI. Choice,Choice 选项数量、返回字段和分层分类说明https://docs.typesafe.ai/primitives/choice

          [4] TheoLeeCJ. SemIf,直接读取候选 logits、共享 prefix 和复现实验https://github.com/TheoLeeCJ/SemIf

          [5] Nicolai Lassen. open-bonsai-jev,普通字母 token 的 next-token logits、WANLI-256 和概率校准实验https://github.com/NicolaiLassen/open-bonsai-jev

          [6] AlexWortega. openjev,Qwen3.5 序列分类、NLI 训练和候选 rerank 方案https://huggingface.co/AlexWortega/openjev

          [7] TypeSafe AI. Example use cases,模型路由、guardrail、客服、搜索和实时应用等用例https://docs.typesafe.ai/concepts/use-case-map

          [8] Jev 中文文档,Choice、Score、Noul 与 confidence 的中文说明https://bald0wang.github.io/jev-docs-zh/

          [9] NandhaKishorM. Laya,编码器底座、typed decisions 与使用边界https://github.com/NandhaKishorM/laya

          [10] Laya 项目. Benchmarks,零样本、微调、客服分流与延迟实验https://github.com/NandhaKishorM/laya/blob/main/BENCHMARKS.md

          [11] Necati Demir. I Tested Laya After the Jev Announcement. Then I Fine-Tuned It.https://n.demir.io/articles/testing-and-fine-tuning-laya/

          [12] JhouCode. Laya fit check,独立复测代码与数据说明https://github.com/JhouCode/laya-fit-check

          图片

          图片

          欢迎留言一起参与讨论~

          跳转微信打开

          从进化到泛化,RSI 四大前沿框架如何实现 Agent 自动调优

          2026年11月9日 18:08

          飞樰 2026-11-09 18:08 浙江

          本文解析了 Google 提出的四大 RSI 框架,分别从无金标进化、进化机制自优化、正则化防过拟合及面向对象架构解耦四个维度实现了 Agent 的自动调优。

          这是2026年的第 78 篇文章

          ( 本文阅读时间:约 20 分钟 )

          前言

          在上一篇文章《深度解析 RSI:当 AI 开始实现自我迭代提升 》里,作者系统性介绍了 RSI(递归自我改进) 的背景理论和实现架构,并介绍了近几年关于 RSI 各方面的一些优质研究,涵盖 Skill、Context、Memory、Tools、Harness、Model、训练算法、进化机制等层面的探索。

          不过整体来看,之前的研究大多偏向于“子模块的局部进化”,甚至严格来说并不能算真正的 RSI,只能说是广义上的自进化,因为有些研究的优化系统本身是无法进化、无法改进的。

          然而,就在刚刚过去的 10 月份,Google 在短短一个月内接连发表了 4 篇 RSI 相关论文,可以说是一次集中爆发式的输出。虽然目前很多都还是预印本,但我仔细读下来发现,这 4 篇文章内容在 RSI 方面的一些探索确实有着比较大的参考价值,而且其中还有两个研究工作已经在 Github 开源了相应的代码。

          这四篇文章的发布时间线其实非常紧凑。最早的一篇叫 RRSI,虽然 9 月份就提交了第一版,但 10 月份又更新了几个版本(下文取最新版进行介绍);紧接着在 10 月 9 号,谷歌一口气发了两篇:一篇叫 Harness²,另一篇叫 Evo²;然后,到了 10 月 20 号,又发表了一篇名为 OO-Harness 的文章。从团队归属来看,这 4 篇文章里有 3 篇来自 Google Cloud AI Research,还有 1 篇来自 Google DeepMind。它们分别解决了 RSI 进化过程中的不同痛点,彼此之间其实是有内在联系的,所以我就把它们放在一起给大家串起来讲。

          本文我们将深度分析 Google 的这 4 篇新作,看看他们具体是怎么做 Agent 的 RSI 自我迭代的,又分别从哪些角度实现了真正的自我进化,从而让 Agent 的效果越来越好。

          01

          Harness²:在没有“金标答案”时,Agent 如何自进化?

          Harness² 解决的是什么问题?

          首先,我们需要讨论一个最基本的问题:究竟如何实现 Harness 的 RSI 自进化?

          这几篇论文里主要回答了这个问题的就是 Harness²。当我们在做 Agent Harness 的自进化时,其实主要就是在修改 Harness 的几个核心部分,比如 System Prompt、Skill、Tool、Memory、Sub-agent 等等。这些东西组装起来,本质上就是一个“完整的工作处理过程”。也就是说,具体遇到什么问题的时候,应该调用哪些工具或者 Sub-agent,然后应该怎么去诊断、处理、回复,这 1、2、3 步的约束都要写清楚,包括对一些具体情况的讨论也要覆盖到。所以,Harness 的自进化,更多时候其实是在沉淀我们具体任务里的工作过程,也就是搞清楚“一个任务到底要怎么去解决”。

          举个例子,如果给医生做一个 AI 诊疗辅助 Agent,当用户说“我咳嗽了”,这是一个症状,诊疗 Agent 应该知道在“咳嗽”的场景下,如何定位到具体的病因或解法。譬如是否需要抽血、做检查,拿到相应结果之后做出判断,最终根据“根因”来提供“对症下药”的方案——这就是一个基本的业务逻辑。

          也就是说,当我们想要去调优一个 Agent,「验证」是一个非常重要的环节,最常见的方法是评测。我如果有一个金标集合(GroundTruth),可以拿到每个场景对应的真实解决方案或参考值,这样就可以把 Agent 跑出来的结果和这个金标进行对比,很容易发现其中不正确的部分,再反查根因,找到 Agent 走偏的原因,然后进行修复和优化。

          但当我们真正去落地 RSI 或者做工程化的时候,就会发现金标的获取是非常难的。根据标准答案直接评价当然是一种理想状态,可现实中大多时候这部分内容是缺失的。在没有拿到标准答案的情况下,Agent 如何实现工程化落地?

          Harness² 的目标就是想要解决这个问题:在一个新任务没有可靠的评分器、或者没有相应的“金标”参考答案的情况下,如何优化 Agent,使其能更好地解决新任务。继续引用前文中咳嗽的例子,如果没有标准答案,Agent 诊断出一个结论以后,如何判定这个结论是否正确?或者如何判定 Agent 的运行是否符合你的预期?

          要知道,在实际工作和生活中,许多场景是没有所谓的金标/参考答案的。在此情形下,如果 Harness 还能通过自进化找到一个更好的解答,这就是一个非常有价值的研究方向。所以,Harness² 就是想定位在这个角度,专门解决“无金标场景下的 Agent 自进化”这一问题。

          Harness² 的六步自进化流程详解

          如果没有金标,Harness² 具体是怎么做的呢?

          首先,Harness² 框架中模型参数是冻结的(Frozon),也就是不训练模型参数的意思。输入给 Harness² 这个自进化系统的信息主要包括三块:当前的任务、初始 Harness 的设计、可修改文件的范围(Harness 中可以改的部分,比如 Skill Prompt、Skill、工具等等),以及此前累计的各种改进经验。这些改进经验都是从过往任务里抽取出来的,记录了具体哪些地方可以优化。这里要特别强调一点:在 Harness² 这篇论文里,是不去优化模型本身的。里面的模型参数都是冻结的,不调优模型,只改进 Harness。

          总的来说,Harness² 运行过程大致可以总结为 6 步。

          第一步:跑一版原始 Baseline。先按照最初版的 Harness 跑一遍任务,留下 Agent 的轨迹,包括工具调用的操作记录、出现的错误、产出的结果等等。这一步作为一个对照项,为后面的改进提供基准。

          第二步:从两个角度提出修改方案。

          • 通用层面的工作方式:比如通用的执行流程、System Prompt 的约束、工具调用的逻辑和结果等,看看是不是需要做一些调整。

          • 领域知识的更新:很多时候工作流程本身没问题,但里面的知识可能需要更新了。这是流程不变,但需要持续对领域知识的补充和迭代。

          第三步:分别验证两份修改。把“通用方式的修改”和“领域知识的修改”各自独立跑一下同一个任务。看看这些改法是不是真正能改善最终结果,同时也要检查有没有引入新的问题。

          第四步:组合与整合。如果前面两步都 OK,就根据记录把两份修改进行组合。这时候要去比较原来的 Harness 和新的 Harness,厘清哪些是有依据的修改、有没有冲突。如果存在冲突的话,继续调整,再完成整合。

          第五步:组合后整体跑一遍。为什么要单独做这一步?因为有可能两者单独跑都还好,但是一组合就会出现新的问题。真实的 Agent 在实际运行时本来就是组合运行的,所以组合起来跑一遍,能尽量发现潜在的冲突,避免上线后出问题。

          第六步:回顾并保存经验。最后一步就是把采用的 Harness 版本、之前遇到了哪些问题、经过哪些尝试、最终结果怎么样,这些经验全都保存下来。以便后续迭代时可以随时查阅和复用,让自进化形成一个真正的闭环。

          Harness² 的三个核心设计亮点

          从论文中可以提炼出 Harness² 非常值得学习的三个关键点。

          第一, 没有金标答案,依然可以从 Trace 中挖掘优化点。在没有参考答案的情况下做 Agent Harness 自进化确实很难。比如用户咳嗽,AI 可能给出感冒、流感等多种分析,没有医生最终拍板,很难判断谁对谁错,但这不代表无事可做。

          即使不知道正确答案,我们依然可以从 Agent 的运行逻辑和 Trace(轨迹)里发现问题:

          • 检查过程合理性:如果 Agent 没做任何检查、没调用工具就直接武断下结论,那大概率是模型幻觉或自由发挥,这种流程大概率是有问题的。

          • 校验工具执行细节:工具调用是否成功?有没有异常?参数是不是填错了?反馈结果里是不是漏了关键项?比如咳嗽需要查血常规,如果发现指标不全,就可以去优化检查项,增加必要的检查。

          • 精简错误路径:有时候 Agent 调了很多工具,中间走了弯路,但最终结果是对的。那这些明确错误的探索路径就可以被精简掉,让模型直接调用最后一轮有效的工具或拿到关键结果来解决问题。

          也就是说,从工作流程约束、指令遵循效果、工具参数校验等维度,我们可以从 Trace 里挖掘出非常多可优化的点。

          第二,“通用不变量”与“领域知识”分层优化,避免跷跷板效应。这是 Harness² 一个非常聪明的设计,它把 Harness 的修改分成了两层:

          • 通用不变量层:比如 System Prompt、工具的抽象封装、通用的 Skill 框架等。

          • 领域特定信息层:比如领域知识、领域专属 Skill、特有工具等。

          这两层是分别优化、分别测试的。比如我可以固定工具不变,只改领域知识看效果;或者固定领域知识不变,只改通用逻辑看效果。通过这种控制变量的方式,就能精准定位问题来源。如果两层混在一起调优,很容易出现“跷跷板效应”:这个 Case 修好了,另一个 Case 却变差了,而且你还不知道是哪部分引起的。分层测试就能有效避免这种情况,让调优更有针对性、更可解释。但最后还是会再做一次组合验证,目的是为了避免两者之间有冲突,导致合并之后出现问题,毕竟进化后的 Harness 肯定是组合使用两者的。

          第三,单条 Trace 提建议 + 全局优化器做决策,防止 Corner Case 带偏。除了对象分层,Harness² 在任务维度也做了分层:

          • 单任务层面:每一条 Trace 都会提出自己的改进意见,比如“根据这个 Case 应该调 Prompt”、“根据那个 Case 应该改工具”。

          • 全局优化器层面:所有单条建议会汇总到一个统一的优化器,由它来做聚合和决策,判断哪些调优要接受、哪些要拒绝、哪些逻辑可以合并。

          这样做的好处是避免单个极端 Case 或 Corner Case 引起整体走偏。这一点和 Trace2Skill、SkillOpt 等的逻辑非常像,都是通过聚合的方式来保证进化的稳健性,不让个别异常轨迹影响整体的进化效果。

          02

          Evo²:让“进化机制”本身也能进化

          Harness² 主要解决的是 Harness 如何自进化的问题,那么,第二篇论文 Evo² 的定位是什么呢?

          Evo² 解决的是什么问题?

          刚才讲的 Harness² 主要是在解决 Harness 各个组件本身的进化问题。不知道大家有没有想过:这套负责进化的机制本身,是不是也需要进化? 也就是说,“如何进化”这件事也要能够“进化”(套娃了),是 Evo² 这篇论文的核心立意。

          当然,Evo² 本身既能优化 Harness,也能优化进化方式自身。不过优化 Harness 的部分跟 Harness² 差不多,本文暂时不作展开。以下讨论重点在于,它是如何让“负责进化”的部分变得越来越有经验的。

          Evo² 进化“改进模型”的做法

          Evo² 的具体做法是通过训练的方式来进化,大致流程如图所示。

          • 生成 Trace 并对比:基于已有的 Harness 提修改方案,选一个版本跑 Agent Trace,再跑修改后的 Harness,对比新旧版本的 Trace,看新版是不是比老版跑得好。

          • 分析改进过程:用模型去分析这次改进是否真的变好了。如果没变好,问题出在哪?下一步该怎么修正?然后做决策。

          • 保存路线与经验复用:记录每一个版本以及版本之间的关系,让一条进化路线上发现的方法有机会迁移到另一条路线里。本质上是希望发现进化过程中的共性规律。

          • 把经历变成教材:整理修改、分析、修正及其结果。格式不合格的会尝试修复,修复后再验证。把这些数据都收集好之后,就可以用来训练这个“改进模型”。

          • 训练与迭代:先学习合格的范例,再通过反复练习让模型倾向于提出能带来真实改进的方案,然后进入下一轮循环。

          在这个过程中,提修改方案时主要看新版本比老版本改善了多少;验证时则要求修正必须比修正前更有效。论文里还特别强调了一点:要核对新办法是否真正被执行了,不能只是看起来有变化,实际上跑起来并没有落地。

          经过这套流程,最终会得到两类东西:更好的 Harness、更会提出修改和分析结果的“改进模型”。

          需要特别说明的是,并不是线上每一个 Agent Trace 都拿去训练一次。而是从海量 Trace 里提取出那些真正能让 Harness 更好进化的经验,用这些高质量的经验去学习。这才是 Evo² “让进化本身进化”的精髓所在。

          Evo² 把“改进过程”本身变成可迁移的经验

          还是拿 AI 辅助医生 Agent 来举例。Agent 得出的结论不一定准,所以我们引入另一个 AI 作为“改进顾问”,去检查执行过程、提出改进建议。但这个顾问自己未必擅长医疗诊断,它也可能找错问题、提无效需求,或者仅仅看到评测分数上涨就误以为有效。如果它的分析过程比较死板,哪怕拿再多数据去训练,也未必能真正提升。

          Evo² 的关键洞察在于:以前尝试过的所有修改和真实结果,无论有没有提升,都是非常有价值的训练素材。 哪些建议真正带来了改善、哪些问题找对了、哪些容易出错、哪些改动会产生冲突——这些信息都能帮助优化“改进模型”本身。所以 Evo² 的定位就是:通过收集改进过程中的各种数据,来训练一个越来越会改进的模型。

          为什么要保留不同的进化分支?如果你只保留最新版本,确实能得到一个相对更好的 Harness,但你会丢失“它是怎么改过来的”这段历史。而不同分支上的修改方法,很可能在其他场景下也有用。如何把一个分支上有用的东西学到,并迁移到另一个分支上,这正是 Evo² 特别想解决的问题。

          没有模型训练环境怎么办?在实际业务中,很多时候我们并没有模型训练的环境,很难真正去微调或训练一个模型。那 Evo² 的思路还能不能借鉴?完全可以。我们可以用一个“改进 Harness”来做改进任务,通过它来调优目标 Harness,同时把中间的所有信息都记录下来:改了哪些地方、前后有没有变化、问题点在哪、方案是什么、哪些有效哪些无效。这些都可以抽象成相对通用的改进经验,让改进 Harness 自己记下来。当下一次运行其他任务、改进其他 Harness 时,这些经验就能迁移过去,“这样做大概率能变好”、“那样做大概率不行”。这就实现了“改进能力本身”的调优。

          这个过程其实和我之前分享过的 SkillOpt 里的逻辑非常像。SkillOpt 除了优化 Skill 本身,还会优化“用来优化 Skill 的那个 Skill”,也就是所谓的 Meta-Skill。通过这种方式沉淀出通用的改进经验,再作用到其他任务和版本上。这是 Evo² 这篇文章一个非常重要的方法论,也非常值得我们在实际落地中参考和借鉴。

          03

          RRSI:用正则化解决自进化的泛化难题

          RRSI 解决什么问题?

          有了前面 Harness² 和 Evo² 两个方案,其实你已经可以搭出一套比较通用的 Harness RSI 自进化框架了。但在实际跑起来之后,你很可能会遇到一个痛点:

          Agent 在高频场景的任务上调优后分数确实越来越高,但换到低频场景或其他任务上,效果就不明显甚至变差了。 也就是说,模型在常见场景上“卷”出了高分,但泛化性不行。这也很正常,因为经验是基于高频问题产生的,未必适用于其他场景。

          那怎么解决这个问题?如何让自进化的内容泛化性更强? 这就是 RRSI 论文想要解决的问题。这里的 RRSI 是“正则化的递归自我改进”(Regularized Recursive Self-Improvement),前面多出来的 R 代表 “Regularized”(正则化)。

          RRSI 的七步正则化进化流程

          RRSI 系统需要初始 Harness、可评分的任务、执行和修改记录、每次调用的 Token 量等作为输入,模型层面不做训练。RRSI 会对搜索轨迹进行正则化约束,但并不限制潜在的编辑空间,提议端(Proposal-side)的约束控制搜索能力的使用方式,而选择端(Selection-side)的约束则决定哪些改进可以被固化为永久状态。它的运行大致可以分为下面的步骤。

          • 测试初始 Harness 的表现和波动。不是只测一次,而是尽量多测几次,找到稳定性问题。偶发的不稳定还好,如果经常不稳定,那就是大问题,需要先摸清基线。

          • 规定本轮改动幅度,前期探索、后期收敛。RRSI 认为前期可以多探索、多改一些地方,但后期要慢慢收敛。同时,成功的经验、失败的教训、没尝试过的方向都要记下来,为后续决策提供依据。

          • 提出有理由的候选改动。每一项独立改动都必须说清楚准备解决什么问题,不能无限叠加不同方法。否则探索虽然多,但可能永远收敛不了,一直在加东西。

          • 完整评分前先检查改动合规性。先看实际文件有没有夹带老任务的答案、有没有只服务于某些个例场景的信息、有没有与现有约束冲突的额外声明。如果有这类“刷分”性质的个例信息,先修掉;修不掉就直接放弃这条改动。我们不需要为了提高分数而加入过于个性化的东西。

          • 真正运行任务并评估。跑一遍任务,看评测结果和模型用量情况,拿到真实的反馈数据。

          • 按规则决定保留还是回滚。既要看评测分数是否上涨,也要判断是不是正常波动(比如没达到之前水位但属于合理范围)。还要看额外费用和探索价值。不合适就否掉这次进化,保留旧版本;整体效果确实变好了,才保留新版本。

          • 记录、删减冗余、更换验证集检验泛化。所有尝试历史都留下来,但最近几轮没太大帮助的改动可以删减掉。最后固定一个版本,换一套验证集去测试效果,看泛化能力是否真的变强了。这一步是 RRSI 区别于前两者的关键:通过更换验证集来强制检验泛化性,而不是只在同一套题上刷分。

          RRSI 如何来约束防止进化“过拟合”

          从整个流程中我们可以非常明显地看到,RRSI 最核心的点其实就是加了一层约束。这也是所谓“正则化”的含义,正则化的主要目的就是“增加约束”。如果你不加任何约束,直接去做 Harness 的调优进化,最大的问题就在于:Agent 为了把评测分数卷到极高,一定会做过度的针对性适配。用算法模型领域的概念来说,这就叫“过拟合”(Overfitting)。

          所谓过拟合,其实在传统机器学习里就有的概念了,就是模型为了拟合数据的程度更高,刻意往更加迎合当前的数据方向学习。举个例子,在评测集里“出现咳嗽,就是感冒症状”的比例比较高,于是 Agent 进化出的结果就变成了“只要见到咳嗽,就得出感冒的结论”。这样在当前评测集上分数确实很高,但这其实是个错误判断,它只是因为评测集里感冒样本多而已。一旦换一套新的评测集,咳嗽症状的根因未必还是感冒,Agent 就很容易诊断错误。这就是典型的“调优阶段效果好,换验证集就变差”。

          在机器学习里,解决过拟合最好的办法就是加 L1 或 L2 正则,让拟合函数不要过于扭曲奇怪。RRSI 正是借鉴了这个思路。

          RRSI 加的这些约束,本质上就是不让 Agent 记录那些非常个性化、非常不通用的信息,而是引导它去沉淀真正通用的知识。

          还是拿咳嗽举例:Agent 可以学到“咳嗽大概率是感冒,应该重点排查感冒相关指标”,但不能写死成“咳嗽就一定是感冒”。因为咳嗽也可能是慢性咽喉炎或其他疾病引起的。

          所以从这个角度来讲,RRSI 所有约束的核心目的,就是为了监督整个进化过程,防止它过分贴合当前评测数据而牺牲泛化性。这才是 RRSI 最想强调的关键点。

          04

          OO-Harness:面向对象思想解决组织与复用难题

          OO-Harness 解决的是什么问题?

          经过前面三篇论文的铺垫,大家会发现 Harness RSI 自进化基本上已经能跑起来了:它能在不过拟合的前提下让 Agent 能力越来越强,也能让负责改进的 AI 越来越有经验。但这时候,依然又会出现新问题:Harness 如何组织的问题。

          比如有些任务分支很多,哪怕你固定了不变量、只调领域知识,可能在当前任务上变好了,但在另一个任务上,对不变量的调整反而会让效果变差。一套统一的 Harness 未必能适应所有场景。除了在评测时验证之外,我们还能不能从组织结构上做解耦?

          比如,我可以有一套主流程处理常规情况,同时分化出一套专门解决特殊问题的子流程。像感冒咳嗽用基础 Harness,遇到异常咳嗽时,就在感冒咳嗽的基础上分化出一个“异常咳嗽 Harness”,它包含感冒的处理逻辑,但又加了额外的诊断步骤。非必要不用这个特殊版本,但一旦遇到棘手情况就能顶上。

          这种思路其实非常像软件工程里的面向对象设计。所以这篇论文就叫面向对象的 Harness(Object-Oriented Harness,简称 OO-Harness)。

          OO-Harness 想解决什么问题?不同任务是有差别的,一套统一流程未必全能解决;但如果每类场景都单独建一套 Harness,又会重复造轮子、成本极高。能不能通用部分保持一套,特殊部分解耦出来,同时又能复用通用能力? 这类问题其实在软件工程的面向对象里早就被解决过了。

          面向对象编程的三大特性:封装、继承、多态,正好对应了 Harness 组织的需求:

          • 封装:把逻辑封装成一套 AI 系统、一个入口,调用时统一从这个口子进来,内部细节对外透明。

          • 继承:有父类和子类的概念。子类继承父类的核心功能,同时加入自己的特有逻辑。父类已有的能力不再重复开发。这正好解决了我们的痛点:绝大部分 Agent 的流程都一样,只是每一种都多了一些特殊处理,那就把相同部分抽象成父 Agent,特殊逻辑放在子 Agent 里,建立父子继承关系。

          • 多态:同一个入口下,不同场景可以分化出不同的处理模式,实现局部的替换和修改。

          OO-Harness 就是把这套成熟的软件工程思想迁移到了 Agent Harness 的组织与进化上,让 Harness 既能复用、又能灵活分化,避免“一套打天下”或“重复造轮子”的两难困境。

          OO-Harness 的运行机制与落地启发

          OO-Harness 从基础 Harness 到专有版本,整个进化过程大致分为以下几个步骤。

          • 跑基础 Harness 收集 Trace:先用基础 Harness 跑各种任务,保留工具调用记录和错误 Trace。

          • 按任务归类分组:把可能受益于同一种改进的任务放在一起,或者按共同的失败报错归类,这样更适合做针对性调优。

          • 提出可解释的改动并生成新版本:挑一组任务和一个已有 Harness 作为基础,让改进 AI 查看记录、提出一项能解释的改动,写成可执行的新版本。这里既可以改进基础 Harness,也可以分化出一个继承自基础版本的专有 Harness。

          • 在目标任务组上验证候选:只在对应的任务组上跑各种版本,对比看是否有真实提升。

          • 保存新版本的来源与使用条件:记录哪些能力复用旧版、哪些是新增的,成功失败的都保留,总结“应该怎么改”和“什么时候选这个版本”。

          • 继续搜索并固定优质版本:持续探索新版本,找到变好的就记下来并固定。

          这个阶段其实是准备阶段:把 Harness 跑起来,收集改进点,沉淀出基础版本和若干专有版本。

          然后,当新任务进来时,就进入了使用阶段“基础优先,专有兜底”。具体运行逻辑是这样的:

          • 先用基础 Harness 执行:看能不能跑通、跑出答案。如果 OK,问题解决。

          • 基础不行再换专有 Harness:如果基础版本没解决,再路由到专有 Harness。专有版本继承了基础能力,同时包含针对特殊场景的新逻辑。

          • 路由依据是需求特征:根据具体需求判断是否该走专有路径,但一定是基础跑不通之后才触发。

          为什么要这样设计? 因为大多数情况下通用 Harness 就能解决问题,只有 Corner Case 才需要专用版本。这样可以避免大部分场景浪费更多时间,也能防止专用 Harness 在常规任务上反而出现幻觉或跑偏。这是一种防御性的架构思路,大家可以参考,不一定照搬。

          在实际业务中,我们经常会遇到任务有差异但也有相似性的情况。OO-Harness 最实用的启发就是:共用基础 Harness + 少量专用 Harness + 一个 Router。

          没有必要把所有优化都塞进一个 Harness 里,也没有必要动辄训练模型。通过这种解耦拆解,就能解决大部分问题。它的核心经验是:改善靠的是对已有经验的验证结果,而不是每个请求都重新发明一套 Harness;同时又保留了一定的自主性和个性化效果。这种“基础兜底 + 专有增强 + 路由分发”的模式,是一种非常务实且可落地的 Agent 架构思路。

          05

          四个 RSI 框架的核心定位对比

          最后,我们来横向对比这 4 个 RSI 框架的特点和定位。它们其实是从 4 个不同的切面来解决 Agent Harness 自进化问题的,不能简单说谁的效果更好或者谁是“最好”的方案,而是各有千秋,适用于不同的场景痛点。

          框架核心要解决的问题核心逻辑 / 关键动作一句话定位
          Harness²

          没有当前任务的金标时,Harness 应该如何改进?

          先执行初始 Harness,从不同角度尝试修改并记录,找到更优解法,积累经验实现进化。

          无金标场景下的 Harness 自进化基线
          Evo²

          如何优化“负责改进的 AI”,让它越来越有经验?

          提出修改 → 看结果 → 修正,将改进过程的经验用于训练“改进 AI”本身。

          让进化机制本身也能进化(套娃)
          RRSI

          怎么避免在特定评测集上刷高分,却丧失泛化能力?

          通过约束和规则抑制波动与过拟合,提高可复用性,让通用能力真正沉淀。

          用正则化约束防止进化过拟合
          OO-Harness

          不同场景、任务差异大时,如何组织 Harness?

          拆解为通用 Harness + 专有 Harness(继承关系),配合路由分发,实现复杂场景的解耦。

          用面向对象思想解决架构复用与分化

          这 4 个框架分别从 “无金标进化”、“进化器自优化”、“防过拟合”、“架构解耦” 四个维度提出了各自的解决方案。在实际落地时,不一定要全部用上,应该根据自己业务中遇到的具体痛点,选择最适合的组合。还是那句话:天下没有最好的 RSI 进化方案,只有最适合你场景的 RSI 进化方案。

          其实这个过程,也有点像我们常说的 Loop Engineering 和 Graph Engineering。Loop Engineering 本身就是在 Agent 执行过程中加了一个过程循环,通过目标驱动的方式来保障 Agent 的执行效果,让 Agent 表现越来越好。但是呢,Graph Engineering 就是为了防止加了 Loop 之后,模型反而为了目标疯狂去过拟合了,去不停地卷那个分数,从而避免了泛化性的降低。所以你可以理解为 Graph Engineering 其实就是用来监管 Loop Engineering 的,它解决了这个“越练越死板”的问题。关于这部分的详细内容,大家可以看我之前写的《从 Loop 到 Graph Engineering 的演进思考与实战》一文。

          在 RSI 这套体系里也是相同的逻辑。Harness² 是用来解决 Agent Harness 怎么进化的问题,比如要进化哪些点、怎么去拆分;而 Evo² 则用来改进 Harness 的这套进化方法本身的;最后,RRSI 的作用就是去监督 Harness 进化过程中可能会出现的过拟合情况。

          如果调优有了瓶颈,出现了此消彼长的“跷跷板效应”怎么办?这就轮到 OO-Harness 出场了。它的核心思路就是把通用的信息抽象出来,然后把那些确定是个性化的、或者说是过拟合的信息,放到另外一些独立的 Harness 里面去,不要跟通用的混在一起;通过这种解耦合,直接从组织结构上、从架构上就把这个问题给拆分掉了。

          综合来看,这 4 个框架相当于在原有的基础之上持续打补丁,加了一系列后续的改进措施。把这 4 个结合起来,目前来看可以认为这是一套相对完善的、当前最新的 Agent Harness 自进化的方案了。

          当然,在具体业务落地时,哪些是有必要的、哪些可能是过度设计,必须视场景而定。正所谓“天下没有最好的 Agent 架构,只有最适合场景的 Agent 架构”。把这句话映射到 RSI 场景里也是一样:天下没有最好的 RSI 进化方案,只有最适合你当前场景的 RSI 进化方案。

          06

          总结

          由于 Google 这 4 篇论文的整体篇幅确实比较长,本文也只是大概梳理了核心逻辑和思路。有兴趣的读者,强烈建议自行找原文来看看,深入研究其核心设计、具体的实验数据以及那些容易被忽略的细节。

          除了论文本身,其中的 Harness² 和 RRSI 还开源了相应的代码(大家可以去 GitHub 直接查看代码的具体实现,这能帮我们更直观地理解背后的工程逻辑)。我也希望这些内容能够帮助大家在各自的业务场景中探索 RSI,或者在解决 Agent 进化、改进过程中遇到的问题时,能提供更多的参考和建议。

          最后要特别说明的是,这几篇文章都是比较近期的,加上写作时间也比较仓促,文中如果部分瑕疵、疏漏甚至表达不当的地方,欢迎在评论区留言指正。我们一起探讨、交流、学习,共同努力成长,一起在 Agent 和 RSI 的落地实践上,献出自己的一份力量。

          References

          [1] Google RSI 论文解析
          https://mp.weixin.qq.com/s/N4H0rYB19myXFshzoH3_4w

          [2] Harness2: Recursive Agent Harnessing for an Open World

          [3] Evo2: Evolving the Evolver through Weight-Harness Co-Evolution

          [4] RRSI: Regularized Recursive Self-Improvement of Agent Harnesses

          [5] Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design

          图片

          图片

          欢迎留言一起参与讨论~

          跳转微信打开

          决策模型 Jev 可以直接上生产?用实验和公式理解 logit 调优与训练要领(长文干货)

          2026年11月6日 18:00

          原创 陈梓康 2026-11-06 18:00 浙江

          本文围绕一个核心工程问题展开:用决策模型替代传统生成式 LLM-as-a-Judge 做自动化评测/决策时,如何避免「直接用默认阈值和原始输出概率」带来的性能折损与误判?

          这是2026年的第 77 篇文章

          ( 本文阅读时间:约 30 分钟 )

          前言

          Decision Model(jev-like)有一些深层次的潜力可以挖掘。并且,在上线业务前,有一些前置的调教工作要做。

          本文的前半部分转载并整理自 Hamel Husain 与 Antaripa Saha 合著的《How To Use Decision Models for Evals》。

          我们将围绕一个核心工程问题展开:用决策模型(Decision Models)替代传统生成式 LLM-as-a-Judge 做自动化评测(Automated Evals)/决策时,如何避免「直接用默认阈值和原始输出概率」带来的性能折损与误判?

          后半部分是作者的一些洞见和见解。

          01

          Why use decision model to decide

          在自动化评测(Automated Evals)中,我们过去习惯直接拿生成式大模型当裁判(LLM-as-a-Judge)。但真正往线上铺开时,传统生成式 LLM Judge 很快就会撞上两个底层瓶颈:

          第一是生成开销大。哪怕我们最终只需要一个 Pass 或 Fail 的二元结论,自回归模型也必须逐个 token 把推理过程或 JSON 结构写出来,时延和 API 成本都很难压下来。

          第二,也是更容易被忽视的一点:传统 LLM Judge 给不出连续、可信的置信度(Confidence)。

          • 如果让 LLM 直接输出离散的 Pass / Fail 文本,就等于让模型在黑盒内部做了一次不可见的硬截断——我们拿不到任何概率信息,既没法根据业务需求去微调误报(False Positive)与漏报(False Negative)的比例,也没法识别哪些样本处于模棱两可的灰区。

          • 如果改成在 Prompt 里让模型“口头报出置信度”(例如输出 {"score": 0.85}),它本质上只是在采样数字字符 token。受预训练语料先验影响,生成的数字会高度扎堆在 0.50、0.80、0.90 等少数离散档位上,既不连续,也不代表真实的错误频率。

          • 即便我们直接去读取生成式 LLM 在答案 token(如 Yes/No)上的 logprobs,由于通用大模型普遍经历了多轮偏好对齐(RLHF)或 0/1 奖励的 GRPO 训练,它的词表 logits 早已被强烈推尖——输出概率动辄坍缩在 0.999 或 0.001,同样失去了灰区样本的校准度。

          这正是决策模型(Decision Models)试图解决的问题。从 TypeSafe 的 Jev 开始,随后 Perplexity 的 Decider、Liquid 的 d1、Cloudflare 的 Clef 以及 OpenAI 的 Decisions API 相继推出。这类模型砍掉了自回归生成文本的循环,单次前向计算直接从决策头读出 logits,并映射为  到  之间的连续概率分数。

          一旦拿到了连续、且经过专项训练的 logits / 概率分数,我们在做自动化评测时就多出了很多操作空间:不仅可以省下生成 token 的成本,还能自由移动决策阈值来适配业务的误报/漏报容忍度,甚至直接把分数当成风险置信度来做分级处置。

          但问题也恰恰出在这里:我们观察到,很多人在接入这些决策模型后,直接照搬了 API 默认的 0.50 决策阈值,也没有检验模型报出的概率数字是否真的可靠,结果把一大截性能白白留在了桌面上。

          下面我们就用一组真实的评测实验,一步步拆解:怎么调阈值、怎么结合成本选模型,以及什么时候才能真正相信模型输出的概率。

          02

          How decision model decides

          1. 我们测了什么:任务设定与参评模型

          我们从一套公寓租赁 Agent 系统中抽出了 100 条真实轨迹(traces),每条轨迹包含完整的对话历史和 Agent 执行动作的日志。评测任务是在这些轨迹里找出包含错误的案例——比如预订失败,或者本该转交人工客服却漏转的情况(这也是我们在之前自动化评测文章里用过的“广义找错”数据集)。

          我们把同一套评测准则发给了 6 个决策模型,让它们各自返回每条轨迹的失败概率(failure probability):

          • TypeSafe Jev 1.13(使用适配 Jev 的结构化输入)

          • Perplexity Decider 1.1 27B

          • Liquid d1 与 Liquid d1-ultra

          • Cloudflare Clef Flash

          • OpenAI Decisions(底层为 GPT-6 Luna)

          接着,我们从两个维度对比这些模型:

          1. 性能(Performance):拿模型的预测结果与人工逐条审阅标注的pass / fail真值对比,衡量模型在抓出错误的同时能不能少报假警。

          2. 成本(Cost):根据实际 token 消耗量和各家官方定价计算 API 成本。

          (为了聚焦核心问题,这次实验暂不对比时延,因为时延很大程度上取决于实验控制之外的服务端因素。)

          2. 理解决策阈值:为什么默认的 0.50 会坑人?

          在这项评测里,我们给每条轨迹打的是二元标签:pass 或 fail。做自动化评测时,我们一向推荐这种二分类设定,因为它能倒逼我们把评判标准写清楚,也更容易和人类的偏好对齐。

          每个决策模型收到一条轨迹后,会返回一个  到  之间的分数,用来估计这条轨迹包含错误的可能性。为了把这个连续分数变成最终的 pass/fail 决定,各家 API 默认都会卡一个 0.50 的决策阈值(decision threshold):分数  的轨迹就被标记为失败(fail)。

          但如果不拿自己的数据检验一下就直接用 0.50,结果可能会非常糟糕。

          不妨想一个最简单的例子:假设某个模型给每一条真正的失败轨迹都打了 0.40 分,给每一条正常通过的轨迹都打了 0.10 分。你看,这个模型其实把正负样本分得一清二楚——只要我们把阈值设在 0.30,它就能做到 100% 完美分类;可如果沿用默认的 0.50 阈值,它连一条错误都抓不出来。

          在真实场景里,失败轨迹和正常轨迹的分数分布不可避免会有重叠。这时候把阈值往低处调,虽然能抓到更多真正的错误,但也会顺带捞进更多误报。所以,选择决策阈值的过程,本质上就是在权衡两个指标:

          • Precision(精确率 / 查准率):被模型标记为失败的轨迹里,真正包含已知错误的比例(控制误报)。

          • Recall(召回率 / 查全率):所有已知的真实错误轨迹里,被模型成功抓出来的比例(控制漏报)。

          到底该偏向哪一头,取决于具体的业务目标。比如刑事审判对定罪设了极高的门槛,宁可漏判也不能冤枉无辜,这强调的是 Precision;而早期癌症筛查则宁可多做几次复查也要尽量少漏掉患者,这强调的是 Recall。为了在同一起跑线上对比这 6 个模型,我们先给 Precision 和 Recall 赋予相同的权重,用它们的调和平均数——F1 分数(范围  到 ,越高越好)来衡量整体表现。当我们把每个模型给失败轨迹(橙色)和正常轨迹(蓝色)打出的分数分布画出来,并把阈值从默认的 0.50 切换到针对各自最优 F1 调优后的位置时,可以直观看到:OpenAI Decisions 在这个任务上把两类样本的分布拉开得最干净,这也反映在它更高的 F1 分数上。

          3. 先立规矩再谈优化:设定业务的最低可用门槛

          需要注意的是,这里很容易踩进另一个坑:千万不要脱离业务底线去盲目最大化 F1。在动手调阈值之前,我们得先想清楚:这个分类器至少要做到什么程度,在业务上才算「能用」?

          举个例子,假如我们要拿这个分类器去搭一套自动化线上告警系统,那我会要求 Precision 和 Recall 都必须至少达到 80%——只有这样,才能在尽量少发假警报骚扰团队的同时,抓住足够高比例的线上故障。倘若我们把各个模型在不同阈值下的 Precision-Recall 变化曲线画在一张图上,右上角“Precision  且 Recall ”的矩形阴影区就是我们的合格线。观察这张图,6 个模型立刻分出了高下:

          • 进入合格区的候选模型(3 个):Perplexity Decider 1.1 27B、Liquid d1-ultra 和 OpenAI Decisions 的曲线成功穿过了阴影区,满足我们的最低要求;

          • 未达标模型(3 个):Jev 1.13、Liquid d1 和 Cloudflare Clef Flash 无论怎么调整阈值,都无法同时迈过双 80% 的门槛,可以直接排除出本次候选池。

          即便对留下的三个候选模型,它们各自的曲线也只是有一小段落在了阴影区里——我们依然需要在这片合格区域内,为每个模型精准定下那个最佳阈值。

          4. 动手调优决策阈值(Threshold Tuning)

          既然下游应用对 Precision 和 Recall 都有明确要求,而调阈值只能选择既有 PR 曲线上的工作点,那么自训时,我们就应在数据覆盖、训练目标和模型选择中提前考虑误报与漏报的要求,并在独立验证数据上检查是否存在同时达标的阈值。提高目标工作点附近的区分能力值得尝试,但概率校准或阈值加权损失本身,都不能保证 P/R 达标。

          接下来我们就以最大化 F1 为目标来调阈值。对于刚才入围的三个候选模型,我们在训练数据上加上硬约束:只允许在同时满足 Precision  和 Recall  的阈值里挑选;至于另外三个未达标的模型,我们不加约束直接最大化 F1,用来展示调阈值本身能带来多大变化。

          为了防止在测试集上“看答案调参”导致过拟合,这一步必须使用交叉验证。只要手里已经存好了人工标注标签和各模型的原始打分,可以直接把下面这段 Prompt 交给 Coding Agent 来跑完整个流程:

          Using my saved model scores and binary labels (1 means failure), tune a decision threshold to maximize F1 while requiring at least 80% precision and 80% recall. Use stratified five-fold cross-validation, choosing thresholds on the training examples and measuring performance on the remaining examples. If comparing models, use the same splits for each. Only select thresholds that meet both minimums on the training examples. If none qualifies, report that rather than relaxing either requirement. Report validation precision, recall, and F1, along with any splits where no threshold qualified or validation performance fell below my minimums. Compare with the default threshold of 0.50. Reuse the saved scores without making new model calls.

          对比默认 0.50 阈值与五折交叉验证调优后的结果,可以看到一个有意思的现象:

          • 入围的三个候选模型(Perplexity、Liquid d1-ultra、OpenAI)从 F1 调优中获得的提升幅度,反而比被淘汰的 Liquid d1 和 Clef Flash 要小(后两者的默认阈值偏离最佳点太远,调完阈值后 F1 大涨,但依然够不到双 80% 线)。

          • 尽管如此,对候选模型做阈值调优依然不可或缺——在实际业务里,哪怕 Precision 和 Recall 只有几个百分点的移动,也会直接牵动业务成本或用户体验。

          • 另外请记住:现实业务里 Precision 和 Recall 几乎不可能像 F1 假设的那样恰好等权。如果更看重 Precision,可以用  的  分数;如果更看重 Recall,则用 。换一个优化指标,选出来的最佳阈值和最终排序都会随之改变。

          简单有效: )

          5. 性能与成本的较量(Performance vs. Cost)

          把每个模型的阈值都调到最佳状态后,我们终于可以把留下的三个合格候选摆到同一张图上,对比它们调优后的 F1 与 API 成本了:

          达标候选模型

          调优后 F1

          (5-fold CV)

          API 成本

          (每 100 次评测)

          在帕累托前沿上的定位

          Perplexity Decider 1.1 27B0.790.82 美分

          合格候选中最便宜的方案,守住双 80% 底线的极致性价比之选

          Liquid d1-ultra

          介于 0.79~0.87 之间

          介于 0.82~3.72 美分之间

          性能与成本均处于中间档,且原生概率校准极佳

          OpenAI Decisions (GPT-6 Luna)0.873.72 美分

          分类性能断层领先,但成本约为 Perplexity 的 4.5 倍

          连接这三个点的虚线就构成了候选池的帕累托前沿(Pareto frontier):对于我们想要的任何 F1 水平,这条线都能指出达到该性能所需的最便宜模型。虽然这里只有三个点。

          6. 我们能直接相信模型报出的概率吗?(Calibration)

          除了做非黑即白的 pass/fail 分类,很多时候我们还会想把决策模型的分数直接当成置信度估计(confidence estimate)来用。但问题是:我们能按字面意思相信那个数字吗?如果模型报出 0.80,真的意味着“80% 的可能性有错”吗?

          要满足这个条件,在所有被模型打出 0.80 左右分数的轨迹里,必须真的有大约 80% 包含错误。

          我们把每个模型的预测概率按高低分桶(每个点代表大约 20 条得分相近的轨迹),横轴画模型的平均预测概率,纵轴画这批轨迹里实际观察到的失败比例,就得到了概率校准曲线(Calibration Curve):

          • 落在对角线上,说明预测概率与实际错误率严丝合缝;

          • 落在对角线上方,说明真实错误率高于预测值,模型低估了失败风险;

          • 落在对角线下方,说明模型高估了失败风险。

          观察校准前的原始曲线,各家模型的脾气大相径庭:

          • Jev 1.13 和 Liquid d1-ultra 在这个数据集上天生就已经校准得非常好,几乎不需要调整;

          • Cloudflare Clef Flash、Perplexity 和 Liquid d1 则明显偏离对角线。最夸张的是 Clef Flash:其中一组轨迹的模型平均预测失败概率只有约 8%,但实际上这组轨迹里有 60% 都包含了错误!

          如果模型的预测概率和真实结果对不上,我们可以在外层再套一个简单模型把概率校准回来。最经典的方法是 Platt scaling——在留出数据上拟合一条简单的 S 型曲线来修正概率偏差。

          经过 Platt scaling 校准后,Perplexity、Liquid d1 和 Clef Flash 都显著向对角线靠拢了。但也要特别当心:Platt scaling 并不总是合身。比如在我们的实验里,OpenAI Decisions 的概率在套用这一版 Platt scaling 后反而略微变差了。所以做完校准一定要用指标说话。我们可以用下面这段 Prompt 让 Coding Agent 自动跑完交叉验证校准并给出 Brier score(越低越好)对比:

          Using my saved failure probabilities and binary labels (1 means failure), test whether Platt scaling improves each model’s probabilities. Use stratified five-fold cross-validation with the same splits for every model. Fit the calibration mapping on each training split and apply it to the remaining traces. Fit on log-odds, clipping probabilities away from 0 and 1 first. Plot predicted probabilities against observed failure rates before and after calibration. Report Brier scores (lower is better), and explain which models improved or got worse. Reuse the saved scores without making new model calls.

          7. 评测器粒度与落地迭代闭环

          在这次实验里,为了让不同模型之间的差距更容易看清,我们故意把评测任务设得很宽泛(“找出任何错误”)。但在实际工程落地中,我们强烈建议为每一种具体的失效模式单独构建一个 Judge(比如把“预订失败”和“漏转人工”拆成两个独立的 Judge)。当任务范围收窄、评判指令更具体之后,我们预期不同模型之间的性能差距会大幅缩小。

          在日常做项目时,我喜欢先从一个性能能达标的大模型开始跑通,然后再尝试换用更小、更便宜的模型,看它们能不能在更低成本下追平大模型的表现;如果手里有高质量的标注数据,配合 Prompt 调优往往也能帮小模型往上提一大截。

          大家可能也会好奇:决策模型和通用 LLM 到底怎么选?在我们的实验里,底层调用 GPT-6 Luna 的 OpenAI Decisions 以最高成本拿到了最高 F1,说明遇到高难度的复杂评测任务时,多花钱上大模型依然是值得的。而在 Randy Olson 做的一项更广泛的对比中,决策模型在分类(classification)和路由(routing)任务上能够以更低成本追平 LLM,但在需要知识储备与多步推理(knowledge and reasoning)的任务上,LLM 依然明显领跑。

          最后把整套方法浓缩成四步迭代闭环:

          1. 定门槛筛模型:打磨好 Judge Prompt 后,先根据业务场景定下 Precision 和 Recall 的最低合格线,直接淘汰达不到底线的模型;

          2. 先调阈值再比性能:在对比各模型之前,先结合业务目标(认真思考该用什么权衡指标,别仅仅因为本文用了 F1 就照搬 F1!)在交叉验证下调优每个模型的决策阈值;

          3. 按需检验并校准概率:如果想把分数当成置信度来用,先检查预测概率是否匹配实际观测结果;校准(如 Platt scaling)能帮上忙,但必须用 Brier score 实测确认它确实带来了改善;

          4. 综合权衡与持续迭代:结合工作负载对性能、成本和时延的要求拍板。而且记住这是一个循环——一旦后续优化了 Prompt,前面调好的阈值和校准映射都需要重新跑一遍。

          03

          Insights for decision model logits training

          以下系作者结合前文的评测现象,以及《Jev-like技术方案调研》《RLCD:校准决策的目标函数、约束与训练算法》(工作内部文件)整理的延伸笔记,非原文转载。

          由浅及深,我们将会从统计与优化理论的数学推导的视角,和算法设计的视角来对评测现象做一些进阶的分析和指导。

          3.1 校准度与排序能力:为什么 Jev 1.13 的概率很准,PR 曲线却进不了双 80%?

          我们先从前面评测里的一个反直觉现象说起:在校准曲线图上,Jev 1.13 的预测概率几乎紧贴对角线,但在“Precision  且 Recall ”的筛选中却未能入围;反倒是原始概率明显失准的 Perplexity Decider 27B 先过了双 80% 门槛,随后补一步简单的 Platt scaling 就把概率也修准了。

          为什么“概率准”不等于“分类好”?因为模型输出的连续分数  其实同时承担着两项不同的任务:一是把正负样本排开(排序/区分能力),二是如实报出每个分数对应的真实错误率(校准度)。

          记真实失败标签为 ,总体失败基率为 ,模型报出分数  时的真实条件失败率为 。衡量概率质量的 Brier 分数在总体分布上可以精确拆解为三项(Murphy 分解):

          • (Reliability,校准误差):衡量模型报出的字面概率  与该分数组真实失败率  之间的偏差;完美校准时 ,。

          • (Resolution,分辨率):衡量不同分数组的真实失败率  能拉开多大差距。极端情况下,如果一个模型对每条轨迹都无脑报总体基率 ,它的校准误差 (说有  的概率错,还真就错了 ),但它的 ,一张告警单都分不出来。

          理解了这两项的拆分,就能明白事后校准的边界:如果我们对所有样本施加同一个严格递增变换 (例如温度缩放 ,或斜率  的 Platt scaling),样本之间的分数高低顺序完全不变。原分数在阈值  下选出的告警集合,与新分数在阈值  下选出的集合是同一批样本:

          因此,在同一批数据上遍历所有阈值时,严格递增变换不会改变 AUROC、整条 PR 曲线以及最优 F1;同时由于可逆变换不改变  的信息划分,总体分辨率  也保持不变,Brier 分数的变化全部来自 。

          这也顺带澄清了一个常见误区:单纯把 logits 乘以一个放大系数,只是拉大了分数的数值跨度,并不会提高  或改善 PR 曲线。在训练决策模型时,第一要务是让模型学到能够区分正负样本的特征表示(把真正含错的轨迹排到前面),在此基础上再保证输出概率与真实频率对齐。

          3.2 默认阈值 0.50 为什么会失灵?从贝叶斯先验与误判代价理解 Platt Scaling

          在评测中,不少模型直接用默认阈值 0.50 截断时效果很差,或者像 Clef Flash 那样“平均报 8% 失败率,实际却有 60% 失败”。把概率还原到对数几率(log-odds / logit)空间,很多现象就会变得非常直观。

          记模型输出概率为 ,对应的 logit 为 。默认阈值  恰好对应 。而事后做 Platt scaling,本质上是在 logit 空间做了一次线性仿射变换:

          其中斜率  负责拉伸或压缩 logit 尺度(当  时就是单一温度缩放),截距  负责整体平移对数几率。在实际拟合中,模型误差和各类分布漂移都会同时影响 ;但有一个非常重要的特例可以精确推导——先验基率偏移(Prior / Base-rate Shift)。

          假设模型在训练分布  上已经学到了准确的真实后验 ,到了下游评测集  上,正负类的特征生成机制没有变(即 ),唯独正例出现的总体比例从  变成了 。由贝叶斯公式两边取对数几率,可以直接推出新分布下的真实后验 logit:


          由基率变化引起的常数偏置

          你看,哪怕模型的判别能力一点没变,只要下游业务的故障基率  和训练数据不同,真实对数几率就会整体平移一个常数 。如果照搬原来的分数并死守 0.50 阈值,自然会出现系统性的漏报或误报(这也印证了《Jev-like技术方案调研》第 2 节的现象:Jev 在多个基率各异的基准上混合算 ECE 只有 0.047,但单拿每个基准出来算,中位 ECE 升到了 0.168)。

          再往深处想一步:就算概率已经针对当前数据集完美校准了,默认阈值 0.50 就是最优的吗?依然不一定。

          1. 调阈值与加偏置在二元分类上等价:对任意阈值 ,有

            也就是说,把决策阈值定在 ,等价于在 logit 上加偏置  后再用 0.50 截断(但注意:调阈值只改变分类切分点,本身不等于把概率校准准了)。

          2. 业务代价决定了最优阈值的位置:假设判断正确的代价为 0,误报(FP)代价为 ,漏报(FN)代价为 。当分数  已完美校准时,一条分数为  的样本报 Fail 的期望代价是 ,报 Pass 的期望代价是 。令两者相等,最小化期望代价的贝叶斯最优阈值为:

            只有误报与漏报代价完全相等()时,最优阈值才是 0.50;若优化目标是最大化  或满足特定的 P/R 下限,最优工作点同样会偏离 0.50。因此,一套通用模型权重不可能预先写死所有下游业务的基率与代价结构,部署时留出少量带标样本在交叉验证下调阈值、验校准,是必不可少的标准动作。

          3.3 训练损失怎样塑造概率:为什么严格正常评分规则是校准的锚点?

          既然我们希望模型输出的  尽可能接近真实条件概率 ,那么在训练阶段,损失函数的设计到底提供了怎样的数学保证?

          固定一条输入 ,设真实失败概率为 ,模型预测为 。对比二分类最常用的 Brier 损失  与交叉熵损失(CE / log loss),它们在给定  下的条件期望损失对  的导数分别为:

          这两个式子非常漂亮:只要 ,它们的导数都在  处唯一为零,且在  时为负、 时为正(当  或  时最优点落在对应边界)。换句话说,在模型容量足够、优化充分且训练分布与目标一致的理想条件下,最小化 Brier 或 CE 都会驱使模型如实报出真实后验概率 。具有这一性质的评分规则,就叫做严格正常评分规则(Strictly Proper Scoring Rules)。

          反过来,如果我们在训练目标里加入一些常见的修改,期望最优点会发生什么偏离?我们可以直接算出来:

          1. 标签平滑(Label Smoothing)会把概率向 0.50 压缩: 在二分类中,如果把硬标签  平滑成 (其中 ),再去最小化 CE,条件期望损失的零点就会直接变成:这意味着真实高风险样本()的概率会被系统性压低,低风险样本()则被抬高。

          2. 只看对错的 0/1 奖励会把概率推向极端顶点: 如果在强化学习中按模型分布  采样动作 ,只根据动作是否正确给奖励 (不加 KL 等其他正则约束),那么条件期望奖励是 ,对  的导数是常数 。只要 ,梯度就一直把  往 1 推;只要 ,就一直往 0 推——这正是只优化分类准确率而不顾校准的典型后果。

          3. 带校准项的 RLCD 策略梯度,以及为什么不能套 GRPO 的组内标准差归一化: 在 RLCD(如社区 eve-rlcd 实现)中,如果把标量奖励设计为 ( 表示求梯度时把奖励视为常数),那么策略梯度在期望上恰好等价于 Brier 损失的负梯度:这里有两个极易踩坑的细节:

            1.有完整标签时无需绕道采样式 RL:当训练数据直接给出了标签 (甚至在二分类里,只要知道采出的动作  和对错 ,就能立刻还原 ),直接对  或 CE 求导就能拿到零采样方差的精确梯度;用采样 RL 估计同一个梯度只会平白引入动作采样方差。

            2.组内标准差归一化会抵消  的校准作用:如果照搬 GRPO,对同一道题采出的  个动作减去组内均值再除以组内标准差,会发生什么?在二分类硬标签  下,答对时 ,答错时 ,合并写出来就是:

            由于  对同一题的  个采样是同一个正数,而标准化操作  对正仿射变换完全不变,因子  在分子分母中被直接约掉!归一化后的优势函数与纯 0/1 奖励  完全相同,原本用来锁住校准不动点的  项就此失效,不动点再次坍缩到 0 或 1。

          3.4 当业务同时卡死 P 和 R 下限时,训练阶段该怎么发力?

          在前面的阈值调优小节里,我们提到了一个关键问题:事后调阈值只能在模型既有的 PR 曲线上找点;如果整条 PR 曲线都没进“Precision  且 Recall ”的阴影区,事后怎么调都没救。那么在自训模型时,我们能如何提前响应这种业务诉求?我这里给出一些训练的trick。

          第一步:把“双 80%”写成明确的数学约束,用对验证指标

          设模型在阈值  下的告警规则为 。记总体真正例比例为 ,总体假正例比例为 ,总体正例基率为 。当  时,业务要求的 Precision  与 Recall  可以改写为关于  的两个线性不等式:

          写成这样,就能一眼看出两个常犯的概念混淆:

          1. “P 和 R 都达到 80%”是跨样本的总体排序约束,绝不等于“把概率阈值  设成 0.80”。

          2. 在训练过程中挑选 Checkpoint、设计困难样本挖掘(Hard Negative / Hard Positive Mining)或调整数据配比时,不能只盯着整体平均 NLL / Brier,而应在验证折上直接追踪受约束工作点指标——例如“在满足  的所有阈值中,模型能达到的最大 Recall(或最大 F1)是多少”。

          第二步:如果已知部署阈值区间,可以用 Schervish 加权损失重点照顾边界

          在容量有限的小尺寸决策模型上,如果我们已经知道下游大致会在某个概率阈值  附近做切分(或者设有类似 0.20~0.80 的人工复核灰区带),能不能让训练损失把梯度预算重点花在阈值  附近,同时又不破坏“如实报概率”的性质?

          这里必须对比两种截然不同的平滑写法:

          • 陷阱写法(固定代价 + 直接把指示函数换成 sigmoid): 阈值为  的代价敏感损失在  时罚 ,在  时罚 。因为指示函数梯度几乎处处为 0,有人会直接把  替换成软决策 ( 为平滑宽度),写成:对它的条件期望求导就会发现问题:导数的符号只取决于真实概率  在  的哪一侧!只要 ,梯度就一直为负,把预测  往 1 推;只要 ,就把  往 0 推。它不仅没有校准阈值附近的概率,反而把概率强行推离了阈值 。

          • 正确写法(Schervish 阈值积分加权): Schervish 定理指出,任何二元正常评分规则都可以表示为不同阈值  下代价敏感损失的加权积分(例如标准 Brier 损失对应均匀权重 ,CE 对应 )。如果我们预先选定一个在  上非负、可积的权重密度 ——比如在目标阈值  附近放一个窄高斯峰,并叠加一个正的基础权重 (相当于并上 ):根据微积分基本定理,它对预测概率  和 logit  的条件期望梯度极其干净:由于 ,逐点期望损失的唯一最优点依然严格停在真实概率  上;同时,当预测分数  落在目标阈值  附近时, 较大,模型会对这一区域的校准残差赋予更高的梯度权重。

          • 权衡与边界(有限容量下的“误差搬家”效应): 需要清醒认识的是,“逐点最优点为 ”的前提是每个输入的概率可以独立自由优化。当模型容量有限、不同输入共享参数时,提高阈值  附近的权重 ,本质上是把宝贵的拟合预算优先保给阈值  附近,代价是其他非关键区域的校准误差可能变大。 

            我们可以算一个极简的构造例:假设数据里有等权的两组样本,真实失败率分别为  和 ,但受限于模型表达能力,预测被耦合为 ():

            1. 用均匀权重的标准 Brier 训练,最优解折中在 ,此时两组预测分别为 0.85 和 0.55,各自承担 0.05 的偏差,整体校准误差 ;

            2. 若改用集中在  附近的权重 ( 为正态密度),最优解会移动到 ——第一组在阈值 0.80 附近准到了极致的 0.8015,但第二组预测被拉低到了 0.5015(偏差近 0.10),整体  反而升至约 0.0049。 因此,Schervish 阈值加权是一个把校准精度集中到刀刃上的工具,但它本身不能代替特征区分度的提升;是否能切实推高验证集上的受约束 P/R,仍需靠实验检验。

          3.5 拆分原子 Judge 与共享前缀:如何兼顾判别粒度与推理成本?

          最后,我们来看评测结尾提出的那条工程原则:“不要用一个宽泛的 Judge 抓所有错误,而是为每一种具体的失效模式单独建一个 Judge。” 把这条原则放到单次前向决策模型(如 Jev-like 架构)里,会引出非常有趣的计算与概率组合问题。

          为什么要拆细?给单次前向模型降低推理跨度

          在前面的实验中,任务被定义为“找出 20 轮公寓租赁轨迹里的任何错误”。对于不生成思维链(CoT)、只做一次前向计算的决策模型来说,这相当于要求它在固定层数内同时完成“检索各轮对话状态、核对多种业务规则、再做逻辑或(OR)汇总”。如果我们将它拆成  个职责单一的原子二元判断(例如 :“用户明确要求转人工时是否未调用转接接口”、:“双方确认看房时间后是否未调用预订工具”、:“Agent 给出的报价是否与房源表冲突”),每一道子题的判据就变得具体而局部,标注与归因也更加清晰。

          拆成  个 Judge 后,怎么把调用成本压下来?(共享前缀隔离读出)

          如果按传统方式把 1 个宽泛 Judge 拆成  个独立 Judge 分别请求 API,同一段长长的 Agent 轨迹就要被重复编码  次,成本会直接翻  倍。

          而在支持共享前缀预填充(Shared State Prefill)与题间隔离读出的决策模型架构中(参考内部文件《Jev-like技术方案调研》第 3 节 QwenJev-Lite 方案),长轨迹材料只需 Prefill 一次,随后把  个原子问题作为互相隔离的分支接在共享 KV 缓存后面并行读出。设长轨迹预填充的计算开销为 ,每个短问题头的增量开销为 ,则:

          当轨迹上下文很长、而原子问题本身很短(即 )时,一次前向并行读出  个原子 Judge 的总计算成本将非常接近单次调用。

          汇总多个原子概率时的数学陷阱:题间隔离  事件统计独立

          当我们通过一次前向拿到了  个原子失效模式的预测概率 (其中  代表第  种错误发生的条件概率),如果下游想要回答“整条轨迹至少发生一种错误的总概率  是多少”,该怎么算?

          很多人会本能地写出 。但请特别注意:注意力掩码上的“题间隔离”只保证模型在回答第  题时偷看不到第  题的题面,绝不意味着真实世界里的失效事件  在给定轨迹  后是条件独立的!(例如 Agent 一旦误解了用户的核心意图,可能在同一条轨迹里既报错价格、又漏调接口,两类错误高度正相关。)

          在不知道各失效事件之间的条件相关性时,仅凭各自的边际概率 ,数学上只能框出 Fréchet–Boole 上下界:

          不妨算一个只有两个原子 Judge 的直观例子:假设在某类轨迹上,两个子错误的真实发生概率都是 :

          • 如果这两类错误总是由同一个底层故障同时引发(事件完全重合),那么“至少发生一种错误”的真实概率就是 ;

          • 如果两类错误在给定轨迹下恰好相互独立,真实并集概率才是 ;

          • 如果两类错误互斥(绝不会同时发生),真实并集概率则是 。

          可以看到,单靠“每个原子 Judge 各自校准得很好”,并不能自动推出合成后的总失败概率也是校准的。那么在工程落地时,我们手头这  个原子概率  到底该怎么消费?最稳妥的路径有两条:

          • 路径一(只做告警,不求总概率):按原子 Judge 独立调阈值。为每个失效模式  单独在验证集上调优阈值 ,线上只要任一  就触发对应类别的告警(不仅能抓错,还能直接给出细粒度错因标签),最后在轨迹级测试集上统一验收整体告警的 P/R。

          • 路径二(既要子项诊断,又要输出整条轨迹的总风险概率):做一层轻量的“二次聚合校准”。

          怎么把手头的  个原子分数合成一个靠谱的轨迹级总概率?(二次聚合校准)

          所谓“二次聚合”,就是把第一层  个原子 Judge 输出的分数当作输入特征,直接用整条轨迹的 pass/fail 真值标签  做监督,再拟合一个极轻量的第二层概率模型来预测整条轨迹的失败风险。

          在动手之前,先明确一个很容易混淆的前提:这  个原子 Judge 是  个各自独立的“是/否(Sigmoid)”二分类器,而不是“多选一(Softmax)”的类别分布。每个  只和它自己的反面  加起来等于 1;同一条轨迹完全可以同时犯下多种错误,因此不同子题的概率之和  完全可以大于 1。

          要把这  个分数合成一个校准过的总概率,我们可以对比两种从简到繁的做法:

          1.做法 A(极简基线):先用固定公式拍扁成一个标量 ,再做一维 Platt scaling

          当手头带轨迹级标签的校准样本很少(比如只有几十到上百条)、不敢拟合多参数模型时,最省事的办法是分两步走:

          • 第一步(人工公式汇总):先选一个现成的启发式公式,把  压成一个候选风险分 。比如取最大值 ,或者借用独立性假设的形式算出:

          (以前面两个子错误概率均为  为例,先算“两项都不错”的乘积 ,再用 1 减去它,就得到原始汇总分 。)

          • 第二步(一维刻度校准):既然错误之间往往并不独立,直接拿  当概率用肯定会失真(比如两类错误完全重合时,真实失败率其实只有 0.30)。于是我们把  当作单一特征,用轨迹级真值标签  拟合两个校准参数 : 

                      校准层从标注数据里看到“凡是原始汇总分  的轨迹,实际只有 30% 失败”,就会自动调整  把输出概率压回 0.30 附近。

          为什么做法 A 只是一个妥协的基线?

          因为它有两个明显硬伤:

          ○ 拍扁成标量时丢掉了组合结构:无论是  的两项完全重合错误,还是两项真正相互独立的错误,算出来的  都是 0.51,一维校准无法区分到底是谁触发了这个 0.51;

          ○ 只修读数刻度,改不了排序和 PR 曲线:当  时, 是关于  的严格递增函数——原本  的两条轨迹,校准后必然还是 。这意味着所有轨迹的高低排序完全被你第一步手选的汇总公式锁死了:遍历所有阈值画出来的整条 PR 曲线分毫未动,只改变了每个工作点上显示的概率数值(例如原本卡  抓出的告警集合,和校准后卡  抓出的集合完全是同一批样本)。

          2. 做法 B(更合理的标准做法):保留全部子项分数,用多变量逻辑回归同时学“组合权重”与“概率校准”既然先把  个分数拍扁成一个标量会白白扔掉信息,更自然的思路是:跳过手工汇总公式,直接把  个原子 Judge 的输出(例如各自的 )作为  维特征向量,在轨迹级标签  上拟合一个带正则化的多变量逻辑回归:

          相比做法 A,把  个子项摊开交给聚合器有三个实质性的好处:

          • 能区分“单项孤立存疑”与“多项并发报警”:假设两条轨迹在两个原子 Judge 上的得分分别是  与 (甚至 )。如果按  拍扁,它们都只剩下一个 0.60,一维校准后概率也必然相同;而保留全部子项后,模型能直接利用第二项的增量信号,给多项同时存疑的轨迹打出更高的风险。

          • 能自动给冗余或高噪的原子 Judge 调整话语权:在实际评测中,不同原子 Judge 的质量与相关性千差万别。如果第 1 题和第 2 题高度重合(经常一起报高分),逻辑回归会自动压低各自的系数  以避免双重计分;如果某个原子 Judge 判别很准,它的  就会更大;若某个子题纯属噪声,其权重会自动向 0 收缩。

          • 真正重学了轨迹级排序,有机会抬高 PR 曲线:由于不同子项被赋予了从数据中学出的不同权重 ,轨迹之间的综合得分先后顺序本身发生了改变(若校准集样本充足,还可进一步加入  等交叉项来捕捉特定错误对的共现效应)。因此,它不仅是在修概率刻度,更是在轨迹粒度上重新优化了一次分类排序。

          不过,无论选用做法 A 还是做法 B,第一层原子特征的覆盖度始终决定了上限:第二层聚合器只看得到这  个分数,看不到原始轨迹文本。如果某类错误根本不在已拆出的  个原子 Judge 之内,两条在现有子题上打分完全相同的轨迹就可能一成一败;此时聚合器算得再精,也只能报出混合后的平均风险——要突破这个天花板,就得回到前面的错误分析闭环,把漏网的失效模式补成第  个原子 Judge。

          04

          写在最后

          回头看整套流程,决策模型给自动化决策带来的最大改变,是让我们重新拿回了一个连续、可调的分数。

          过去用生成式 LLM 做决策,模型直接吐出一个 Pass/Fail,把“正负样本分得开分不开”、“概率数字准不准”和“阈值切在哪”全包办在黑盒里了。现在这三件事终于可以拆开处理:底子能不能把好坏轨迹排开,看 PR 曲线;报出来的数字能不能当真实错误率信,看校准曲线和 Platt scaling;业务上宁可多审几条误报还是宁可漏掉故障,靠移动阈值来拍板。

          很多时候,便宜的模型并不是不能用,而是需要做一些调教工作。得在交叉验证下调好阈值、配上一层简单的校准,它才能勉强上生产。我更喜欢把基本工作做扎实。

          当然,我在这里也留下了两个还没有想得太明白如何去解决的问题:

          1. Thinking Decision Model的必要性(更高的上限): 决策模型省钱是因为砍掉了生成推理过程(CoT),一次前向直接读出概率。但如果 20 轮轨迹里的错是“第 3 轮答应的折扣,到第 18 轮算总价时漏扣了”,或者要先算出两个日期差几天再判断是否违规,不写中间步骤,小模型单靠一次前向很难算对。这类问题光靠把 Judge 拆细恐怕还不够,要么得用代码把中间数字先算好塞进输入,要么还得退回带推理的模型。以及,如何训练一个有thinking能力的decision model,也是一个待定的问题。

          2. 如何让调好的阈值和校准,不随着场景的变化而变化(真实业务): 无论是最佳阈值还是 Platt scaling 的参数,都建立在当前这批数据的错误比例上。等线上 Agent 修掉了几个高频 bug、或者换了一版 Prompt,错题的比例和分布一变,原来锁死的阈值和校准映射就会偏掉。线上怎么低成本发现分数漂了、隔多久需要补标数据重调一次,目前还没有一个auto的解法。

          图片

          图片

          欢迎留言一起参与讨论~

          跳转微信打开

          《2026 阿里巴巴 AI 向善行动报告》发布!

          2026年11月6日 11:09

          阿里技术 2026-11-06 11:09 浙江

          今年,是我们连续第二年发布 AI 向善行动报告。

          AI 的发展,需要的不只是更强的模型,还有让技术长期为人所用的条件:社会可接受、环境可承载、经济可持续。服务值得信任,资源消耗可承受,创造的价值能够支撑持续投入,向善才不会停留在短期目标。

          报告分享了过去一年阿里“AI 向善”的 26 个实践案例,涵盖医疗、教育、环保、科研等领域。

          阿里巴巴集团首席技术官、科技伦理治理委员会主席吴泽明表示,AI发展需要满足三个要件:社会可接受、环境可承载、经济可持续。当前行业正处于规则成型期,科技企业应积极创造社会价值,确保AI发展方向符合人类福祉。

          阿里巴巴集团公益总裁、阿里巴巴公益基金会理事长孙利军表示,“向善”必须“向众”,Al走向大众才能创造最大价值。

          我们想分享的不只是进展,也有经验、机会和没解开的难题。报告记录的只是一个阶段,而回应真实的需求,需要更长的耐心。我们想和更多伙伴一起,把AI向善从“可以做”变成“一直做”。

          跳转微信打开

          双11:当 AI 接管支付宝大促交付,模型之外还要建什么?

          2026年11月5日 18:12

          原创 王晋阳 2026-11-05 18:12 浙江

          关于如何通过 AI Harness 从工程化走向 AI 全链路交付,本文或许能提供一些经验和参考

          这是2026年的第 76 篇文章

          ( 本文阅读时间:约 20 分钟 )

          01

          导读

          支付宝大促主要指 618 和双 11,由支付宝、淘宝、天猫协同推进,支付宝大促以直播和互动两大会场承载,配合淘宝的预热期与现货销售期。直播会场接入淘宝直播,让用户边看边领、边领边买;互动会场通过抽奖、养成玩法和红包,让用户边逛边玩、领取优惠。

          本文回顾支付宝大促技术团队近三年的演进,介绍如何通过 AI Harness(支撑 AI 研发交付的工程体系),从工程化走向 AI 全链路交付,提升研发效率与质量,并回答一个核心问题:当 AI 接管大促交付,模型之外还需要建什么?

          02

          大促研发演进:从工程化到 AI 全链路

          (一) 大促特点

          • 时间是刚性。

            支付宝618、双11的排期和集团大促战略时间强绑定,必须按照既定时间执行,交付窗口以周计、全倒排——“延期”这个选项在大促字典里不存在。

          • 质量是底线。

            优惠、权益、资金全是高敏感业务,大促期间任何线上问题都处在用户与舆论的放大镜下,事故代价被数倍放大,质量标准只升不降。

          • 需求脉冲式涌入。

            平时细水长流的业务,大促前集中爆发——横跨直播、互动多个会场与几十个功能模块,短时间内交付密度陡增。

          • 唯一不变的是变化。

            每年的会场玩法、权益形态、对接方都在换,去年沉淀的经验今年只剩部分适用,再加上每年都有新人进场——体系本身必须能应对“变化”这个常态。

          (二) 技术演进过程

          1. 2024年:把需求交付的“又好又快”定义清楚、做到位。快的定义是随时可发布——以主干研发为基础,向主干合入小PR,随时保有可发布版本,发布能力从“一周一发”提升到“一天一发”,并行需求互不等待,接得住大促需求脉冲式涌入的交付密度。好的定义是科学拆分需求,Feature化小步快跑,单次变更控制在800行以内,保证CR质量,严控高风险代码,变更行覆盖和分支覆盖行业领先,达到90%才能合入,第一次大促就做到了线上0故障/0线上问题/0重大舆情,业务目标完美达成。但是也存在不足:当需求规模量级变大,人力投入线性上涨,交付下来不轻松。

          1. 2025年:组件化沉淀 + AI 补全,效率的第一次杠杆。 第一步是把通用能力从需求里抽出来:将签到、抽奖、发奖、弹窗这些大促标配能力沉淀为可复用模块,通过配置和拼装快速搭建会场,当年节省约106 人/日。第二步引入 CodeFuse 做 AI 代码补全和单测生成,AI 生成代码占比逐步达到30%。但补全的本质是“Coding加速器”:写这一下变快了,系分、自测、联调仍一条条是人工,模块怎么拼还是要人来决策。瓶颈没有消失,只是从“写代码”转移到了“串流程”。

          2. 2026上半年:Claude Code 引爆 Agent Coding,重新理解 AI 的角色。 关键变化不是代码写得更快,而是 AI第一次能“接活”了——给它一个任务和一份上下文,它能自己读代码、自己改、自己跑测试验证。我们对 AI 的认知从“补全工具”升级为“可以委派的执行者”,这是 AI Coding 与传统辅助编码的分水岭。

          3. 2026年·618大促:Agent Coding 的第一次实战,也暴露了裸用 AI 的代价。 CY26-618 我们用 AI Coding 主导交付了 32 个需求,验证了可行性,但代价清晰可见:系分/编码/联调全程人工澄清 1332 次,AI 协作的人力成本全部压在人身上。复盘的结论很直接:裸用 Agent 不可行——AI 产物质量不可控、对业务上下文一无所知,每一分不可控都要人来兜底。

          4. 2026年·双11大促:用 Harness 回答这道题。 要让 AI 真正接管交付,光等更强的模型是等不来的,必须在模型外面补上一整套东西:它该看到什么、下一步该干什么、用什么工具动手、出错了怎么爬起来。而这整套东西的原料,正是前两年的工程积累——主干研发练出的CR纪律与质量门禁、组件化练出的复用抽象、评审与评测沉淀的准出标准,它们没有被 AI 淘汰,而是被翻译成 AI能执行的语言,多年软件工程的深入理解与演进经验,在 AI 这里找到了结合点。这个判断也得到业界印证——Anthropic 在《Building effective agents》中提出的 agent 工程化原则,以及 Claude Code、Cursor 等 Harness 的实践都表明:同一个基座模型,套上不同的 Harness,表现天差地别;决定上限的是模型,但把上限稳定兑现的,越来越是模型之外的那一层。这套模型之外的运行框架,业界称之为Harness——这正是我们双11要回答的问题。

          03

          定义大促Harness体系

          1. Harness核心解决:让AI在可控的范围内稳定产出各阶段高质量交付产物,高效率

            完成需求交付。

          Harness 是什么:模型外层的运行框架,环境、工具、上下文、编排、可观测、验证、治理。

          业界

          核心Harness思想

          OpenAI 

          环境即产品,围绕 Codex 设计环境、约束、文档、反馈回路。

          Anthropic 

          架构简单可检查,工具为 Agent 设计,上下文渐进给,长任务可恢复+交接产物。

          LangChain

          评测是护城河,单步/回合/多轮三层评测 + 可重置可复现环境。

          1. 结合业界以及我们大促业务特性,大促Harness体系如下:

          层

          目标

          上下文精细化

          让流程每步拥有「恰好够用且正确」的信息。

          执行编排

          把「散装工具的人工串联」升级为可编排的自动流水线,模型知道下一步该干啥,人只做裁决。

          工具/能力资产

          让交付线与保障线的每个编排节点都有「够用、可复用」的执行 Skill,且运行环境一致、产物稳定。

          记忆与状态

          让跨阶段状态外化可接力,并把澄清与现场经验晋升为知识回流上下文层。

          评估与观测

          让 Agent 的工作可量化、可下钻、可归因,优化从「感觉」走向「证据」。

          约束与恢复

          让 AI 执行在可控边界内运行——错误结构上不能犯、出错可回退重试,而非靠 AI 自觉。

          04

          Harness 建设关键动作

          (一)建设大促上下文

          • 解决问题:AI 与人对大促业务知识断层,导致每次需求都要从零解释业务背景、反复澄清。建 appcampaignocb_kis大促知识库,沉淀为标准事实,作为大促上下文管理的底座。

          • 知识库生产:现场蒸馏,准入成库。候选知识来自四个触发源——人工沉淀、CC 会话蒸馏、Aflow复盘节点、代码与知识库比对,研发现场出现的澄清与结论都是潜在候选。蒸馏时先过筛选闸门:研究对象属本应用、可复现、无已有覆盖,命中才按六大板块归类套模板成文。入库前走准入门禁——AI预审 + 评测集回归人工 check,合入后同步挂上 AGENTS.md 索引。
          • 知识库使用:约束常驻、索引先行、按需召回。三层渐进式加载:规则层随会话自动注入——“编码前必查规范、澄清前必查知识库”是硬约束,不依赖模型自觉;导航层 AGENTS.md 文档地图常驻上下文,先看地图再取正文;召回层 knowledge-search按任务语义检索,不全量灌注。检索命中高置信直接采纳不澄清,中置信确认式提问,未命中才开放问人。
          • 知识库保鲜:巡检比对,自动回流。每天跑一次全量巡检,逐篇将知识与代码现状比对,找到过时段落、失真章节与失效结论。偏差自动生成修复PR,走与入库相同的准入门禁,合入即完成一轮保鲜。另有一套按模块出题的评测集持续“考试”,保鲜度与准确率以答题结果度量。

          1. 知识库建设经验

          环节

          要 ✅

          不要 ❌

          支撑指标(下节)

          内容取舍

          技术方案与代码保持一致,只存结论与关键决策

          罗列过多代码详情——保鲜成本高、检索噪音大

          保鲜率

          组织方式

          分模块沉淀 + AGENTS.md 索引导航,全局约束以 ADR 模式全局生效,既要有垂类业务,又有通用知识

          一篇方案留多个结论,AI 检索到无所适从

          准确率

          加载消费

          渐进式加载:AGENTS.md 索引常驻上下文,规则自动注入,knowledge-search 按需召回

          知识全量灌进提示词——上下文膨胀、关键事实被稀释

          检索成功率

          质量准入

          版本控制 + 定时保鲜巡检,发现偏差自动提 PR

          AI 自审直接通过,跳过人工 check

          采纳率 / 一次通过率

          2. 知识库数据表现

          知识库的保鲜标准,每天定时播报,低于值就要关注了。

          • 规模:知识库累计 122 篇,包括产品知识、技术方案、架构决策、业务术语、测试、问题排查等六大板块。
          • 保鲜率:H_fresh = 88.10%(优)全量比对 14 模块,每天定时跑一次全量,发现问题直接提PR。
          • 准确率:H_acc= 86.11%(优),统一管理评测集(基于规则生成),14 模块共 196 道问答评测集。
          • 采纳率:76.2%,本轮巡检提交的 68 个修复 PR 中,89.7% 已采纳合入,一次通过率 72.1%。

          (二)统一大促研发流程

          • 基于上述Harness体系打造,我们定义了大促统一研发流程,研发交付需求采用四层结构。

          研发工作台定义就类似我们研发用的IDEA一样,不用关心细节,只关注需求交付即可,与平台共建属于自己研发工作台。

          1. Aflow平台

          • 基本介绍:

            支付宝自研流程编排平台,让 AI 与人按业务自己的流程协作,过程可看见、可感知、可干预。

          • 解决问题:

            确定性的研发编排流程,将前面Harness体系落地到Aflow各个节点,给了需求交付更多确定性。

          • 关键能力:
            • 流程编排 + 产物上传&传递 + 节点级 checkpoint + 后置 Prompt + 钉钉通知。

            • 每个节点都有干净上下文,业务可以自定义prompt,很好解决长任务执行过程中上下文污染和爆炸的问题。

          基于大促需求的风险等级拆分的研发模式。

          L2研发工作流,如下图所示:

          关键经验

          • 各个关键产物都有多Agent对抗性检查。系分、代码以及自测报告都有准出标准,这样才能保证质量。

          • 门禁节点必选。包含了AI预审、约束条件以及项目规范,必须遵守,保障AI产物在可控范围,不跑偏。

          • 断点恢复,重启胜过修补,保证高效执行长任务。状态沉到文件里,Agent 随时可以在一个干净的上下文窗口里接力继续,目前依赖守护进程和Aflow的节点恢复能力。

          2. Multica平台

          • 基本介绍:基于开源项目 Multica 改造的内部多 Agent 研发协作平台——以任务(Issue)为载体统一承载需求上下文与过程产物,通过分布式 Agent网络连起个人与团队运行环境,持续适配支付宝复杂多样的业务场景。

          • 解决问题:统一研发界面,开发同学只需要关注产物即可,不需要关注是多少个Aflow节点在运行了。

          • 关键能力:

              • 多issue并行,一个issue对应一个需求,开发同学可以并行运行多个需求,解决大促需求集中且多的问题。

              • Agent 与运行时解耦,开发可以自由选择在本地和云端执行需求交付,不用本地电脑一直开着。

              • 多 Agent 协同:覆盖前端、后端、质量等多角色,很好承接 Aflow 的三档研发流程。

          L3小队(端到端交付)实践

          • L3小队协同把「后端全自动」升级为「全链路全自动」,把人工串联的环节收进编排。

          • 关键目标:结合 Multica 多 Agent 协同能力,重点解决改动不大的存量功能,释放更多人力去做新的需求。

          • 一次需求交给一个 Agent 小队:TL 负责调度,后端、前端、质量三个交付角色按棒接力,每棒产物 review 齐全才算交棒。质量不通过自动进 BUG 修复循环,连续两次不过才升级人工。人只做两件事——验收和机器跑不动时的协调。

          (三)关键工具能力持续打磨

          1. 系分工具:从“AI 味”到过得了评审

          • 痛点:

            系分是大促交付链的第一环,也是协同面最宽的产物——前端、质量、SRE、下游系统都照着它干活,评审不过就是全链返工;而大促需求脉冲式涌入、全程倒排,留给写系分的时间被挤压。裸用 AI 写系分有四个顽疾——信息收集不全、图表制作繁琐、技术选型不靠谱、文档质量不可控,AI 味重到评审直接打回,返工反而更慢。

          • 怎么做:
            • 先建尺子:

              蒸馏 24 年至今工程研发的系分思路与优秀产物特性,固化为模型的编写参考与准出标准,AI 照着最好的样子写,Reviewer 按同一把尺子判。

            • 定死分工:

              人做决策、AI 做执行。架构分层、技术选型等关键决策动笔前由人拍板,AI 负责信息整理、图表生成、文档组织,避免“AI 写 AI 看”。

            • 管住过程:

              渐进式确认。信息收集 → 资料分析 → 大纲 → 关键决策 → 逐章撰写 → 准出审阅 → 发布,每步有明确输入输出与确认点,方案先行于写作,方向错了当步拉回。

            • 守住终点:

              独立 Reviewer Agent 按推导过程、架构合理性、技术专业性等六维度评分,不达标循环修改—质量是检查出来的,不是期望出来的。

          2. 编码工具:Loop 出来的高质量 MR

          • 痛点:

            大促代码踩在高危区——发奖、权益、资金链路上,事务、并发、幂等、弱依赖兜底一处不能漏,还要扛住峰值的限流降级要求。而模型输出是概率性的——代码三分钟写完、看着像模像样,细看暗伤一片:事务内直接调下游、一锁二判三更新没走、ThreadLocal 不做清理、只让改 A 却顺手改了 B。用规范和流程做约束后仍有漏网:MR 通不过静态检查、Agent 干到一半自认完成、改了动态配置代码却漏掉了配套的默认值声明,运行时直接报错。根因是单次交互难以稳定产出高质量交付物。

          • 怎么做:
            • 先立铁律:

              把“想好了再动手”做成结构约束,上下文未确认不写代码、骨架未批准不写实现、审查未完成不交付。任何一项未通过就回退重来,模型在结构上无法跳步。完整自审查清单源自 2457 个真实 PR 的 1833 条 CR 评论加蚂蚁军规,按 P0/P1/P2 分级逐项过——不再是“请仔细检查”式的空泛嘱咐,历史踩过的每一条坑都变成模型的必答题。

            • 再上 Loop:

              铁律降住了暗伤,降不住概率。于是编码被做成Loop,输入明确,系分+编码计划前置,人的澄清全部前移到编码前,产出编码计划;准出客观,单元测试与CR预审以业务用例为判断依据,双通过才放行;过程不依赖人,两路检查的问题以报告形式流转回编码,自动修复重试。

            • 确定性的事交给确定性工具:

              贯穿两代的底层原则——Gate 检查用 Shell 脚本强制执行、编译验证跑真实 mvn、PMD 升级为 JavaParser+AST 脚本判断。概率模型做概率擅长的事,脚本保证确定性。

          3. 测试工具:从人工构造 case 到 AI 全自动自测

          • 痛点:

            大促下游依赖较多,逻辑复杂,各种营销活动发奖、淘宝跨域咨询等,没有自动化工具,完全依赖人去构造资产和case,再去进行自测,不仅效率低,而且容易漏掉case,特别是端到端基本是人来执行。

          • 怎么做:
            • 分层推进:

              单元测试验证代码逻辑(关注分支与行覆盖)→ 接口测试验证输入输出行为 → 端到端测试串联完整业务链路——三层互补不互替,逐层向后收网。

            • 真实请求数据回放:

              端到端测试与本地测试工具打通,把预发真实请求拉到本地回放——接口正确的前提下,不再反复造数联调。

            • 知识库托底:

              预发测试资产、接口前置准备、端到端测试 case 沉淀进知识库,前置准备从“每次手工攒”变成“按需取用”。

            • 报告结构化生成:

              自测报告由 AI 按标准骨架产出,每条测试用例带编号与“预期结果 + 实际结果 + 判定依据”三件套,判定依据落到配置单据、日志断言与trace留痕——覆盖情况可检查,每条结论可复核。

          • 实践案例:

            单个case端到端测试流程,大概3~6分钟可以跑完一个case(复杂程度),支持多次/循环执行。

            • 预读知识库+自测报告,获取用户case以及真实请求的数据。

            • 拉起本地的测试工具(模拟器),按照用户case模拟点击行为,返回服务端接口测试数据,前端进行渲染。

            • 截取关键动线图,进行对比(关键截图、日志以及返回数据),对比成功之后,自动回写自测报告。

          (四)大促Harness自进化能力

          • 痛点:Harness 不是一次性搭完就定型——研发现场每天都在暴露新的澄清、断链、知识缺口,靠人工逐条优化不可持续。

          • 解决问题:建自进化闭环把现场问题自动转化为 Aflow 提示词 / 工具 / 知识库的改进,全链路自动流转、人工仅末端裁决。

          • 触发链路:每次一个需求完结,回收运行时详细数据,实时生成采集报告,T+1提出PR,T+2合入发布(含人工review)。

          具体步骤

          1. 需求完结,自动采集

            每个需求复盘节点完结即触发采集任务,回放主会话与子 agent 会话,按统一口径产出「上下文观测报告」——不靠人回忆,现场证据完整落盘。

          2. 指标提取,问题清单化

            从会话中提取 7 项运行时指标(人工澄清次数、可优化澄清数、应答未答澄清数、自主解答次数、可优化自主解答数、知识库检索次数、回答率),把模糊的“这次跑得不好”翻译成可归因的问题清单。

          3. 定时分析,分类归属

            定时任务逐份分析观测报告,按问题分类,归属到三大改进面(运行时关键改进面):Aflow 流程(节点提示词)、大促工具链以及大促知识库。

          4. 分支路由,改进自动化

            知识缺口 → 直接走知识晋升流程,蒸馏结论自动提 PR;流程与工具问题 → 建立 issue 打标签进队列,按优先级排期。

          5. 人工裁决,末端把关

            所有 PR 经 AI 预审 + 人工 review 后合入,人工只出现在链条末端——低风险改动快速过,高风险改动重点看。

          6. 回流生效,进入下一轮

            改进后的大促 Harness 在下一个需求交付中重新被采集与度量,好没好用让数据说话,形成「交付→观测→改进→交付」的自驱动飞轮。

          自进化当前数据效果

          • 真实需求35个,进行了35轮自进化,5轮大的迭代,针对Aflow流程发现有效issue 51 个,排除非通用、重复等issue,落地优化PR 12个。

          05

          双11整体效能与质量

          CY26-618大促已经开始使用AI交付了,所以与618数据比较最合适。

          06

          下一步计划

          (一)支撑全新营销活动 0→1 搭建,优化 Harness 体系

          • 现状局限:

            当前 Harness 体系建在双11存量会场之上,需求以「模块迭代」为主,知识库沉淀的也是存量模块的标准事实。换成全新营销活动从零搭建,知识库无可检索、系分无可对照,体系优势会大幅衰减。

          • 知识库冷启动机制:

            新业务进场即自动蒸馏 PRD、系分、评审结论入库,边交付边沉淀,让知识随需求「长出来」,而不是等活动结束再人工补录。

          • 落地验证场五福:

            计划把整套大促 Harness 体系运行到 CY27五福上。五福相对大促是全新活动类型,正好作为新场景验证,重点打磨「架构先行」的并行编排模式——总体系分作为门禁先行,再拆子需求Aflow流并行,把全局架构约束注入每个子需求上下文,保证并行产物与整体设计一致。

          (二)Harness 自进化:可视化、更及时

          • 现状局限:

            当前闭环节奏为需求完结 → T+1 采集报告 → T+2 PR 合入;35 轮自进化产出 51 个有效 issue,仅 12 个落地为 PR,时效偏慢、有效转化率偏低。

          • 更及时:

            采集从需求级后置复盘,前移到节点级实时触发;低风险优化(提示词调优、知识修补)AI 直接自动合入,人工只裁决高风险与跨模块改动,闭环周期从「天级」压到「小时级」。

          • issue 质量提升:

            51 → 12 的落地差主要来自非通用、重复类 issue,加强自动去重与分类的准确率,让有效 issue 更多转化为改进。

          • 可视化:

            建自进化看板——澄清轮数、知识检索命中率、issue 分类流向、PR 合入状态、知识保鲜度实时可观测,趋势可见,暴露断链不再依赖人工翻采集报告。

          • 平台化输出:

            与Multica深度合作,体系成熟后向其他业务团队复制推广,从大促专有走向通用能力,比如五福需求交付环节。

            07

            从 Harness Engineering 到 Loop Engineering

            业界正在形成共识:Agent 工程的演进是五层叠加:Prompt → Context → Harness → Loop → Graph。Harness解决完“活得稳”之后,竞争焦点上移到第四层 Loop Engineering——你不再逐轮提示 AI,而是设计一个自己发现工作、执行、验证、改进的循环。正如 Claude Code 负责人 Boris Cherny 所说:I don't prompt Claude anymore. My job is to write loops.

            先讲清两者的区别:

            1. Harness Engineering

              相当于把一个新手上路要出的每一步险都兜住——交规手册时刻提醒(上下文精细化)、限速和车道约束防跑偏(门禁与规范)、安全员坐副驾随时踩刹车(human in the loop)、出了事故有拖车和返厂维修(约束与恢复)。它回答的是:这一趟,能不能安全到达。 

            2. Loop Engineering

              把视角从“一趟”换成“一支车队”:车自己接单、自己跑、跑完自动回场检修,把每天的行驶数据自动转化成第二天的驾驶策略。它回答的是:这支车队,怎么持续地跑、越跑越好。

            我们目前的位置:第三层半,human in the loop。 六层 Harness 体系已建成——交规、约束、安全员、事故维修一应俱全。自进化闭环也已具 Loop 的雏形:需求完结触发采集、自动分类提PR、知识晋升。但循环的每一圈都要人推。往 Loop Engineering演进,本质就是把“必须由人确认”的环节收敛到最小,把副驾上的安全员逐步请回站场,只在他真正需要出现的地方拦截,两个方向已经在探索实践了:

            1. 高风险代码的自动化检查与修复闭环

              资金安全巡检目前是每日定时巡检 → 自动识别 → 提 PR 等人合入,发现是自动的,闭环是断的。往 Loop 演进的目标是把“发现—修复—验证—回归”整链接上:编译、单测、评测集这些机器能判的直接自动通过,人只抽检资金幂等、并发锁这类真正的红线,让高危代码问题以小时级被发现并修复。

            2. 基于线上问题的自动解决闭环

              大促值班目前的问题定位 agent 止步于“给出根因”,处置仍在人。演进方向是补全后半段:定位 → 生成处置方案 →低风险操作(开关回滚、配置调整)自动执行、高风险止损保留人工确认 → 处置结果归档、经验沉淀回知识库。值班人力从“执行者”退到“裁决者”,同一个问题第二次出现时循环应该自己接住。

            大促工程师的角色转变已经悄然发生:从对着 AI 逐条澄清需求,到设计约束、验证规则与改进循环。

            Build the loop, stay the engineer.

            图片

            图片

            欢迎留言一起参与讨论~

            跳转微信打开

            高德 Data Agent 实践:从业务问题到可信数据(上篇)

            2026年11月4日 18:04

            郭人豪 2026-11-04 18:04 浙江

            这是2026年的第 74 篇文章

            ( 本文阅读时间:约 20 分钟 )

            分析师 / Agent,就是坐在真实世界与数字世界之间的翻译。

            本文希望通过实践,产出完整的Data agent实践脉络,尽量没有技术语言,轻松有趣真实,让大家想看且看懂。

            全文一万五千字,分为上下两篇。集团队半年以来的实践历程,欢迎在评论区留言讨论。

            01

            开头:智能的差距

            「我们业务当前表现怎么样,今年目标完成有风险吗?」

            把这个问题分别交给一个熟练的分析师和 Agent + 数仓的系统,我们会看到两种截然不同的第一秒反应:

            这一秒钟的差距,就是智能的差距,也是这篇文章想讲的全部。

            做了这么久的 AI,我每天都在感叹:女娲造人,是一项多么精妙的工程。

            02

            现状:人人都在做 DataAgent

            AI 时代下,每一个数据、BI 团队都在做同一件事:把自家数仓接上大模型,做 DataAgent,宣传口径都差不多:数据人人可用、人人都是分析师、你身边的 AI 分析搭子、让分析师从取数中解放出来。

            大家有一个共识:BI 的下一个时代来了。毕竟自从 2003 年 Tableau、Power BI 等第四代工具确立了分析范式之后,这个领域已经差不多二十年没有太大的变化。

            海量数据一直堆在仓库里,无法快速流动、无法产生业务效果,无法成为有业务价值的资产,能看见的只有一张张高昂的成本账单。这也逼得大多数数据工作者,只能以成本、效率、故障率来衡量自己存在的价值。

            那么, BI 分析范式的变革现在到底走到哪了?

            一个略显尴尬的事实是:能跑通 SQL 取数的很多,能跑准的也不少(L2 阶段),但能真正回答业务问题、给出靠谱判断的很少。为什么呢?难点在哪里?如何解决?

            以下是高德商业智能中心团队一系列的实践总结与汇总,本篇只是序章,介绍整体框架与实践经验概要。这套东西已经在我们团队日常跑着,WAU 450 人左右,L2 智能问数准确率稳定在 85%+;离好用还有距离,正在努力往 L3、L4 迈进。

            03

            定义:一次分析,是两段往返翻译

            为了把话讲清楚,本文会用一个贯穿全文的例子:

            「美食行业最近表现怎么样,这个月的目标有没有风险?」

            这样看似简单、最日常不过的问题,可能发生在电梯里、走廊上、早会中。如果我们把人脑处理这个任务全过程拆开,本质上是两段翻译:

            降维过程把业务语言一层层翻译成机器能执行的查询语言。

            升维过程把跑出来的数字一层层回译成带结论、带判断的业务语言。

            这里「维」是抽象层级。业务语言一句「美食行业最近怎么样」,里面的目标、口径、时间、跟谁比,全靠默认共识省略着。反过来,把一堆数字重新装配成一句能拍板的结论,就是升维。去程装问题,回程装答案,进行翻译与加工,好让两个世界可以准确传递信息。

            可以感受到,分析是一条长链路的活,在真实世界也不是一个人做完的。于是组织里长出了数据运营、数据分析师、数据产品经理、数据开发工程师这些角色,靠精细分工弥合各环节的鸿沟,推动数据流动。本质上是在弥补人类无法直接理解、应用原始数据这个根本限制,每一层都在翻译,成为下一个环节人脑能处理的形态。这是典型的工业时代设计逻辑,把每个环节高度专业化,以换取规模化。

            AI 会变革这个范式,但不会太快,我估计 2~3 年吧,也可能更久,或许是一代人。原因不是技术不成熟,而是范式的变革里,技术只是器物层面最早期的变化,也是最简单的一层。感兴趣可以读 Notion 联合创始人 Ivan Zhao 的《蒸汽、钢铁与无限心智》。

            接下来,看技术关键难点,所有工程学科都绕不开的著名难题,真正的拦路虎:可靠性会沿链路连乘。

            六步只是骨架,每一步里还藏着大量步骤与推理。即便每步都做到 99% 准确,累计起来也会迅速衰减:10 步后只剩 90.44%,50 步后跌到约 60%,100 步后仅存三成多。

            这在数据分析上是灾难。生文、生图、生视频这些 AIGC 场景里,用户 10 次里 1 次超预期,就像中彩票一样满意;但数据分析你连续对 10 次,第 11 次错了,用户对 Agent 的信心就会瞬间崩塌。所以我们必须细看每一次翻译到底该做到、做好,还要做稳。

            04

            方案:Data Agent 的设计原则

            「以下是实践方案与技术落地环节,会开始说一些天书用语,我尽量说得简单易懂。」

            要让每一步翻译都做得准、做得稳,得给 Agent 补齐四样东西。

            补知识(Context):脑子里有货,知道业务在说什么、口径该怎么算。

            补能力(Function):手上有活,会取数、会算、会验。

            卡校验(Harness):心里有尺,做完先自查,过不去不许出门。

            留兜底(Loop):事后有账,人在关键处接手,做过的事有记录、有回收。

            这也正是一个熟练分析师之所以靠谱的四件事:脑子里有货、手上有活、心里有尺、事后有账。

            前两样决定能不能做,后两样决定敢不敢信。有的步骤难在知识,有的步骤难在校验。

            六步 × CFHL 总览:每一步各要补什么知识、做什么动作、卡什么校验、谁来兜底。

            下面正文着重讲述重点的那一两样,完整对照见上图。

            05

            解析:六步逐一看,落地实践

            以下每一步都会涉及很多能力点的组合,无法一次讲透,我会以链接的形式关联对应的实践文章,方便各位按需取用、细读。

            每个环节我都用五点来拆解:🤔 难点是什么?🙋‍♀️ 人是怎么做到的?🤖 Agent 该怎么做?⚙️ Agent 需要建设什么?🎯 产出目标。这样大家能从场景目的到落地方案有个大致了解;而每一环更详细的落地细节,会以链接的方式,另开专题讲解。

            第一步:【A 业务需求 → B 分析需求】厘清需求,产出分析目标与方法

            1.1 难点是什么

            一句「美食行业最近怎么样,这个月的目标有没有风险?」

            听着简单,但绝大多数 Agent 是接不住的:它不知道「最近」是多久、「表现」该看哪几件事、美食是看整体还是拆子类,更不知道你要的是看风险还是找增量?就宛如新入职的同事,即便爱因斯坦来了,缺少信息也理解不了这问题。

            需求理解错了,口径再准、SQL 再对,也只是一个错问题的正确答案。所以第一步的目标就是把一句模糊、口语、没边界的话,厘清成一份能干活的需求。

            1.2 人怎么做到厘清需求?

            这不是天赋,是人类脑子里装着一套先验知识体系,有四样东西在同时工作:

            1.知道你是谁:是老板还是同事,所以他知道你要的是看进度、有没有风险,还是找哪还能做增量。

            动态画像感知:(靠的是记人记事的情景记忆)海马体透过情景记忆将特定的人物身份与过往的交互事件存储,并产生连结,当遇到不同受众时你会见人下菜。

            2.知道「最近」对你意味着什么:知道你在做季度 review,那最近就是本季度,还得顺手带上环比上季度、同比去年。

            时空对齐与标记:(靠的是给每段记忆打时间戳的能力)海马体给情景记忆标上时间,能回顾过去、知道现在,维持自我的时间连续性,让人具备时间节奏感。

            3.懂美食这门生意:靠什么赚钱、现在处在什么阶段、和谁在竞争,要分析这个问题,并知道这些事物相互有关联。

            领域本体认知:(脑子里那本行业百科+各种知识文档)颞叶新皮层存的是关于世界的一般知识、概念和规则,能把大量情景经验抽象成规律,所以懂美食这门生意的门道。Agent 这边对应的是知识图谱与业务本体。

            4.手里有一套用熟了的分析框架:知道分析框架按供需连拆解,并且干了三年攒下手感,有基础的判断,能快速做出初判。

            程序性记忆与模式提取:(练出来的肌肉记忆+方法论)基底神经节把常年练过的零散经验和复杂判断固化成自动通路,变成专家手感。Agent 这边对应的是从经验中学习与自我反思——把跑过的分析沉淀成可复用的框架。

            以上可以总结为,从人类智能到 Agentic 架构的发展,真的很像一个新同事的 Landing 过程。

            别小看这些灵长类🐒的能力,家里的小猫小狗🐱🐶可一样都没有的,连时间都没有概念。但人能秒懂,靠的就是这套先验,而所谓做 Agent,第一步就是把这套先验补给机器。

            但到目前为止,AI 与人脑的运作并非是一致的发展路线,只是在参考人脑的运作。所以人类会被机器人统治吗?我理解不会,如果人类能造出有以上能力的物种,那估计是被人造人统治……

            1.3 Agent 该怎么做?

            说白了,就是把人脑那套动作拆成一条能跑的流水线:先翻记忆,认出你是谁、爱看哪个口径;再用意图识别,把「最近 / 表现」这些模糊词追问成具体的时间和指标;最后按一套框架,把大问题不重不漏地拆成收入 / 曝光 / 转化 / 供给四块。本质就是一次翻译:把模糊问题,翻成一套结构化、可取数、可执行的分析体系。

            1.4 Agent 需要建设什么?

            补知识(Context · 脑子里有货)

            • 业务领域知识(美食靠什么赚钱、商业模式是怎么样的)

            • 分析方法论(漏斗、供需连、对目标看、认异常)

            • 决策场景模板(是什么场景目标)

            • 提问人画像(知道这话是谁在问)

            补能力(Function · 手上有活)

            说穿了,就是把「美食最近怎么样」这句人话,拆成要达成什么目标 + 用什么方法 + 到哪为止。四件东西在配合:

            • 一副好记性:记得你是谁、你上次问过什么、你是什么角色。(记忆系统)

            • 一本行业知识库:懂美食这门生意的门道。(知识库 / 知识图谱)

            • 一双会追问的耳朵:把「最近」翻译成本季度,把「表现」翻译成具体指标。(意图识别与澄清)

            • 一个会拆活的脑子:把大问题拆分为分析、查询、验证、归因总结等多步骤。(任务规划)

            这套架构确保了 Agent 不仅仅是「查数据」,而是能像拥有 5 年经验的专家一样,具备情境感知与逻辑深度。

            1.5 产出目标

            一份写清了目标、边界、方法的《详细分析需求》给后面五步,画好一张能照着施工的图纸。当有了清晰的交付目标,用 Agent 的执行就不会过于发散与偏离,这是产出用户满意结果的起点。

            第二步:【B 分析需求 → C 数据需求】确定数据口径查询逻辑,产出查询语句

            2.1 难点是什么

            需求清楚了,真正磨人的问题才刚冒头:到底怎么算?

            一个「收入」躺着三个口径:应付 GMV、实付 GMV、核销 GMV,退单算不算?……全是坑。

            这是一个没有 AI 时就存在的难题,只是在 AI 时代被放大了数倍:

            同时,AI 是很难承认错误的。为了满足主人的愿望,它会开始说一些善意的谎言。更离谱的是,它还能把编出来的数解释一通,真假难辨。

            2.2 人怎么做到的?

            为什么分析师能「确定」数据应该怎么算?这不是天生就知道的,也不靠背下数据表与口径。

            是数据工程一直在建设的重点:指标字典、数仓分层、数据治理等,加上自身经验与记忆,知道哪有坑、有特殊用法、需要怎么处理。同时也会求助同事,用哪个表问小王、口径问阿明。团队中总会有几个表哥表姐,作为人形双足数据字典😂(愿世界上没有人在吃这个苦)。

            2.3 Agent 该怎么做?

            主线(NL2Metric2SQL):列出查数目标 → 官方指标词典召回候选(实在没有就诚实说没有)→ 对应具体的表和字段 → SQL 构建 → 门禁校验。

            支线(NL2SQL):没有指标定义 → 寻找可解数据表 → 命中数据表 → 理解元数据信息 → SQL 构建 → 门禁校验。

            2.4 Agent 需要建设什么?

            补知识(Context · 脑子里有货)

            • 指标字典:包含指标定义、可用状态、指标口径、应用场景等。但要维护统一、高质量、常态化更新的指标字典,其实很难。业务本身在变化,部门之间的协同也有障碍,都会拖累指标的稳定更新。现实是,团队里指标口径根本形不成稳定共识,要么散落在各处的数据集和代码里,要么只存在少数几个人的脑子里。高德经历了长达一年的指标统一与治理,一共 2000+ 指标,这个工作仍然在进行中。AI 智能分析,这是一个重要基石。

            • 数据说明书:包含表、字段、数据血缘等。进入 AI 时代后,数仓建设冒出一个新词,叫 AI Friendly(对机器友好)的数据组织方式,正在从面向人类可读转向面向机器推理。但绝大多数团队还深陷在疲于应付业务需求的陈年屎坑里,根本腾不出手来调整。趁着这一波 AI,我们清理了 1000+ 的待下线表,并把各种重复加工与孤儿表理了出来,对数仓整体做了一次体检。

            补能力(Function · 手上有活)

            光说有了指标字典、元数据字典还不够。真正干活的时候,Agent 需要的是一种能查得到的能力,像走进图书馆,能把这次任务要用的那份资料准确地翻出来。因为光靠记忆、光靠大模型自己的理解,是不可能回答正确的,也不可能覆盖这么大体量内容的。关于 RAG 和检索的做法,市面上的实践已经很多,这里就不展开了。

            卡校验(Harness · 心里有尺)

            • SQL 逻辑错误门禁:

            数据模型和查询场景越复杂,LLM 写出来的 SQL 就越不能信。人有一杆秤,碰到复杂任务会本能地多方交叉验证,但 AI 没有这根弦。

            典型的高风险场景包括:Cube 多维模型、不可聚合字段、比率、半可加 / 不可加指标、N 天留存计算、多层级维度的上卷下钻级联、维度枚举与筛选、去重口径、收入双算、多表 Join。这些场景对粒度、口径和聚合顺序高度敏感,一旦处理不当就会产生错误结果。

            • 可得性核对(防幻觉的关键):

            查询前先过一道「有没有」的校验:这张表在不在、这个字段有没有、这个粒度支不支持、目标值 / 对比基准 / 去年同期到底在不在库里。凡是要用却拿不到的,一律不许编,只能老老实实报错:这项缺失 / 这个维度拆不了 / 没有去年同期,把缺口如实告诉用户。

            这是防住 LLM 幻觉最关键的一道闸。大模型有个致命的讨好型天性:你要什么,它就给你什么,哪怕这东西根本不存在。你问这个月目标多少,没有目标,它会一本正经编数,并且看起来很合理;你说按门店拆一下,表里没门店字段,它会凭空虚构一列。

            所以一定要做校验机制。到目前为止,我们线上运营时还是有 1%~3% 的任务里,LLM 会幻想出不存在的表和字段。

            很多人以为 Agent 取数的难点是会不会写 SQL。其实真正的坑是口径和幻觉。写得出来不难,写得对、以及拿不到时肯承认没有,才难。

            2.5 产出目标

            这一步交出的,是一段口径正确、可复核、可溯源的 SQL。背后每一个口径都被锁定过、每一个数据都确认拿得到,而不是一段看起来能跑的 SQL。

            第三步:【C 数据需求 → D 数字结果】执行查询语句,产出正确数据结果

            3.1 难点是什么

            跑过数的人都知道,一次就对,是不可能滴。别说 AI,就算是人,在茫茫数据里捞数,错误率也不低;更别提数据本身质量就参差,跑出来的结果随时可能踩坑。

            但一个老练的分析师拿到数,不会闷头就用,而是先扫一眼对不对:量级合不合理、有没有混进脏数据、口径有没有跑偏。确认这数可信了,才敢往下用,而 AI 恰恰没有这种一眼看出不对的直觉。

            3.2 人怎么做到的?

            为什么分析师能火眼金睛看出不对?

            老练分析师拿到数,第一反应不是拿去用,而是扫一眼对不对。神奇的是,他往往真能一眼看出蹊跷,靠的不是玄学,是四种攒了很多年的老师傅经验:

            • 量级感:脑子里存着每个数的合理身材,美食一天的 GMV 不可能只有几千,也不可能一夜翻十倍。

            • 逻辑关系:数和数之间有天然的勾稽关系,实付不可能大于应付、转化数不可能大于点击数、各项拆分加起来得等于总数。

            • 常识边界:比率一定落在 0~100% 之间、点击率不可能到 40%、分母不能是零。

            • 记忆对照:跟昨天、上周、去年同期一比,要是突然多出一个数量级,那准有鬼。

            这四种直觉,其实就是心理学说的知晓感(Feeling of Knowing)那杆秤给出的读数,一种「我觉得这数对 / 不对」的直觉体验。正是它,触发了要不要再验证一遍这个开关。而要让 Agent 把这一步做稳,说白了就是把这种直觉翻译成机器能自动跑的检查规则。

            3.3 Agent 该怎么做?

            第三步是「跑完先体检」—— 把分析师「扫一眼」的功夫,做成强制门禁。

            3.4 Agent 需要建设什么?

            验证这一步可轻可重,需要在效率和准确之间权衡。校验越多,耗时越长。AI 不是人脑,人脑中「好像不太对」的感觉是可以毫秒运算的,有一个错误监控信号模块在运作。人一旦做错,大脑会在你还没意识到之前的几十毫秒就冒出一个负波,相当于内置了警报器。但每多校验一条,就多耗时与 Token 消耗,所以要按重要性和风险,决定这次到底跑到哪一档。

            最早我们把校验全打开,跑完数都要过一遍。数确实稳了,但一次问数从 30 秒变成 600 秒。用户的问题从「这数对吗」变成了「怎么这么慢」。后来按风险分档,日常问取数只留正性校验,例行汇报的才全量。

            3.5 产出目标

            这一步交出的,是一组经过体检、可信的数字。到这里,降维三步走完,一句模糊的业务问题,被翻译成了一组值得信任的数据。

            注意,第三步的门禁不是锦上添花。前面口径再对,只要跑出来的数带病,后面所有解读和判断都建在流沙上。先体检,再解读,这是分析师的老规矩。

            图片

            图片

            欢迎点赞、在看、转发三连

            跳转微信打开

            高德 Data Agent 实践:从数字到业务决策(下篇)

            2026年11月4日 18:04

            郭人豪 2026-11-04 18:04 浙江

            这是2026年的第 75 篇文章

            ( 本文阅读时间:约 20 分钟 )

            分析师 / Agent,就是坐在真实世界与数字世界之间的翻译。

            01

            上篇回顾

            上篇完成了 A → B → C → D 的「降维」:从业务需求出发,先厘清分析需求,再确定数据需求与查询逻辑,最后执行查询并验证结果,把一句模糊的业务问题变成一组经过体检、值得信任的数字。

            接下来沿着原路「升维」:D 数字结果 → C 数据解读 → B 分析判断 → A 业务结论。数字本身从来不是答案,数字放回分析框架里得出的判断才是答案。

            第四步:【D 数字结果 → C 数据解读】描述事实,产出数据解读,并识别重点

            4.1 难点是什么?

            一屏数字,大部分是噪音。AI 最容易犯的毛病,就是从头到尾把每个数念一遍:收入 xx 亿,曝光 xx亿,CVR xx%……

            念完,听的人还是不知道今天到底发生了什么。

            老练的分析师就不一样,拿到数据的第一个动作是做减法,从几十个数里划掉绝大多数,只留三五个真正值得说的。挑得准不准,这一点也是分析师之间的能力划分重点。能找到问题的关键是哪,是一个很难复制的能力,这个本事很难教,也很难复制。

            4.2 人怎么做到的?

            为什么分析师不会把数字念一遍?

            靠专业的统计学方法,与这些年攒下来的手感。要是美食 GMV 掉了 2%,他心里就会报警咯噔一下。

            另外,光说 2% 没用,得说清楚它是高了还是低了、离目标差多少。孤零零的数字是不会说话的。我们想让 Agent 学会的就是这两下子:先做减法,再配参照。

            4.3 Agent 该怎么做?

            识别异动的方法,其实一点都不缺。这些年各种数据工具里攒下的算法很多,从最基础的同比环比,到复杂的统计检验,应有尽有。

            我的想法是把通用的方法 + 具体业务定制的分析思路,一件件包装起来,每件都写清楚它能判什么、什么时候能用,然后交给 AI 自己挑。这里我特意选了让 AI 自主决定,而不是提前写死规则:AI 读了知识库里的业务背景,再结合手上这道题的判断,自己选方法。AI 在纯数理这块的底子相当扎实。当然,这只是我的一个判断与试验,各位可以根据自己的场景决定。

            4.4 Agent 需要建设什么?

            维护好每件武器的信息,都标好:①作用(判什么)+ ②射程(适用边界)+ ③实战(举例)。AI 读懂战场后(任务目标 × 指标类型 × 数据形态 × 样本 × 可解释性),从库里取用趁手的一件或几件。就如同士兵先看清楚眼前是什么仗,指标是什么类型、数据长什么样、样本够不够,再决定抄起哪一件,或者哪几件。

            绝大多数时候用不着那些花哨算法。Class 0~2 日常分析,最基础的那几档就够了,真正天天上手、最顺的,往往是那口不起眼的万能平底锅。

            注意:大多数固化报告场景,建议稳定写死对应的判断方式,不需要自由探索。

            4.5 产出目标

            这一步交出的是一组有基准、分了主次的事实,不再是一屏平铺的数字,而是哪几个值得关注、各自异常到什么程度。

            很多 AI 数据播报读起来像流水账,它把每个数字念了一遍,找不到问题的重点。会念数字的是复读机,会挑重点、给基准才是分析师。

            第五步:【C 数据解读 → B 分析判断】产出有假设、有方法、有概念的分析判断

            5.1 难点是什么?

            前面找到了异动,这一步要回答它为什么好、为什么不好、原因到底在哪,也就是归因。这是整条链里 AI 最容易骗人的一步。

            从「哪个数有问题」到「为什么有问题」,中间隔着一道大坎。看起来有道理,和经得起追问,根本是两回事。Agent 最爱顺口来一句:「是竞对补贴了吧。」听着挺像那么回事,其实一点证据没有。归因一旦开始胡说,第四步辛辛苦苦挑出来的信号就全废了。

            5.2 人怎么做到的?

            老练的人做归因,手上有两把功夫。

            第一把:横向比 + 往下钻。

            「看到美食收入涨了:是新签在涨还是续签在涨,是连锁大商户还是街边单店,哪个城市、哪个渠道涨得最凶。只说一句美食涨了,跟没说一样。」

            第二把:排除混淆。一看美食收入这周暴涨,新手就乐了:「活动有效果啦?」

            「经验丰富的分析师会皱个眉😧:多半是月末商户集中入驻,加上品牌广告打款周期赶在月末冲收,不一定是真有效果了。得先把这种赶节奏的水挤掉,剔干净之后,看看变化到底涨没涨。」

            人还会追问:这段时间到底发生了什么。

            • 先看 时间和基数 :是不是撞上了聚餐旺季或者节假日,去年同期本身是不是就低。同样涨 15%,摊上旺季和淡季,意义完全两样。

            • 再看 自己人干了什么 :美食上了新补贴吗?推荐算法把美食的权重调高?搞美食专场活动?产品是不是改版?

            • 最后看外面 :竞品是不是收了美食的投放,有没有政策或天气帮忙,比如一场冷空气把火锅店带火了?

            说到底,靠的是脑子里常年攒下的两样东西:一张这门生意到底怎么赚钱的账本,和一份公司内外这阵子发生过什么的记性。他心里大概就有数:该往哪儿钻,哪些得先排掉。

            5.3 Agent 该怎么做到有分析判断?

            把人的功夫拆成两种可执行模式。

            可以拆成两种干法。碰到能慢慢来的异步场景,就让 Agent 转起来:提一个假设,取数去验,排掉混淆,留下证据,不行再换一个,一圈圈逼近那个站得住的原因。碰到即时问答,别搞这么重,直接调指标关系、拆公式、按维度算贡献,先把大头找出来就够了。

            • 异步场景 → 假设-验证循环 :提假设 → 取数验证 → 排除混淆 → 留证据 → 再迭代,直到找到站得住追问的因果,适合深度 归因 。分析本身就是一个发散到收敛的过程。

            • 即时问答 → 常规套路:引用 指标关系 → 公式拆解 → 维度贡献分解 ,快速定位大头即可。

            5.4 Agent 需要建设什么?

            AI 分析最被诟病的一点,就是不懂业务。业务方:「不是这么拆的,我们不这么看数。」所以第一件事,是把业务沉淀下来的方法论、指标公式、指标关系图变成 AI 可读取的,让它按业务的路子拆解。

            补知识(Context · 脑子里有货)

            • 分析方法库: 往下钻、拆公式,把波动拆成三类模型:加法(构成求和)、乘法(链路连乘)、除法(比率结构),再用差分法、LMDI 对数分解、综合贡献法算清每个因子的贡献度。这部分 Agent 现在已经做得不赖。

            • 内外部事件: 一个结果的变化只是表象,往往是很多因素导致的。 数据证据与统计方法 ,能把一部分因果证据链讲清楚,但不够。 真实世界 里的很多变化,节日、社会活动、舆情、竞品动作、天气、突发事件,同样在推着数据走。

            Agent 能联网搜,可每次搜的结果都不稳定,没法当分析证据用。于是我们搭了一套外部事件采集系统,专门收这些外部情况:采集 → 清洗 → 置信度校验 → 抽象归档 → 沉淀进外部信息库,供分析随时调用。

            再就是内部信息,真正难的就在这里。「这段时间到底发生了什么」,其实也困扰着人类分析师们,难在两处:

            ① 系统割裂:活动系统、算法变更、产品发版,各躺在各自领域里,系统割裂,彼此不通气,AI 根本看不见这些内部动作。在过去人类怎么解决?一大杀招就是开会!什么日会、周会、同步会、讨论会,其实最大的作用在于交换与对齐信息。

            ② 隐形知识:更麻烦的是,大量信号压根没进过系统。散在会议里、钉钉的对话里、走廊的两句闲聊里,真实世界发生的变化,数字世界里的 AI 感知不到,就成了一块块隐形的知识,连人自己都未必理得清。

            「可能解法是什么?IM 是组织里用得最勤的地方,钉钉、飞书里存着大量组织记忆,还天然带着身份和权限,是最该被 AI 读到的一手信息源。字节把飞书放到豆包底下,我猜就是看中了这一点,一个围绕 AI 而生的 IM?再往下,得有一个开放的企业知识库,把散着的组织记忆持续攒起来、归好档、理成结构。」

            • 卡校验(Harness · 心里有尺)

            这里比较好约束,让 AI 留下推断证据、走完 check list 就行。不要硬做成模板和代码实现,一来很难维护,二来 Agent 会变笨。实测在上下文不爆炸的情况下,90% 以上会执行,能很有效地防止无中生有的幻觉。

            5.5 产出目标

            这一步交出的,是一个下钻到位、排除了混淆、站得住追问的归因结论——而不是一句听起来很有道理的猜测。

            这一步是 Agent 最容易翻车、也最见功力的地方。能查数的工具很多,敢说「证据不足,我先不下结论」的很少。

            第六步:【B 分析判断 → A 业务结论】翻译成业务语言,产出判断与业务动作建议

            6.1 难点是什么?

            绝大多数分析在精彩绝伦的掌声之后,听的人心里都会冒出一句:所以呢,我该干嘛?

            就像你听完一堆理财分析,最后还是得追一句——买哪个,买多少,现在卖吗。

            一种是只描述、不敢下结论;另一种是 AI 张口就来:「某某活动有效,可以加大补贴力度。」可预算从哪来、长尾商家能不能承接,一概不考虑。

            再往回一步想,我们一开始要回答的那个业务问题是什么?

            「美食行业最近怎么样,这个月的目标有没有风险?」

            分析只是过程,最后要交出的是判断和动作。敢下结论、能给出靠谱建议的,才叫好分析师。

            6.2 人怎么做到的?

            归因清楚了,最后一步是把它翻成老板能直接拍板的话。

            翻这句话得靠什么?靠对业务的底子——盘子多大,本季度目标是什么,手里能动用的资源到哪,这条建议最后落到谁头上,有哪些绕不开的现实约束。所以说来说去,还是那句:有没有业务 sense。

            说句实话,分析方法和算法,绝大多数没大学高数难,复杂的也不过是调包加微调。真正拉开分析质量差距的,就是这份业务 sense。

            6.3 Agent 该怎么做?

            AI 是没有责任感的。它可以给出一份看着很专业的建议,但它不会为这个建议担责。方向押错了、团队折腾一圈没结果,最后扛的还是那个拍板的人。

            此外,在真实世界中,一个建议从判断,到共识,到方案,到执行,再到回收,中间跨周期、跨部门传导。小团队或者小 OPC 还能端到端跑完,规模化的大组织里,Agent 要给出一个能落地的完美方案,非常难。

            所以我们对 AI 的定位是:识别信号,提供建议,作参考和辅助,不替人拍板。

            在这条边界内,AI 能补的其实不少:

            • 把 归因 翻成 决策语言 :别只甩一句掉了 2.1pp,要有论据、有因果链、有判断。

            • 建议带约束 :分档、分动作——干预、观察、验证,每条备注 Owner 。

            • 标置信度 :证据足就说结论,证据不足就明写「先不下结论」。这一条是 AI 最难、也最见诚意的地方。

            • 要给方案就给 可选项 :A 方案加大投放,预计……;B 方案先做核销保障,预计……让人可拍板,而不是替人拍板。

            真正得留给人的是这几件:拍板担责、跨周期落地、组织共识、资源调配、执行回收。这几样短期内 AI 都替不了。

            6.4 Agent 需要建设什么?

            现在 AI Native 这个词很火,但在数据分析这件事上,端到端真的很难跑通。卡住的地方常常不是技术,而是信任怎么建立、人和 Agent 怎么重新分工。

            所以落地的时候我们建议先挑场景,优先挑这三种:

            1.反馈快的 : 一次小活动、一个小实验,几天就能验出 Agent 判断得准不准。对了就加码,错了改起来也不心疼。

            2.能落到一个团队、一个小目标上的 : 别一上来就搞大盘 GMV 分析 、总收入分析,这种题分析完了也没人能接着做动作,最后只剩一份没人看的报告。

            3.以前做不到、有了 AI 才做得到的 : 老活套个 AI 加速,天花板一眼就看到了;真正值得投的是增量,比如外部信号捕捉、话题挖掘这类过去人力铺不开的事。

            很多分析做到最后,往往变成了“报信号”。AI盛行的年代,每个群里都有机器人每天报各种信息,但我们不妨回头想想,真正看的有几条?(这是一个灵魂拷问)

            6.5 产出目标

            到这里,升维三步走完。当初电梯里那句「美食行业最近怎么样、目标有没有风险」,才算被完整回答了一次。

            六步 × CFHL 总览:每一步各要补什么知识、做什么动作、卡什么校验、谁来兜底。

            06

            展望:大幕才刚拉开

            写到这里,大概已经倒吸一口凉气:六步,步步是坑;每一步还要补齐 Context、Function、Harness、Loop;再叠上「可靠性连乘」那把达摩克利斯之剑。这么难,AI 智能分析是不是没戏了?

            恰恰相反。

            回头看看,我们翻来覆去只在讲一个词:翻译。

            降维是把业务语言翻成机器听得懂的查询,

            升维是把冰冷的数字翻回带着判断的业务语言。

            六步、四模块、所有的坑,本质上都是同一件事:让翻译不失真。

            过去二十年,数据流不动、沉在仓库里变成成本账单,卡点从来不是算力、不是存储,而是翻译这道工序太贵、太慢、太依赖人。

            而今天,人类第一次造出了一台天生就通晓这两种语言的机器。

            所以真正的问题,从来不是 LLM 行不行,而是会不会用它。LLM 给了我们前所未有的翻译原力;CFHL——补上知识、配上手脚、立好尺子、拴上缰绳,就是把这股原力驯服成一个靠谱的过程。

            至此,Data Agent上下两篇已阐述完毕,欢迎大家指正、讨论。

            图片

            图片

            欢迎留言一起参与讨论~

            跳转微信打开

            ❌