铃阅
❌

普通视图

用 Super-agent 的理念,拆解 Octop 团队模式

2026年11月16日 15:26

原创 腾讯程序员 2026-11-16 15:26 广东

Octop 「团队模式」

作者:Jubaoliang,Octop 负责人

导读DeepSeek 近日发布长文,系统阐述了其 Super-Agent 设计理念——打破 AI「单次仅能处理单一任务」的旧范式,以调度员(Router)加执行单元(Worker)的双层架构实现任务并行与后台运行,解放用户等待时间。

无独有偶,在工程实践的另一条路径上,Octop 于 1.0.2 版本便已上线「团队模式」,由主持人 Agent 统筹分解任务、多名专家 Agent 并行执行。两者核心思路的殊途同归,恰好形成了一次跨越产品与时间的对照印证。本文即以 DeepSeek 的 Super-Agent 框架为参照,解析 Octop 团队模式的具体实现路径——两者如何在工程层面分别落地「多任务并行」这一共同目标。

DeepSeek 近日发布了一篇长文,系统阐述了 Super-Agent 的设计理念。其核心主张是:AI 不应被束缚在「单次仅处理单一任务」的旧范式中。Super-Agent 采用双层架构——前端由调度员(Router)负责接收请求与任务分配,后端由多个执行单元(Worker)并行作业;耗时较长的任务自动转入后台运行,前台则持续响应新的交互请求;每条消息仅保留核心上下文,冗长材料归档存储并按需检索。这样一来,用户无需停留在单一窗口苦苦等待,AI 也能真正实现多任务的同步推进。

Octop 是一款由腾讯云开源的多用户 AI 助手(Github 地址: https://github.com/TencentCloud/Octop)。在 Super-agent 的设计思路公开之前,Octop 1.0.2 版本便已上线了「团队模式」:整个团队由一名主持人与若干专家 Agent 组成,主持人负责任务的梳理与分派,专家们并行推进各自负责的子任务,核心思路不谋而合。本文即以 Super-agent 为参照,解析 Octop 团队模式的具体实现。

一、Super-agent 要解决的问题

先来看一个日常工作中最常见的场景。

群里突然发来通知,要求周五提交一份季度汇报 PPT。此时手头还在排查线上故障,又有紧急的新功能要赶进度,无奈之下只能把 PPT 需求复制出来,新建一个会话窗口。随着手头的事情增多,浏览器里的对话标签越开越多,每个窗口分别推进到哪一步,全凭个人记忆。等到两天后汇报材料做完,同事又反馈第三页的业务数据需要更新,但早已记不清当初是在哪个窗口生成的,只能把前因后果重新给模型描述一遍;找不到历史记录,便不得不再次新开窗口。而在修改过程中,助手又要耗费数分钟重新生成整份内容,这段时间用户只能守在屏幕前干等,甚至连电脑屏幕都不敢合上。

DeepSeek 在文章中给出了一个直观的数据:一个人通常只能同时跟进三到五个处于进行状态的复杂会话。当前的模型虽然越来越聪明,逐渐摆脱了“每一步都需要人盯着看”的局限,但各项事务究竟进展到了哪一阶段,记忆负担依然落在人身上。一件事能否做好,取决于底层模型的能力强弱;而多件事能否并行推进,考验的则是人类用户的精力上限。

Super-agent 试图接管的,正是这种跨上下文的状态追踪与任务分派工作。为此,它设定了四个清晰的目标:

  • 连续性:无论用户是在聊天群组还是在代码评审页面与它交互,背后的服务实体始终如一,用户无需再费心记忆哪句话落在哪个孤立的窗口里。
  • 高效率:前置任务尚未结束时,不阻塞后续指令的接收,多项任务能够真正并发推进。
  • 主动性:不再依赖人类一条条机械地下达指令,群聊讨论、邮件往来、自动化测试结果中一旦出现需要协同的事项,它能自主介入处理;非相关事务则静默旁观,不产生多余打扰。
  • 持久性:常驻于真实的工作环境中,即便是长时间运行遭遇单点故障,也能基于持久化上下文恢复工作,无需推倒重来。

目前行业普遍采用的“提示一次、执行一步、确认结果、再规划下一步”的交互范式,本质上是一种串行运转的单线程逻辑,一旦面对多任务场景便捉襟见肘。而 Super-agent 的架构,正是为了打破这一瓶颈而设计的。

二、Super-agent 的几个关键设计

2.1 双层结构:上层调度,下层执行

DeepSeek 打过一个生动的比方:大语言模型好比是马,外部工具和运行环境是马具,封装后的产品形态则是车行;一辆配齐车夫与工具的马车,就是一个具体的 Agent,而用户则是每天需要调度发货的货主。

按照目前主流的使用方式,货主每来一批货物,就必须亲自前往车行单独雇佣一辆马车,将这单任务全权托付给它;新开一个对话窗口,就相当于重新走一遍雇车的流程。

Super-agent 换了一套协作路径:车行直接常驻到了团队的工作群中,无论是群内的日常讨论、代码评审下的改动留言,还是自动化测试抛出的异常报错,系统都能够统一感知。车行内部配备了一名专属的调度员(Router),职责非常纯粹,只负责任务的辨识与分派。所有外部需求统一汇聚到调度员手中,由其判断该分配给哪辆马车、是否需要多车协同作业,以及各方任务完成后如何汇总反馈。具体负责拉货作业的马车,则被称为 Worker。上层由轻量调度员总揽全局,下层由专业 Worker 并行执行,这便是 Super-agent 所倡导的双层架构。

在这一设计中,调度员的角色被剥离得极为轻巧:只负责接收需求与分派任务,自身绝不承担具体执行,甚至完全不配置业务工具。 正因为调度员无需分心处理繁重的业务运算,面对持续涌入的新任务时才能始终保持快速响应。他仅需进行任务意图理解和路由分配,因此选用更轻便、更敏捷的模型即可胜任;而在底层承担具体执行的 Worker,则各自配备全套业务工具与独立的上下文对话流,接入能力更强的大模型,专注于将单一任务执行完毕后向调度员汇报,最后由调度员对外统一回复。

相比之下,业内常见的“一个主 Agent 挂载若干 SubAgent”的设计并非真正的双层架构。在那种模式下,主 Agent 既要负责接收消息,又保留了自己直接下场干活的工具链,分不分工完全依赖大模型在当下的概率判断。DeepSeek 曾在试验中发现:如果系统提示词仅注明“在合适时可以寻求帮手协助”,测试五次任务竟没有一次触发分工,其中耗时最长的一项被拖延了近半小时;即使将提示词强化为“尽量将任务分配出去”,五次测试中依然出现过主 Agent 因自认为难度较低而亲自执行的情况,导致主窗口当场被长任务卡死。事实证明,只有彻底拿走调度员手中的具体业务工具,从架构层面阻断其亲自执行的可能性,才能稳定保证每一项进入系统的任务都能被可靠调度。

配图1

2.2 事件驱动:由外部触发替代轮询输入

当执行体系建立之后,核心问题便转向了系统何时启动运转。

驱动 Agent 工作的指令,不再是用户在对话框中逐字敲入的一行行提示词,而是整个协作网络中自然发生的外部事件:一条群聊消息、一封新邮件、一次日程提醒、代码评审中的评语,亦或是流水线构建失败的通知。这些统称为触发事件。当 Agent 嵌入工作环境后,正是这些实时发生的事件在驱动它开展工作,这也正是 DeepSeek 所强调的事件驱动理念——用户甚至无需特意找到它并主动发起对话。

当然,工作群内的绝大多数闲聊与日常沟通与业务任务并无关联,如果将每一条群消息都送入大模型做语义分析,无论在响应速度还是调用成本上都吃不消。因此系统设计了双重过滤机制:前置层先通过基础规则过滤,凡是来源渠道不符、群组未授权或不在白名单范围内的信息直接丢弃;只有通过前置过滤的有效事件,才会递交给模型层,由模型依据自然语言编写的策略规则,综合研判该事项是否应当承接。

此外,针对同一个代码评审、同一话题讨论或连续往来的邮件线索,系统会将其抽象为一条持续的“任务上下文线”。一旦某个任务被具体分配给某位 Worker,该任务线上后续追加的上下文将直接路由至对应的 Worker 手中,无需反复绕回调度员重新流转。试验表明,在代码评审提交二十多分钟后,即使评审人员追加了一条修改意见,负责该任务的 Worker 也能立刻无缝衔接历史背景,用户完全无需重述前因后果。对于已被认领的任务线,调度员不再过多干预,从而将精力聚焦在全局监控与未分配的新任务上。

更进一步,系统甚至具备适度超前的推测执行能力。当研发群内还在就某处 bug 的可能成因展开讨论时,后台 Agent 可能已经提前准备好了复现脚本与初步的修复方案;如果团队最终确认需要修复,现成的方案便可即刻输出;若讨论决定无需改动,则在后台直接废弃推测结果。通过后台适度的算力冗余,换取人类等待时间的显著降低,这在系统设计中常被称为“推测执行”(投机执行)。

与此同时,对话上下文的容量膨胀也是工程落地的一大制约。单一会话能够承载的上下文长度始终存在上限,盲目塞入过多背景往往会稀释模型的注意力,导致重点漂移;但如果信息保留不足,又会导致模型频繁调用外部工具反复检索。DeepSeek 采取的应对策略类似于日常对办公桌面的整理:当前轮次紧密相关的核心信息常驻在活跃上下文中,而篇幅冗长且调用频次较低的原始资料,则仅在主流程中保留摘要与引用标识,正文归档至持久化存储中,后续仅在需要深挖细节时按需调取。正如原文所强调的:在上下文窗口中浪费空间,本质上就是在浪费模型宝贵的推理能力。

配图2

2.3 全双工:前台不等待后台

在实际业务场景中,当一条新消息到达时,系统后台很可能仍有尚未执行完毕的长周期任务。在传统的交互方式下,处理方案通常是线性排队:新消息虽然已被系统接收,但必须等当前轮次完全运行结束才能开始处理。以生成一份完整的方案 PPT 为例,往往需要耗费数分钟,用户在这期间就只能在屏幕前等待;如果中途强行打断,前置任务的产出又会被彻底废弃。这种模式在通信领域被称为“半双工”,如同对讲机通话一般,一方不释放通话权,另一方就无法插入。

全双工交互模式则改变了这一机制:耗时较长的重型任务被移交至后台异步执行,前台对话流完全不阻塞,能够持续保持待命状态以响应用户的后续输入。例如当用户在后台任务运行期间提出“第二部分还要补充两个案例”,系统在完成后台任务的当前执行步骤后便能即刻捕获这一新要求;如果新指令与后台正在生成的版本并不冲突,系统会在后台产出完成后统一执行增量合并;若发现两者存在冲突,则能果断终止当前后台分支,带着新要求重新派发执行。而后台任务最终完工后,其执行成果会被封装为独立的系统消息,动态回填至前台对话流中。

从交互逻辑来看,系统原有的“模型等待外部工具返回”转变成了“系统承载等待,模型持续响应交互”。这种模式高度契合分布式系统中的异步消息机制:将复杂计算请求分派出去后,主流程继续处理其他交互,计算结果则在完成后通过回调递回。

与之配套的输出策略同样需要因地制宜:在即时通信群聊中,系统遵循最小打扰原则,仅在需要关键决策或成果交付的节点发声,且输出内容以简短结论为主;而在代码评审、长邮件或技术文档等非即时交互场景下,才详细展开完整的背景考量、改动明细以及验证报告。原文对此甚至给出了一条极具实操性的量化规范:在即时通讯场景中,单次回复内容尽量控制在百词以内。

配图3

2.4 持久在线与独立巡查

如果在下班离开工位时,后台某项复杂的代码重构或大型 PPT 尚未处理完毕,直接合上笔记本电脑便会导致原本部署在本机的 Agent 进程中断。虽然纯云端托管的 Agent 能够继续运行,但本机未提交的代码改动、私有内网系统的访问权限以及敏感的本地凭据,在安全要求下又无法随意同步至公有云端。

针对这一两难困境,DeepSeek 给出的架构方案是“手脑分离”:

  • 将“认知规划”与“状态记忆”托管于云端:通过轻量无状态的计算容器承载核心规划逻辑,将全局对话状态与任务轨迹持久化存入高可靠数据库;

  • 将“具体执行”保留在本地终端:在用户本机部署轻量守护进程,专职负责接收并执行由云端派发的具体命令;

  • 一旦云端容器发生异常崩溃,系统可快速拉起新实例,通过读取持久化记录无缝接续当前任务;

  • 本地代码与认证凭据自始至终保留在本地受控环境中,避免敏感资产外泄。

与此同时,面对长周期复杂任务的持续运行,单纯依赖模型内部的自我反思很难全面保障系统的高可用性。因此,主系统外部通常还会配备一个独立的看门狗守护程序(Watchdog),周期性唤醒并对全局运行状态展开巡检:它不仅监控常规的网络接口报错或调用超时,更能借助轻量模型评估每个 Worker 是否在切实推进目标、当前执行路径是否产生偏离。实践表明,Agent 系统在实际运行中最棘手的故障往往并非进程崩溃,而是模型陷入逻辑死循环或偏离了最初设定的目标,这类逻辑层面的偏航是传统进程监控工具无法捕捉的。此外,外部运维人员也可以直接使用自然语言询问“上一轮任务失败的根源是什么”,或是在线动态调整事件触发的过滤规则。

正如 DeepSeek 在文末客观指出的:这一整套设计并非凭空发明了新理论,而是计算机系统工程领域沿用数十年的成熟实践,在 AI 智能体场景下的自然延伸。

三、再看 Octop 的团队模式

Octop 是腾讯云自研的具备多用户,多专家,支持团队协作的 AI 助手。 命名灵感来自章鱼(Octopus)——多条触手协同作业,能同时处理几件复杂的事。在 Octop 1.0.2 版本中推出的团队模式,核心运转逻辑与 Super-Agent 如出一辙:由系统主持人率先对综合任务进行结构化拆解,随后将其分配给不同领域的专家 Agent,诸如市场调研、数据分析、文案策划等环节各司其职,各自闭环后再将成果交由主持人统一汇总收口。

3.1 主持人负责统筹调度,专家专注于细分执行

在 Octop 团队模式中,主持人的系统权限做得很克制,仅配置了查看团队成员、分派子任务、检索长期记忆以及感知时间的轻量工具。当用户提出一项复合需求时,请求首先统一由主持人承接。主持人会优先厘清核心目标、业务边界、限制条件以及预期的最终交付形式,进而为参与协作的每位专家分别生成一份定制化的任务指引——将工作目标、禁止边界、输出标准以及必要的背景上下文交代得清清楚楚。

从系统内核来看,Octop 团队本质上就是一个工程落地的 Super-Agent 架构:团队内部的各位专家成员被抽象封装为标准化的工具接口,主持人通过工具调用将任务消息分发至具体专家,专家在本地执行完毕后再将成果异步通知主持人。每一个专家成员在底层保持高度隔离,拥有专属的本地工作目录、独立绑定的模型服务、独立的记忆沉淀以及隔离的会话流。用户既可以在主房间内发起多专家团队协作,也可以进入私聊窗口单独与某位专家深度探讨,甚至能将同一位专家引入多个不同的协同团队,各自的上下文记忆完全不会产生混淆。

不过在交互呈现上,两者存在一处明显的取舍差异。DeepSeek 倾向于完全屏蔽执行单元的对外发声,所有输出统一收敛在调度员一人身上,以此保证界面的极致精简;而 Octop 则选择让各专家的回复直接携带其专属头像展示在协作房间中,让任务的推进过程直观透明。主持人只在全部环节结束后,输出一段不超过三句话的全局收尾,且严格避免重复专家已阐明的具体细节。这种将中间过程充分展开的做法,使得当专家之间出现方案分歧时,团队成员能够一目了然地追溯不同立场的逻辑根源。

尽管交互细节各有侧重,但两者在“对外保留统领收口的角色”这一设计理念上高度契合:DeepSeek 依靠调度员从始至终主导交互脉络,而 Octop 则由主持人把控团队协作的序幕与终局。

配图4

3.2 异步协作与非阻塞执行机制

在任务分配的执行机制上,Octop 同样采用了“提交即返回”的非阻塞设计:当主持人将子任务分配给对应专家后,系统绝不会陷入原地同步等待状态,而是立即转入待命模式,随时准备响应用户的后续新指令。各自分配出去的子任务完全交由对应的专家在后台并发推进,不同专家之间的任务彼此独立运行,而同一位专家名下的多项任务则在其私有队列中井然有序地排队流转。

当专家顺利完成所负责的子任务后,系统底层会将阶段性成果组装为一条带有特定标签的唤醒消息回传给主持人,消息体中会明确标示这属于已有任务的回调而非用户的新增提问,并随附一段核心答案的节选摘要。主持人接收到唤醒信号后,会智能判断是否需要触发下一轮专家分派,或者直接用简练的几句话收尾,明确向用户说明决策结论及采纳依据。

“分派即返回、后台并发作业、成果异步回填”,这三项核心特征在两套系统中均得到了完整体现。唯一的区别在于等待机制所处的抽象层次不同:DeepSeek 重构的是底层单次工具调用的等待协议,而 Octop 则是将协同链路抽象为一套事件收件箱体系——任务分派后主线程即刻释放,后台作业完成后再主动唤醒主持人。无论技术选型如何,那些耗时漫长的重型任务都成功从前台交互流中被彻底剥离出去。

3.3 核心理念上的不谋而合

深入剖析两者的工程细节,可以发现它们在诸多核心设计决策上展现出了高度的默契:

任务主线回归特定上下文。 在 Octop 中,团队协作房间本质上承载了主持人的会话主干,每位专家在此基础上派生出属于自己的子会话。同一任务后续产生的追加讨论与交付结果,都会精准排队回归至最初创建的上下文线程中,绝对不会与用户同该专家的日常私聊记录产生交叉污染。这与前文提到的“同一任务线的增量信息直达原处理单元”在设计思路上完全吻合。不同的是,Octop 并未选择彻底绕开前台的隐式路由,而是让所有新消息统一步入主持人的视野,从而更加直观地厘清任务演进的全局时序。

上下文容量的克制与归档管理。 面向篇幅冗长的工具返回数据,Octop 在前端渲染前会执行截断处理并保留折叠标记;而提供给主持人审阅的专家答卷,默认也仅提取核心结论的节选。在向下分配具体任务时,系统会自动将房间内的历史讨论纪要压缩提炼为一份精简的背景概要,并显式标注其仅供背景参考。将最关键的决策信息留在手边,将庞大的原始全文归档存放在专属空间,这一做法与 Super-Agent 所提倡的办公桌面整理法则在工程理念上如出一辙。

因地制宜的场景化表达规范。 在缺乏完整富文本界面的即时通讯渠道中,用户无法感知到协作房间内专家逐字生成的动态过程,因此 Octop 在任务分派成功的第一时间,会主动补发一条“已指派某某专家处理,请稍候……”的即时状态提示。当专家完成工作后,系统会推送带有明确身份署名的完整结果;而在主持人全局复盘时,再单独推送标有“【主持人总结】”的前缀消息。在移动端及 IM 群组中保持输出简练且主体清晰,若用户需要查阅全量推导链路,则可随时无缝切回 Web 控制台深入浏览。

单轮支持并发多路任务分派。 主持人支持在同一轮调度决策中,将复合任务拆解并同时分配给多位专家协同推进,避免前台交互被单一维度的任务分派所阻塞。DeepSeek 采取的方案则是将短时间内并发涌入的消息合并成批次统一处理。虽然工程手段不同,但两者旨在规避的前台串行阻塞痛点是完全一致的。

把关键把控权始终留在人类手中。 Octop 并没有引入完全由程序驱动的外部自动化巡检进程,而是设计了一套严谨的人机协同安全机制:当专家在执行过程中涉及调用敏感系统工具时,执行链路会主动暂停,等待人类用户的显式确认与授权,最长等待时间可达半小时,在此期间系统绝不会误判该轮任务已经超时结束。若任务分派过程中遭遇网络异常或上下文超限等问题,系统会如实唤醒主持人进行客观说明,进而由主持人决定重新分派还是向用户汇报终止,严禁模型在异常状态下凭空编造替代结果。此外,只要专家身上仍有尚未收尾的活跃任务,系统就会在规则层面禁止将该专家移除出团队或执行删除操作。DeepSeek 选择用独立的 Watchdog 巡检保障可靠性,而 Octop 则将决定系统边界的安全确认踏实地交到了人类手中。

配图5

3.3 认知大脑在云上,执行的双手留在本地

合上笔记本电脑之后,原先部署在这台电脑上的助手会一起停掉。整套系统搬到云上,云上的进程可以继续跑;工作区里尚未提交的改动、登录凭据,以及只有内网才够得到的资源,却仍然留在原来的机器上,云端够不着它们。DeepSeek 把这个矛盾收成「脑手分离」:负责规划和记忆的认知放在云端,本机只留下听命执行的进程。云端容器出了故障,可以换一个新的,读回已经存下的记录接着做;代码和凭据则始终守在本地。

Octop 的云端协作,把同一件事做成了两台实例之间走得通的一条路径。一台 Octop 放在云上,人离开工位之后,从手机或另一台电脑仍然打得开,任务从这里进来,任务分配和来回对话也在这里发生,这一侧就是随时找得到的认知入口。另一台留在家里或办公室里持续开着的机器上,仓库、凭据和内网都在它旁边,这一侧是执行的双手。两边连上以后,云端界面里会出现家里的专家。你把任务分配给他,操作上与把任务分配给本地专家一样。请求经云端协作的桥送到专家所在的实例,模型循环、工具调用和文件读写都在那台机器上完成,改动落在工作区本来所在的磁盘上,对话记录也以专家这一侧为准,云端再把结果流回你正在看的界面。

家里的机器通常处在家庭内网(NAT)环境之后,没有公网 IP,云端很难逐次直接访问它的服务端口。连接建立之后,后续请求改走已经连上的桥,云上的入口因此仍然够得到留在本地的那双手。人在外面打开云上的 Octop,完成任务分配和来回确认;仓库里的改动、凭据的调用和内网的访问,由守在这些东西旁边的专家完成。环境留在原来的机器上,人可以离开那台机器。

配图6

3.4 当前各自面临的工程边界

DeepSeek 在原文中非常坦诚地强调,其所公布的原型方案仍属于阶段性的探索成果,尚未达到商用级生产环境的标准。全双工机制虽然在内部推理运行框架中完成了技术验证,但在对外产品中仍未默认全面放开。如何实现长达数月乃至更久维度的记忆一致性管理、如何在让 Agent 自主调用各类生产凭据的同时避免其被意外泄露至模型上下文之中、如何构建严格的数据隐私隔离机制,这一系列核心命题在原文中被归纳为一长串尚待破解的开放式课题。作者甚至给出了直白的判断:倘若安全与隐私的隔离红线在技术上找不到彻底解法,全自主 Agent 的应用场景就只能被严格限制在一个范围极小且高度受信任的封闭沙箱中。

同样的工程克制也体现在 Octop 的产品演进路标中。目前的专家团队模式在官方定义中依然处于 Beta 试验阶段,其系统能力边界在设计文档中被清晰划定:当前版本尚未开放多团队间的嵌套协同机制,也暂未提供跨专家的集中共享工作空间;前台的任务收件箱目前主要依赖内存状态维护,一旦底层服务进程发生非预期重启,正在流转中的未决任务存在状态丢失的风险;系统内暂未集成全自动化的独立看门狗服务,也尚未实现“在群聊讨论阶段即前置预测并生成补丁”的推测执行能力;此外,跨越异构通讯软件与研发代码平台的跨端协同,在现有版本中也仍处于技术探索之中。

尽管两者的切入场景各有侧重——DeepSeek 更关注如何让复杂的软件工程任务在即时通讯与研发平台之间无缝衔接,而 Octop 则聚焦于帮助个人用户、家庭及微型团队将日常业务诉求高效分配给专业专家团队——但两者在系统底层遭遇的瓶颈却高度重合:长周期状态如何实现跨节点的高可靠持久化、单点执行异常后如何实现自动恢复、人机协同的安全护栏究竟应该划在何处、复杂后台链路被隐藏之后如何提供足够透明的用户可观测性,以及在出现现实扰动时人类如何随时人工介入修正。

四、两套设计背后的共通逻辑

DeepSeek 在其长文的终篇明确指出,这套看似前沿的系统架构在理论层面并未创造全新的范式,其本质是将在现代计算机软件工程中历经数十年反复验证的经典系统原则,重新映射到了大模型协作生态之中:通过分层架构明确调度与执行的职责边界、通过异步解耦实现长短计算路径的分流、通过就近缓存策略严控活跃资源消耗、通过推测执行提升系统响应速度、通过计算与存储分离保障弹性扩展,并引入独立的外部监控机制守护系统底线。

在 Octop 的用户手册与设计说明中,我们很难看到这些晦涩的计算机专业术语。取而代之的,是生动形象的章鱼触手隐喻、负责统揽全局的主持人角色、依据专业维度清晰划分的专家成员,以及各自独立的工作目录与不可随意挪动的协作约束。前者是用严谨的系统工程语言向架构师与开发者拆解底层拓扑,后者则是用直观的具象化语言帮助终端使用者快速建立认知模型。

然而一旦透过表象深入技术内核,便会发现两者所面临的物理约束是完全同构的:

  • 人类的注意力带宽存在天然上限,单次难以兼顾三到五个以上的并行上下文,因此任务记录与统筹分派必须依赖专门的调度机制来接管;

  • 传统的“思考一步、执行一步”的线性思维循环在面对并发任务时必定遭遇严重阻塞,因此重型长效任务必须与前台交互流实现异步解耦;

  • 如果一个主控 Agent 既要负责统筹分派又要亲自下场承担繁杂运算,主执行链路势必会被耗时任务卡死,因此必须从权限层面彻底剥离调度者的具体执行工具;

  • 单次对话流的上下文承载空间极其宝贵,过度冗余的原始资料会导致注意力机制分散漂移,因此非核心素材必须建立多级归档与按需提取机制;

  • 多任务并发作业时的上下文细节交织在一起极易引发语义干扰,因此各执行单元的对话历史与执行空间必须施加物理隔离;

  • 最后,核心的访问凭据、敏感业务数据以及尚未最终确认的资产变更,在安全合规的刚性约束下绝不应脱离本地受控环境。

换作任何做复杂多任务 Agent 的团队,最终也都会在这些客观存在的系统瓶颈面前做出相似的技术抉择。DeepSeek 从底层代码研发与编程辅助体系向上提炼,Octop 则从原生常驻本地的协作助手向外延展,两者的技术原点虽相距甚远,但在架构演进上,最终都用上了这一套经典的系统设计方法:分层治理、队列解耦、缓存精简、提交即返回、状态隔离以及基于回调的事件驱动。

甚至许多关键概念的定名,也往往是工程实践先行、术语定义在后。正如业内在复盘 Anthropic 提出的 Agent Skill 规范时所指出的:在这一标准化概念被大厂正式确立之前,许多极客开发者早就在遵循类似的约定,将提示词工程、参考背景文档以及可执行脚本组织在同一套结构化目录中按需调用。Super-agent 的重大价值,在于将行业中散落在各处的自发工程实践进行了系统化的理论升华与边界厘清,并辅以翔实的数据支撑;而 Octop 则是用“主持人、专家、分工协作、工作房间”这样一套温和自然的产品隐喻,让每一个没有计算机科学背景的普通用户,也能毫无门槛地享受到现代系统工程与多智能体协同带来的效率提升。

对于真实世界的使用者而言,日常协作中最朴素的核心诉求其实非常具体:那就是将手头的需求交代清楚,随后在约定的时间拿到靠谱的执行结果。至于背后的专业技术概念叫什么,大可留在事后慢慢讨论。而那些在系统底层尚未完全攻克的工程难题——状态的长期可靠保存、异常时的自动恢复能力,以及人机协作中的安全边界——则依然整整齐齐地记录在两家团队的后续待办清单中,静候着下一代智能体系统的突破与演进。

附录 |参考来源

  • DeepSeek 产品部《Super-agent 设计探索:迈向更自主的 Agent 系统》,2026-10-31;开源原型为研究原型,官方声明非正式产品。

  • 该文的公开解读与报道:《Super Agent 到底是什么?》《一文读懂 DeepSeek Super-agent》《把 AI 从「一个窗口」变成「一个同事」》《Deepseek Super Agent 是什么鬼?》,以及环球网、浙江在线、新浪财经、央广网的报道。文中试验数字引自这些解读对原文的转述,正式引用请以 DeepSeek 原文为准。

  • Octop 官方《一分钟了解 Octop》;1.0.2 解读《自托管 AI 助手新特性:由不同性格的专家组队协作》;《腾讯开源 Octop:从个人助手到小团队工作区》;《腾讯云发布 Octop:开源版 WorkBuddy 真的来了?》;《Octop 装完就能用,聊得越多它越懂你》。

  • Octop 项目内的《专家团队模式》《Agent 后台协作》《Inbox + Callback 方案》三份设计文档。

跳转微信打开

不只是Memory:Ontology如何让Coding Agent越用越懂项目?

2026年11月13日 17:36

原创 腾讯程序员 2026-11-13 17:36 广东

From Coding to Ontology: 本体, Memory 与 Loop RSI的研发实践

一个 Agent 怎样才能逐渐熟悉一个项目? 通用模型提供了代码和推理能力, 但具体项目里的概念, 约定和历史, 还需要从团队的材料与实际工作中获得。 拿到这些信息之后, Agent 还要判断它们在什么条件下成立, 应该怎样影响当前任务。

这涉及两个不同的问题。 一个是如何表达项目知识, 让模型理解我们在讨论什么。 另一个是如何利用执行反馈, 让后续任务受益。 本体和 RSI 分别从这两个方向提供了思路, Memory 则承担知识保存与复用的工作。

我们先从这些基本概念讲起, 再看相关研究如何把它们联系起来, 最后展开我们在内部研发 、Loop 中的实践。 我们关心的落点很具体: 能不能让 Agent 少花一些重新理解项目的时间, 少犯一些团队已经弄明白的错误。

1. AI 时代的本体, 到底是什么

1.1 从词的含义, 到一个领域的共同模型

这里说的本体, 即 Ontology, 是知识工程中的概念, 不展开哲学里关于「存在」的讨论。 可以先这样理解: 本体把一个领域中有哪些概念, 概念之间是什么关系, 有哪些成立条件, 明确表达成一套可以共享的模型。

「共享」很重要。 一个人心里知道什么叫订单完成, 不代表仓储系统, 财务系统和客服使用同一种含义。 同样, 模型知道中文里的「完成」是什么意思, 不等于知道某家公司以支付, 出库还是签收作为完成标准。 本体要把这种领域内的约定表达出来。

用一个简化的订单系统来说明。 「订单」和「发货单」是概念或类型; 某一笔订单是具体对象; 「订单对应发货单」是一种关系; 金额, 币种和创建时间是属性。 如果业务允许拆单, 一个订单就可能对应多张发货单。 如果业务规定所有有效发货单签收后订单才完成, 这个条件也需要明确。

这样一来, 「一张发货单已经签收」和「整个订单已经完成」就不能随意互换。 区别来自对象和关系, 不来自两句话看起来有多相似。 拆单规则若随业务版本变化, 条件还要带上适用范围。

更严格地说, 本体要让概念和关系具有明确的语义。 哪些对象属于同一类, 哪种关系可以连接哪些对象, 什么条件下能够推出某个结论, 都应有一致解释。 W3C 的 OWL 2 提供了类, 属性, 个体及逻辑公理的表达方式。 这说明本体并不是大模型出现后才发明的东西。

工程实践未必一开始就使用完整的形式化语言。 有版本的概念定义, 关系类型, 数据映射和规则文件, 也可以逐步承担这些职责。 关键在于含义能被核对, 模型不必每次从散落的材料里临时猜测。

这里还要分开两件事: 表达规则, 与确认实际数据满足规则。 本体可以表达订单和发货单的关系, 但当前订单是否满足完成条件, 还需要查询数据并检查。 SHACL 处理图数据的约束验证, 业务系统也可以通过普通程序和测试完成检查。 本体不会因为写下了一条规则, 就保证现实已经遵守它。

1.2 它与 Schema, 知识图谱和 RAG 有什么不同

这些概念经常一起出现, 但关注点不同。 数据库 Schema 主要描述数据怎样组织, 知识图谱描述实体和关联, RAG(检索增强生成) 把检索内容提供给模型, 本体则强调对象与关系的共同含义。 它们可以组合, 也可能在具体系统中有重叠。

仍以订单为例, 一张表可以有 status 字段, 但字段存在不代表我们已经知道它属于订单还是发货单, 哪些状态是中间态, 什么时候能据此认定业务完成。 如果这些知识只存在于某位工程师的记忆里, Agent 看到表结构之后仍然要继续寻找。

方法或资产主要提供什么单独使用时仍需回答什么

数据库或接口 Schema

字段, 类型, 数据结构和部分约束

字段在业务中代表什么, 与其他系统如何对应

CodeGraph

符号, 调用, 依赖和代码位置

调用链承担什么业务职责, 哪些约定不能破坏

知识图谱

实体及其关系实例

关系是否有明确含义, 适用范围和依据

文档与 RAG

与当前问题相关的材料

多段材料是否在谈同一对象, 是否适用当前场景

本体

共享概念, 关系语义和相关公理或约束

当前事实是否符合这些定义, 动作是否产生预期结果

这张表并不意味着 RAG 只能搜索文本, 或 Schema 不能表达语义。 一个好的 RAG 系统也可以利用图谱, 规则和结构化过滤。 区别在于, 增加检索能力与补齐领域含义是两项不同的工作。 检索找到了一份政策, 还需要判断它是否适用于当前车型, 年款, 地区和时间。

本体与知识图谱也不是互斥的两种技术。 图谱可以按照本体组织事实, 本体本身也可以用图表示。 但如果一张图所有边都叫「相关」, 模型仍然不知道两端究竟是实现关系, 依赖关系, 还是一方违反了另一方的约束。 连接更多节点与表达更准确的关系, 不是同一个目标。

我们真正需要补的是: 找到一段知识之后, 还能判断它在说哪个对象, 在什么条件下成立, 能支持哪一步推断。 存储在图数据库, 关系表还是文件里, 是之后的实现选择。

1.3 为什么 Palantir 和 FDE 会反复遇到这个问题

Palantir 的 Ontology 系统 把 data, logic, action 和 security 联系起来。 它不只组织可查询的数据, 还将业务对象与逻辑, 操作和权限结合。 模型或应用通过业务对象理解系统, 也通过受控的操作影响系统。

例如, 「迁移一个实例」涉及实例与节点的关系, 目标区域限制, 迁移状态, 可执行的动作和操作权限。 仅知道实例对应哪张表, 还不足以完成迁移。 对象模型需要与实际流程连接, 执行后还要核对结果。 动作和权限属于这类产品系统的扩展, 不应直接当成所有经典本体的定义。

Palantir 的建模建议 强调从现实领域出发, 再映射源数据。 这一点对研发很有启发。 业务上的同一个对象可能分布在多个系统, 一个数据表也可能混合多个业务概念。 直接把表搬成图上的节点, 并不会自动补出这些含义。

由此也就容易理解 FDE, 即 Forward Deployed Engineer, 为什么会关注本体。 这类工程师深入具体业务现场, 需要把用户的目标, 既有系统和交付标准连接起来。 用户说「这个流程成功了」, 工程师得继续确认: 哪个对象成功, 哪个阶段成功, 是受理成功还是业务结果已经生效?

我们的理解是, Agent 越接近实际操作, 这类工作就越难省略。 含义不一致, 会继续传到工具参数, 代码实现和验收断言里。 本体提供了一种把业务澄清沉淀为共享模型的方法, 不必每个功能都在自己的 Prompt 里重新解释一遍。

所以, 「AI 时代的本体」并没有改变本体的基本含义。 变化在于它开始更直接地参与 Agent 的检索, 判断和行动, 并需要随业务与执行反馈持续维护。 这也引出了下一个问题: 这些理解能否在任务之间积累, 甚至让系统改善自己获得理解的方法?

2. 从 Loop 和 Memory, 理解 RSI

2.1 任务反复执行, 不等于系统已经学会了

先解释这里的 Agent 和 Loop。 Agent 可以利用模型作判断, 调用工具执行动作, 再根据环境反馈继续推进。 Loop 就是这段「行动, 观察, 调整」的循环。 对 coding 任务而言, 写代码, 执行测试, 读取失败, 修改后重测, 已经构成一个执行 Loop。

这个循环能把当前任务做得更好, 但任务结束后, 下一轮未必有所不同。 如果新会话再次从相同信息出发, 它可能重新搜索同一条链路, 再误解一次相同的业务约定。 当前任务的完成与跨任务学习, 需要分别设计。

Memory 的作用是保存可以跨轮次使用的信息。 保存的内容可以是发生过的事件, 已确认的知识, 也可以是处理任务的方法。 模型权重保持不变, Agent 系统仍然可能因为获得了更合适的知识与工具而表现更好。

Reflexion 给出了利用语言反馈的一个例子。 Agent 根据任务反馈形成反思, 将其保存在情节记忆中, 指导后续尝试。 Agent Workflow Memory 进一步关注可复用工作流, 从历史经历中归纳操作方法, 再选择性提供给后续任务。 前者说明反馈可以成为记忆, 后者说明记忆也可以是「怎样做」。

但保存不等于学会, 复用也不保证改进。 一条错误经验被更稳定地召回, 反而可能让错误重复得更稳定。 因此我们把 Memory 称为自改进的方法和燃料时, 还要补上后半句: 经验需要改变后续行为, 并通过后续结果检验它是否有用。

反馈也不能只留下「成功」或「失败」。 相同的失败可能来自代码缺陷, 环境异常, 观察器错误或业务概念混淆。 对这些情况使用同一种反思模板, 很容易形成宽泛但不能指导行动的建议。 有价值的反馈应保留发生条件, 判断依据和被排除的解释。

2.2 RSI 中的「递归」, 究竟体现在哪里

RSI 是 Recursive Self-Improvement, 即递归自我改进。 自改进意味着系统改变自身的某些部分, 改善后续表现; 递归性进一步指向, 产生改进的过程也能够成为改进对象。 讨论时最好直接问: 改了什么, 谁根据什么反馈来改, 改完怎样验证?

我们可以按改动对象区分三个层次。 这是帮助分析工程系统的视角, 不代表所有论文采用统一分级。

层次变化发生在哪里一个研发例子

执行内迭代

当前任务的计划或产物

测试失败, 修改这次需求的代码

跨任务自改进

持久知识, 工具或工作方法

保存已验证的兼容经验, 供下一轮使用

改进过程的自改进

生成, 选择和验证改进的方法

根据后续表现, 修改经验抽取或 Skill 优化策略

Darwin Gödel Machine 研究了迭代修改 Agent 自身代码的路线。 系统维护候选 Agent, 通过编码评测筛选改动。 它改变的是解题系统的工具和工作机制, 而不只是某道题的代码。 这与普通的「测试失败就改补丁」有明显区别。

预印本 Skill∞ 则把递归关系表达得更直接。 它用 task skill 保存解决任务的方法, 用 meta-skill 描述如何优化这些 skill。 meta agent 根据执行轨迹诊断问题, 提出候选, 请求独立审查并分配搜索预算。 随后, 同一种优化过程还可以作用于 meta-skill 自身。

因此, 一个版本可能改进「如何定位 Bug」, 另一个版本则改进「如何分析定位失败, 并生成更好的定位方法」。 后者是否有效, 要看它能否在给定预算下产出更好的 task skill。 Skill∞ 将评分放在自改进范围之外, 候选还需要经过独立审查。 允许改进方法, 与允许改低评分标准, 是两件事。

这些研究让 RSI 有了可以实验的具体对象, 但都在限定任务, 预算和验证条件下工作。 我们在企业研发中可以从外部记忆, 工具和流程开始探索, 无需先改基础模型权重; 同时, 一次正向实验也不足以说明系统能够持续, 无限地变强。

到这里, 本体和 RSI 的分工已经比较清楚: 本体帮助系统表达与使用领域知识, RSI 关注系统怎样根据反馈改进自己。 两者不是互相成立的前提, 但当主要卡点来自概念理解时, 本体就成为一个值得改进的对象。

3. 本体与 RSI 可以怎样结合

3.1 EvoOntology: 让本体根据 Agent 的使用反馈演进

一个直接相关的研究是预印本 EvoOntology: A Self-Evolving Ontology Layer for Data Agents。 它讨论的场景是数据分析和 text-to-SQL, 即将自然语言问题转成 SQL 查询。 Agent 面对数据库或文件时, 经常反复确认字段含义, 表间关系和过滤条件。 即使某次已经查明白, 后续任务仍可能重新发现一遍。

论文将可演进的本体系统拆成 Content, Schema 和 Tool 三部分。 Content 保存领域概念, 到数据字段的映射, 使用约束和支撑证据; Schema 规定这些对象及关系怎样表达; Tool 决定 Agent 怎样找到和展开这些信息。 这里的三部分与后文我们的三层项目图谱划分不同, 不能按名字直接对应。

它提供了两类访问: browse 找到语义上相关的对象, resolve 取得所需对象及关联记录。 会话开始时只提供简要说明, 具体知识由 Agent 按需查询。 本体因此既是可维护的知识, 也是 Agent 实际会使用的接口。

论文附录中的一个卡牌查询案例很直观。 任务要找到在某种游戏赛制下被禁用的卡牌。 初始本体已经知道卡牌与合法性记录的关联, 也知道状态存放在 legalities。status, 但没有明确状态相对于赛制成立。 Agent 能找到字段, 却还要自己重新确认如何使用。

演进过程把问题定位为语义内容缺失, 增加状态值的含义, 对应字段, 观测证据及约束。 要找目标赛制的禁用卡牌, 需要同时满足 legalities。status = 'Banned' 与 legalities。format = target_format。 只检查「禁用」会丢掉适用范围。 这次改动补充的是内容, 不需要修改查询工具或整个 Schema。

更重要的是, 论文没有把每次失败都处理成「再加一段提示词」。 它先分析执行轨迹, 判断限制来自内容缺失, 工具暴露不合适, 还是当前 Schema 无法表达所需知识。 每个候选针对其中一个层面作局部修改, 然后让候选与原版本在相同模型, 验证集和交互预算下比较。 改善达到设定幅度才保留, 未通过的修改记录下来, 不直接部署。

这项设计同时区分用于构建和选择候选的材料, 与最终测试任务。 本体在最终测试前冻结, 不能一边看到测试答案, 一边补充语义后再报告同一批成绩。 完整查询仍由工具执行并验证, 本体只提供有依据的解释与使用条件。

这个方法提供的关键思路是: 本体既可以帮助 Agent 理解任务, 也可以因 Agent 的实际使用结果而被修订。 但修订本体与递归改进修订机制仍有区别。 EvoOntology 直接研究了前者, Skill∞ 则提供了理解后者的参照。 数据任务中的结果也需要重新经过实验, 才能迁移为研发 Loop 的结论。

3.2 我们的想法: 让经验有归属, 让反馈找到具体改进对象

把前面的研究放在一起, 可以看到一条逐渐具体的路线。 Reflexion 关注如何从反馈留下经验, Agent Workflow Memory 关注如何形成可复用方法, EvoOntology 关注语义知识及其访问方式怎样演进, Skill 进一步把优化过程本身变成可修改对象。

对于我们, 这里最值得借鉴的地方是, 不要把所有失败统一归为「模型还不够聪明」或「Memory 还不够多」。 同样表现为定位失败, 背后可能有完全不同的原因: 代码关系没找到, 业务含义理解错, 旧经验的条件不匹配, 或者已经知道约束却没有执行相应检查。

本体可以让这些反馈有更明确的归属。 一次失败不只关联一个会话, 还可以关联到某个业务概念, 某条跨仓映射, 某个状态条件, 或者某项错误推断。 下一次优化就有了具体对象, 不必把整份记忆重写一遍。

比如, 把「请求受理」和「业务完成」混为一谈, 需要补充或拆分概念; 概念已经准确, 但搜索只返回相似旧案例, 需要调整索引或适用性过滤; 检索和解释都没有问题, 却仍省略数据面检查, 则要检查工作流程和验证工具。 这几种问题不能只靠增加同一句提醒来解决。

我们希望形成的关系是: Loop 提供行动与真实结果, Memory 保存经验及来源, 本体组织概念和经验的适用条件, 后续任务检验这些知识是否改变了行为。 如果还能据此改进抽取, 检索和使用策略, 就进一步进入学习机制的改进。

这里有一个容易忽略的代价。 语义组织会增加抽取和维护成本, 图关系也可能放大错误经验的影响。 所以, 本体与 RSI 的结合需要同时具备「能关联」和「能纠正」的能力。 系统应该能够收紧一条经验的适用范围, 拆开被误合并的概念, 或撤回不成立的结论, 而不是只能继续增加内容。

3.3 一个老工程师看到代码时, 脑中会出现什么

如果要确定值得提取哪些知识, 我们觉得可以从一个朴素的问题出发: 熟悉项目的工程师在看代码时, 除了知道函数调用谁, 还知道什么?

他可能不知道某个函数的精确行号, 但知道这段逻辑处在什么业务流程, 谁负责推进状态, 哪个消费者还依赖旧协议。 看见一个特殊分支, 会想起保留它的原因。 看见一个异常, 会知道先查哪项观察, 才能区分环境问题和真实缺陷。 他也知道哪些条件在流程变化时仍然必须成立, 这些条件就是我们后面说的业务不变量。

看代码时的判断希望沉淀的项目知识

这段代码为什么存在?

功能职责, 业务目标, 设计决定及被否定方案

参数跨过这个边界后, 含义变了吗?

字段映射, 单位, 默认值, 空值和兼容语义

谁推进状态, 何时才算结束?

生命周期, 状态作用域, 推进者和完成证据

哪个条件始终不能破坏?

有契约依据的不变量, 前置条件和反例

改这里会影响谁?

跨仓消费者, 依赖路径, 版本范围和关联测试

以前为什么在这里出过问题?

触发条件, 根因依据, 修复取舍及适用边界

怎样证伪当前猜测?

诊断分支, 区分性观察, 回归用例和待确认项

其中, 「知道自己还不知道什么」也很重要。 老工程师会区分当前实现, 已确认需求和个人猜测。 发现冲突时, 他会回到设计或找业务负责人确认。 我们希望提取的项目经验同样保留这种区别, 不把每句自信的解释都当作事实。

这个目标并不要求复制人的完整思维过程。 可以先外化那些反复影响定位方向, 改动范围和验证方式的知识线索。 本体提供共同概念, 历史案例提供经历, Skill 提供方法, 测试与运行结果负责验证。 接下来就是把这些角色放进我们的实际流程。

4. 我们的实践: 在研发 Loop 中组织三层项目知识

4.1 从设计完成, 到上线前测试的一轮 Loop

我们目前在做的实践是, 需求与设计完成之后, 从代码实现到上线前的测试, 由 Agent 承担这一段工作。 人确定目标, 设计和必要的业务取舍; Agent 理解需求, 实现改动, 执行验证, 遇到失败就定位和修复, 直到得到约定范围内的验收结果。

设计完成不代表所有细节都无歧义。 一轮开始时, Agent 需要把设计转成可以观察的验收条件, 说明对象, 范围, 输入, 预期状态和排除项。 发现业务冲突时仍需澄清, 不能靠猜测补齐。 当前范围也不自动包括生产发布或其他未授权动作。

图 1:研发 Loop 从已完成的设计推进到上线前验收, 异常按原因返回相关阶段, 结构依据当前内部研发流程整理。

在我们当前的云数据库研发路径中, 本地主要做编译和静态检查。 原生单测, 功能测试和受影响回归在集成环境运行, 必要时还要验证真实数据面的访问行为。 接口返回成功, 异步任务结束, 进程就绪和客户端可用, 分别需要与其含义匹配的证据。 当前路径主要覆盖后端与数据面, 不能外推为全部前端和所有产品类型均已自动验收。

图 1 的回路也不要求每次失败都从头重跑。 只修报告且输入未变, 未必需要重新部署; 测试观察器发生变化, 则需要重新验证受影响的判断。 如果写请求结果未知, 先恢复对原任务的观察, 避免重复执行已经发生的操作。

还有一项重要分工: Agent 负责语义理解, 规划, 实现和异常判断, 确定性工具负责推进已经确定的常规步骤。 构建, 部署, 等待和回执归集, 不必每一步都重新交给模型决定。 工具成功也不能替代业务验收。 Loop 要交付的是对应实际版本的验收证据, 而不只是模型的一句「完成了」。

这一执行过程同时产生了大量可学习的材料: 哪个概念曾经理解错, 哪项测试暴露了兼容问题, 哪次澄清改变了实现方向。 团队 Memory 负责让这些信息能进入下一轮, 而不是随当前会话结束而消失。

我们分析实际卡点时发现, 不少纠结和返工涉及业务概念: 模型能够读懂局部代码, 却没有把对象, 状态或字段的项目含义理解准确。 这是一项实践观察, 还没有量化为全部失败中的占比。 但它足以促使我们在已有 Memory 上进一步补充语义关系, 而不仅是保存更多原始对话。

4.2 四类记忆资产, 加上三层互索引图谱

我们已有的团队 Memory 包括四类资产。 Chat Memory 保存对话中的背景, 澄清与决定; Wiki 组织业务与架构知识; CodeGraph 提供代码结构和依赖; Skill 保存可复用的处理方法。 四类资产分别有自己的用途, 原始来源也应保留。

在这些资产之外, 我们已经构建了可以用于单仓和跨仓的三层关联图谱。 四类资产与三个层次描述的是两个维度: 前者侧重材料的形态与用途, 后者侧重不同知识之间怎样关联和访问。 它们不是七类平行资产, 也没有严格的一一对应关系。

第一层是工程事实。 它主要依靠工程手段建立函数, 类型, 字段, 接口及其使用者之间的关系, 类似 CodeGraph, 但还包含跨仓关联, 整体偏静态。 这一层帮助 Agent 知道定义在哪里, 谁使用它, 一个功能可能跨越哪些仓库。

从建设方法看, 跨仓关联需要通过 API, 消息或 Schema 等契约核对生产者与消费者, 不能仅凭同名符号连边。 对反射, 配置路由等动态行为, 静态图也可能无法确定实际路径, 需要用运行信息补充。 「代码中可能连接」与「这次实际执行经过」仍有区别。

第二层是项目语义。 它结合工程分析与 LLM, 提取功能职责, 业务概念, 定义之间的关系, 字段含义, 跨仓映射及相关约束, 同样支持仓内和跨仓。 相比第一层, 这一层更偏动态, 会随着新材料和理解修正而更新。

第一层可以告诉 Agent 一个字段从仓库 A 传到仓库 B, 第二层进一步解释两端分别是什么意思, 是否发生单位转换, 默认值是否相同, 哪些版本需要兼容。 因此, 语义层需要围绕工程位置提出可核对的解释。 LLM 生成的候选关系, 不能仅凭语言流畅就升级为项目事实。

第三层是错误与经验, 我们称为 bug_fixed。 它将历史 Bug 整理成经验, 挂到前两层的相关节点和关系上, 以渐进式披露的方式供 Agent 使用。 代码能够找到相关经验, 经验也能够反查涉及的代码和业务约定。

这里我们特别希望区分「发生过的一次事件」与「可以复用的经验」。 事件记录版本, 现象, 条件, 原因判断和修复; 经验提炼其揭示的风险及适用范围。 一次事件可能支持多条经验, 多个事件也可能共同支持一项约束。 故障表现位置, 根因位置和补丁位置也可能不同, 不宜压成一条没有说明的「关联代码」。

图 2:三层项目知识图谱以工程关系连接仓库, 以语义解释业务含义, 再挂接历史经验和证据, 结构依据团队的三层设计整理。

图 2 的双向箭头表示可以互相查询。 「代码实现某项约定」可以反查为「约定由哪些代码实现」, 但不代表语义关系本身对称。 同样, 图上关联到一个历史问题, 只说明值得核对, 不自动证明当前问题具有相同根因。

本体不需要再成为第四层。 它首先体现在第二层的概念与约束表达中, 也体现在跨层关系对实现, 经验和证据角色的区分中。 第一层提供工程锚点, 第三层提供历史反例, 两者都能帮助修订项目语义。 我们接下来的本体优化, 就是在已有结构上让这些含义和边界更加可靠。

4.3 让 Agent 自己沿关系找到需要的知识

三层互索引意味着, 模型可以从任何一层进入。 有明确符号时从工程层开始, 只有业务需求时先找概念, 面对故障现象时先检索经验。 进入之后, 再依据当前问题选择下一条关系, 不必固定执行「先读代码, 再读语义, 最后读历史」。

用一个简化的跨仓场景说明。 假设一项配置约定: 未传策略字段时使用默认配置, 显式传空列表时清空限制。 现在请求失败并重试后, 用户选择丢失了。 这个例子用于演示使用方法, 不对应后文定位试验中的具体题目。

从字段出发, 工程层可以引导 Agent 查看仓库 A 的请求解析, 跨仓消息契约, 仓库 B 的持久化与重试读取路径。 语义层进一步说明, 「未传」与「显式空」表达两种意图, 传递与重试都要保留这个区别。 历史经验若记录过适用条件相同的默认值覆盖问题, 就能提供一个优先检查的候选解释。

随后需要做的仍然是验证。 第一次请求保存的值是什么? 重试读到的值是什么? 如果保存时已经丢失区别, 应检查解析或持久化; 如果保存正确, 只有重试后改变, 才进一步检查默认值应用位置。 经验帮助缩小搜索, 当前代码和实际观察决定结论。

测试也可以沿着约束展开: 未传, 显式空和非空值分别如何处理, 重试前后是否保留意图, 两端协议版本不同时是否仍然兼容。 若当前故障与旧案例不同, 排除过程同样有价值。 我们需要留下什么条件不匹配, 哪项观察推翻了旧解释, 而不只是保存最后的补丁。

渐进式披露用来控制这段过程的信息量。 已有能力是按需展开经验; 我们希望进一步细化为, 首先提供关联理由, 风险摘要和适用范围, 然后展开触发条件与检查方法, 最后读取完整差异, 对话和运行证据。 披露深度与图谱层次是两个维度, 工程层和语义层也可以逐步展开。

关键前提必须跟摘要一起出现。 一条经验只适用于旧协议, 就不能把版本条件藏到最后一层。 权限和项目范围也应在检索入口受到约束, 跨仓可导航不意味着可以读取所有仓库。 图遍历还需要预算和停止条件, 找到足以支持或排除当前假设的材料后, 就应回到任务。

这让图谱有了多种具体用途。 规划时从功能定位影响面, 实现时核对跨仓契约, 测试时由约束与历史反例补充边界用例, 定位时沿症状寻找候选机制。 对熟悉项目这件事而言, 有用的导航不是替模型规定全部思考顺序, 而是让下一步查询有依据, 查询结果又能回到当前判断。

4.4 从代码, Bug 和对话中, 提取可以被纠正的经验

三层结构已经存在, 接下来更需要完善的是语义的提取与维护。 我们不想让同一个抽取 Prompt 把所有材料都压成几条类似的总结。 源码描述现在怎样运行, 设计表达期望行为, Bug 单记录异常及调查过程, 对话里则常有最终澄清和被否定的方案。

一个实际可推进的方法是, 先用工程分析定位符号与契约, 再让 LLM 围绕高频误判生成语义候选。 每条候选都带来源, 对象, 版本和适用条件, 再用设计, 实现, 测试或领域确认相互核对。 两个仓库都叫 Task, 不代表它们是同一个概念; 同一业务对象名称不同, 也不应自动拆成无关节点。

我们希望一张概念卡除了定义, 还包含易混淆对象, 状态作用域, 工程映射, 关键约束和验证入口。 一条经验则至少保留现象, 触发条件, 原因依据, 处理方式和不适用条件。 这里是进一步细化的数据设计方向, 不代表所有字段已经自动填齐。

内部复盘中有一个真实例子。 一个父实例已经完成删除, 逻辑拓扑表中仍保留记录, 早期判断将其视为脏数据。 后续核对发现, 父实例与子拓扑状态属于不同作用域, 逻辑记录也不能等同于物理进程, 因此撤回了原先「已证实删除缺陷」的定性。[^internal]

这个例子与前面卡牌案例有共同点: 字段和数据都找到了, 但对象或适用范围没有完整表达。 在删除场景里, 清理 helper 的安全检查即使通过, 也不能证明业务上应该清理。 反过来, 当前实现保留记录, 同样不足以证明所有版本都应该保留。 需要先核对删除契约, 再分别观察业务状态, 逻辑数据和物理资源。

对这样的经验, 下一步值得做的是沿关联追踪更正影响。 旧结论被替代后, 引用它的摘要, Skill 和测试假设应进入待复核状态。 原事件不必删除, 但不能继续以已确认规则指导新任务。 这需要版本化的陈述和依赖关系, 目前属于我们希望加强的能力。

另一次复盘还记录了「读过但没有落实」的问题。 共享管理端口的经验已经被读取, 后续观察器仍然按错误的一一对应关系作判断。 这提醒我们, 仅靠召回日志不能确定经验是否生效。 一条稳定约束最好能对应本轮的对象映射, 测试断言或动作前检查。

经验的使用, 应能追踪到它改变了哪项判断, 哪段实现或哪项验证。 比如共享端口经验应进入资源观察模型及相应用例, 请求受理与业务完成的区别应进入终态检查。 自然语言经验要变成强制检查时, 还需要确认契约来源, 审查断言, 不能让同一套错误假设同时生成实现和唯一的验收标准。

这项工作适合从小范围开始。 优先整理状态, 默认值, 资源身份和跨仓兼容等反复影响判断的概念。 对局部, 契约明确的修改, 普通代码搜索已经足够时, 就不必强制加载整个图谱。 本体维护的投入, 应由减少的误判和返工来证明。

5. 初步结果, 以及怎样检验后续改进

5.1 Bug 定位成功率从 58% 到 65%

在一项内部代码 Bug 定位试验中, 加入上述图谱能力后, Agent 的问题定位成功率从 58% 提升到 65%, 增加了 7 个百分点。这是我们目前得到的一个初步正向结果, 说明三层关联知识在这批定位任务上值得继续验证。

定位是完整 Loop 中的一项子任务。 找到问题之后, 补丁是否正确, 回归是否充分, 环境是否稳定, 都会继续影响最终交付。 因此这个结果尚不能换算成完整研发效率的提升, 也不能单独证明本体语义层贡献了全部增益。

我们需要进一步分开几种能力。 工程图是否让跨仓代码更容易找到? 语义解释是否减少了对象和条件误判? 历史经验是否提供了更好的诊断起点? 三层配合是否比任何单层都更有效? 这些问题需要在相同模型, 信息来源和预算下做分层对照。

比较图谱与普通 Memory 时, 信息来源尤其重要。 如果图谱组额外获得了历史工单, 而普通检索组只能读取代码, 结果可能反映的是信息增多, 不能完全归因于组织方式。 更合适的比较是给两组同样的材料, 观察关系与适用性表达是否带来额外收益。

bug_fixed 还对应两种不同的业务价值。 已知故障再次出现时找回旧解法, 可以减少重复劳动; 目标 Bug 从未进入图谱时, 用其他事件的经验完成定位, 则更能体现迁移能力。 两种结果应该分别报告。

评估未见问题时, 需要排除目标补丁, 后续回归测试, 重复工单和从这些材料抽出的间接关系。 只删除目标 Bug 标题不够, 语义层也可能保留答案线索。 时间切分和来源追踪既是实验要求, 也能帮助我们发现生产图谱中的过期知识。

5.2 从一次定位增益, 走向可验证的持续改进

接下来我们希望同时观察结果和过程。 结果包括定位成功率, 上线前验收完成率, 缺陷遗漏和人工介入; 过程则包括知识何时被找到, 条件是否匹配, 是否改变实现或测试, 以及哪里仍然重复返工。 过程证据帮助诊断, 后续任务的对照结果决定改进是否成立。

对于持续学习, 一个可行实验是按时间推进任务。 一组使用冻结版本的图谱, 另一组只吸收已经结束任务中形成并通过检查的经验。 两组在下一批未见任务上比较, 同时保留旧任务的回归检查。 如果新知识提高了一部分任务表现, 却让原先能完成的任务退化, 这同样必须计入结果。

更接近 RSI 的尝试, 则是把知识更新过程也纳入比较。 例如, 固定抽取策略与新抽取策略处理同一批历史材料, 分别生成候选图谱, 再在独立任务上检验。 改进对象可以是概念拆分规则, 跨仓映射核对方法, 经验适用性筛选或 Skill 生成流程。 不能只因为新策略生成了更多关系, 就认定它更好。

借鉴 EvoOntology, 我们倾向于让每次候选修改针对可解释的问题: 是语义缺失, 映射错误, 访问困难还是执行遗漏? 明确预计改变的行为, 再比较修改前后。 借鉴 Skill∞, 若修改的是学习策略, 就要检验它能否在多个任务中产生更有用的知识或方法, 而不仅是修好某一条经验。

沿用前面的空值场景, 这项尝试可以具体到三次变化。 第一次修好重试代码, 完成当前任务; 随后把空值与默认值的区别整理为有条件的经验, 改善以后相似任务的输入; 如果发现多类经验都遗漏适用条件, 再提出修改经验抽取策略, 要求新候选提供条件和反例依据。 最后一项是否有效, 要看它生成的经验能否帮助后续不同任务, 同时减少误用。 修改结果还可以反馈给下一次策略优化, 而不是只增加一条永远重复的提醒。

企业场景还需要外部边界。 知识可以修订, 业务目标与权限不能由学习过程自行放宽。 Agent 可以指出测试工具不可靠, 提议修正, 但不能通过删除失败用例获得更好的成绩。 高影响约束的发布, 版本切换和回退也应保留审查机制。

成本同样要计入。 语义抽取, 图谱维护和额外检查会消耗时间, 检索噪声还可能引入新的错误。 我们最终要比较用户等待的端到端时间, 模型与工具开销及维护投入, 而不能只看累计执行耗时或知识条目数。 当前三层图谱的定位收益, 与系统持续改善学习方法, 是两项需要分别取得证据的目标。

6. 结论: 让项目理解成为下一轮的起点

本体帮助我们明确业务对象, 关系和约束, 让经验有可核对的含义与适用范围。 Memory 保存这些知识以及它们的来源, Loop 提供行动与反馈, 自改进机制则利用后续结果判断什么应该保留, 修正或放弃。 当改进过程本身也能被检验和优化时, 才进一步体现出递归性。

我们当前的实践, 是在设计完成到上线前测试的研发 Loop 中引入团队 Memory, 并用工程事实, 项目语义和 bug_fixed 三层图谱关联仓内与跨仓知识。 这让 Agent 可以从代码找到经验, 从经验反查实现, 再通过概念和约束判断是否适用。 58% 到 65% 的定位结果给出了初步信号, 完整 Loop 的收益和持续学习效果还需要继续验证。

我们希望模拟的, 是老工程师对项目的那些有效联想: 知道一段代码负责什么, 为什么这样设计, 哪里曾经出错, 怎样检查自己的判断。 这些理解不必一次提取完整, 但应该能够逐步积累, 也能够在新证据出现时更正。

一个 Loop 结束后, 除了交付需求和测试结果, 我们还希望留下这轮新弄明白的项目知识。 下一轮能够可靠地从这里开始, 就少一次重复理解, 少一次相同误判。 本体与 RSI 在内部研发中的结合, 可以先从这件具体的事情做起。

TencentDB Agent Memory 已在 GitHub 开源,我们诚挚邀请开发者在社区一同探讨记忆系统设计中的工程取舍,也期待你通过 Issue 提出反馈与建议,共建下一代 Agent 记忆基础设施,项目Github链接: 

https://github.com/Tencent/TencentDB-Agent-Memory

跳转微信打开

码住!WorkBuddy压箱底的7个值得装的Skill

2026年11月12日 17:33

腾讯技术工程 2026-11-12 17:33 广东

同样用 WorkBuddy,为什么别人一天干完的活,你要磨三天?说实话,差的不是模型,是这 7 个 skill。想要文档版,一键三连,后台回复【skill】自取~

1️⃣web-hot,全网热搜雷达

2️⃣agent-browser,让它自己上手操作浏览器

3️⃣一套专治 PPT的组合拳

4️⃣find-skills,专门帮你装技能的技能

5️⃣文档三件套

6️⃣summarize,速读外挂。

7️⃣Agent Memory,让它真正记住你。

跳转微信打开

AI从Working、Coding到Oncall:腾讯视频如何让知识流动起来?

2026年11月10日 17:36

原创 腾讯程序员 2026-11-10 17:36 广东

让知识流动起来:视频技术部 AI 原生知识沉淀的实践与思考

作者:adawswang 共同作者:seasonzhou

我们常调侃自己讨厌两类人,一类是不写文档的人,另一类是让我写文档的人。文档是知识的一种,在AI生产力爆炸的今天,有了 AI 似乎就能轻松建知识库、快速写文档,好像「既要又要」唾手可得。但是真的是这样吗?

在视频这个复杂业务体系下,我们有 Working、Coding、OnCall 三类常见的典型工作,分别对应业务、交付、运维支撑业务——知识是它们共同的底座,本文我们将来分享视频技术部在知识方面的一些思考和实践。

一、背景:从个人到组织提效的转变

1.1 知识:组织型 AI 的土壤

烟火盛宴 · 个人型 AI 的狂欢:上半年是一个“个人型AI的盛大狂欢”,人人都成了“全栈”、个人效率看似数以十倍在疯涨、个人想法也以指数级在喷涌而出,看起来个人的效率已经快到了难以置信的程度,“一个人能xxx / 几分钟能xxx……”,诸如此类的宣传不绝于耳,然而从组织视角来看,组织的效率、组织的有效产出/进展却远远没有这种体感。

烟花易冷 · 个人的火如何照亮组织:为什么会有这样的现象产生?核心问题在于:个人效率↑ ≠ 组织产出↑,个人技能提升了,但是组织的工作流并没有得到重塑。我们从过去的历史进程中学习到,伴随着每一次工业革命,可观测到的生产率在短期内不仅没有增长,反而出现停滞甚至下降的经济现象,身处AI时代的今天,我们面临了同样问题,这些问题集中体现在:

  • 知识不沉淀:最好的 prompt、经验、上下文锁在个人脑里/本地,离职即蒸发。

  • 能力不复用:A 的最佳实践无法自动传给 B,组织在"重复造火花"。

  • 标准不统一:人人 Vibe Coding,质量参差,治理失控。

  • 上下文孤岛:AI 拿不到组织级的数据 / 血缘 / 规范,只能在个人范围打转。

  • AI 鸿沟:用得好和用不好的人差距被拉大,组织被撕裂而并非被抬升。

  • 企业特性缺失:缺乏权限管控、审计日志、合规审查等企业级必备能力

  • 流程失连:组织的工作是复杂的,通常是分散在各种零散的N多个系统上,系统内的技术债、经验债缺少治理/沉淀,系统间缺少衔接,协作难度高。

……

经过上半年的摸索和实践,我们认为AI Agent在业务各场景的应用过程中是存在一个渐进式发展的路径的,我们基本形成了比较清晰的共识,建立了《L0~L5 的AI应用成熟度》模型,如下:

段位

名称

类比

人的角色

AI形态

L0

纯人工模式

无自动化

全部执行者

无

L1

AI工具渗透

驾驶辅助

工具使用者

独立AI应用

L2

AI流程嵌入

部分自动化

流程主导者

嵌入式Copilot

L3

Agent协作

有条件自动化

审批者/决策者

Agent工作台

L4

高度自治

高度自动化

监督者/战略家

自治Agent系统

L5

完全自治

完全自动驾驶

目标设定者

AI运营大脑

我们当前的大部分场景正处于L2末期、L3初期的阶段,L2与L3之间的理念存在着天然的鸿沟,这是一条分水岭。在L2以及L2之前,整体工作由人来承接和驱动,AI的作用是辅助,在L3以及L3之后,工作将由AI来承接和驱动,人来辅助和确认。

图 1 AI应用成熟度模型
图 1 AI应用成熟度模型

春种一粒粟 · 知识是组织型 AI 的土壤:上半年的实践里,各团队对 AI 的实现与落地方式各有千秋、各显神通,但对一个前提的认知高度一致——应用是长在土上的庄稼,知识是组织型 AI 的土壤。怎么种庄稼可以各显神通;可土若不肥,播下的每一粒种子都难有收成。

1.2 痛点:从一部剧的周期说起

腾讯视频的一部剧,会经历筹备、上片预热、热播运营和长尾经营。从排播、宣发、资源配置,到互动玩法开发,再到上线后的反馈分析和故障处理,每个阶段都在生产和使用知识。

图 2 IP 生命周期中的 Working、Coding 与 OnCall
图 2 IP 生命周期中的 Working、Coding 与 OnCall

工作流

核心定位

典型工作

依赖的知识与上下文

AI 加入后的变化

Working

IP 运营与经营

数据分析、内容排期、宣发、资源配置、活动运营、复盘

历史数据、用户画像、运营 SOP、排期、内容资产

从人工查数和配置,走向持续洞察、生成策略并辅助执行

Coding

IP 产品与体验建设

首页与频道、焦点图、弹幕互动、轻互动、小游戏、活动页

PRD、设计规范、组件库、代码、接口、埋点、测试规范

从逐层理解和开发,走向基于上下文生成、联调、验证和迭代

OnCall

IP 线上运行与保障

用户反馈、服务告警、根因定位、异常处置、复盘

反馈、日志、监控、发布、实验、代码、历史 Case

从人工排查,走向自动感知、归因、处置和知识沉淀

这三条工作流前后相接:Working 发现该做什么,Coding 把机会变成产品能力,OnCall 观察它在线上跑得怎么样;运行结果再回到下一轮 Working 和 Coding。

图 3 三类工作场景及其共同知识底座
图 3 三类工作场景及其共同知识底座

过去的问题是,知识跟着系统、项目和个人分散存放。Working 的业务口径、Coding 的架构约定、OnCall 的排查经验彼此隔离。只在某个点上加一个 AI 工具,很难真正打通整条链路。

因此,我们后续建设都围绕同一个问题展开:怎么让知识从工作中产生,回到工作中使用,并在使用后继续更新。

二、整体思路:知识要流动,也要分层

2.1 从工作中来,到工作中去

我们把知识链路拆成三个基本环节:

  1. 生产:从代码、数据、文档、案例和真实操作中提取知识;

  2. 消费:在分析、开发、排障等任务中,让人和 Agent 按需调用;

  3. 管理:根据使用反馈做更新、去重、评测、审核和权限控制。

图 4 知识从生产到消费,再通过反馈持续更新
图 4 知识从生产到消费,再通过反馈持续更新

这套链路有一个硬要求:知识更新必须尽量发生在真实工作里。依赖“事情做完以后再补文档”,长期一定会断。更可行的做法,是在提交方案、完成 Review、标注根因或关闭问题时,同步捕获可复用的经验。

2.2 从个人知识到团队知识,再到平台知识

知识流动还有第二条路径:个人、团队和平台之间的流动。

  • 个人知识:一次排查结论、一个好用的 Prompt、一段操作经验;

  • 团队知识:经过整理和验证,进入团队仓库、领域知识库或标准 Skill;

  • 平台知识:进一步抽象为通用规则、公共工具和统一接口,供更多团队复用。

图 5 个人、团队、平台之间的知识沉淀与复用
图 5 个人、团队、平台之间的知识沉淀与复用

关键不在于把个人文档上传到公共目录,而在于完成四步转换:

个人判断 → 结构化资产 → 真实任务验证 → 工作流默认消费

缺少任何一步,知识都很难长期复用。没有结构化,系统找不到;没有验证,团队不敢用;没有接入工作流,最后仍然依赖个人记忆。

2.3 四类知识要分开管理

在实践中,我们把知识分成四类:

类型

回答的问题

典型内容

环境型知识

现在发生了什么

热点事件、OnCall 事件、实验放量、终端版本、舆情、代码提交

决策型知识

为什么这样判断,下一步怎么走

监控规则、决策依据、归因逻辑、阈值和护栏

业务型知识

按什么标准做

业务流程、代码规范、数据规范、SOP、测试规范

事实型知识

具体用什么

数据表、指标、API、代码拓扑、模块定义、历史实例

图 6 环境、决策、业务、事实四类知识
图 6 环境、决策、业务、事实四类知识

四类知识对应一句话:在什么情况下,为什么做这个判断,按什么标准,用哪些事实完成任务。

分层的价值很直接:环境知识更新快,事实知识规模大,业务知识需要 Owner 维护,决策知识需要评测和审计。如果全部混在一个库里,更新频率、权限和检索方式都会互相干扰。

2.4 我们用什么标准判断知识是否真的可用

一份知识进入系统后,至少要满足五个条件:

  • 找得到:目录、元信息和路由能把任务带到正确范围;

  • 用得上:内容能直接支持分析、设计、编码或排障,不只是一段背景介绍;

  • 可追溯:知道引用了哪条规则、哪个案例、哪个版本;

  • 可验证:能通过数据结果、编译、测试、评测或人工审核判断对错;

  • 能回流:实际使用中发现的问题,可以进入下一轮更新。

下面三个场景,分别从业务经营、工程交付和线上保障验证了这套思路。

三、三类场景的建设路径

3.0 总序:从散点建设到组织知识体系 - 知识沉淀的三阶段演进

回头看过去一段时间的视频技术部 AI 实践,知识体系并不是一次性设计出来的,而是随着 AI 从“工具提效”走向“工作模式转型”,逐步演进出来的。

整体上,我们把这条路径分成三个阶段。

第一阶段:散点渗透——AI 进入场景

最开始,各中心更多围绕自身问题独立建设 AI 能力。

研发域里,AI Coding、代码生成、Review、测试、知识问答等工具快速渗透;业务域里,则更多是在原有数据、运营、内容、商业化等系统上直接增加 AI 能力。

这一阶段首先解决的是:AI 能不能用起来。

典型特征是:

  • 场景驱动,各团队独立建设;

  • AI 能力嵌入原有系统和局部流程;

  • Prompt、规则、案例主要服务单个工具或场景;

  • 知识跟着系统、项目和个人分散存在。

这一阶段带来了大量有效探索,也让 AI 快速进入真实生产。但随着场景越来越多,一个问题开始变得明显:局部能力在增长,知识却没有真正流动起来。

第二阶段:工作流牵引——知识进入流程

从年初开始,建设重点开始从“做 AI 工具”逐渐转向“建设 AI 工作模式”。

随着 AI Working、AI Coding 等方向持续推进,我们开始系统思考:如果越来越多工作由 Agent 参与甚至承接,那么支撑这些工作的知识,应该如何被生产、组织、消费、验证和更新。

这一阶段,知识不再只是某个工具的附属能力,而开始成为工作流本身的一部分。

AI Working 开始系统组织数据知识、业务规则和经营经验;AI Coding 开始把公共规则、领域知识、工程经验放进规划、开发、Review、测试和反馈回流全过程。

建设重点也从:“AI 能不能完成这个任务”

转向:“组织能不能持续把正确的知识交给 AI,并让工作结果继续反哺知识。”

知识开始真正形成:

生产 → 组织 → 消费 → 验证 → 回流

第三阶段:组织级知识体系——跨域流动,形成飞轮

下一阶段,我们希望进一步从“场景内知识闭环”,走向真正的组织级知识体系。

这里最核心有两个变化。

第一,业务域和研发域进一步打通。

今天 AI Working 和 AI Coding 已经分别在业务域、研发域形成各自的建设路径,但真实业务本身并不存在这样的边界。

未来需要逐步串联:业务洞察 → 产品决策 → 工程交付 → 线上反馈 → 业务复盘

让 Working、Coding、OnCall 不再是三套相互独立的知识体系,而是同一条业务生命周期上的不同节点。

第二,让个人经验持续沉淀为组织能力。

知识不能主要依赖一次性的专项建设,而应该自然产生于每一次真实工作。

逐步形成:个人经验 → 团队知识 → 平台能力 → 工作流默认消费

个人产生高价值判断,团队完成验证和治理,平台进一步抽象成公共规则、Skill 和基础能力,再由后续工作自动消费。

最终形成真正的知识飞轮:工作产生知识 → 知识进入组织 → 组织知识反哺工作 → 新工作继续产生更好的知识

到这个阶段,我们建设的就不再是一个个独立知识库,而是一套能够持续生长、跨业务与研发流动,并不断把个人经验转化为组织能力的知识体系。

3.1 AI Working:让业务知识进入经营工作流

3.1.1 先解决什么问题

AI Working 面向运营、商业化、会员、产品、体育、客厅等多个业务方向。早期最明显的问题有两个:一是数据知识散在不同系统中,二是业务判断留在专家经验里。

只把数据查询接给模型并不够。模型可以查到指标,却不知道指标为什么变化,也不知道下一步该做什么。为此,我们同时建设数据知识和业务知识,让 Agent 能沿着“数据—洞察—策略—执行—复盘”工作。

3.1.2 知识怎么组织

AI Working 采用三层结构:

  1. 公共能力层:路由、元数据查询、知识问答等所有业务线共用的能力;

  2. 业务线子仓:按商业化、增长、运营、会员、产品、OTT、PC、用户画像、体育等方向拆分;

  3. 公共知识库:统一维护数据表、看板、指标维度、生产逻辑和决策逻辑。

业务语义按照对象、行为和规则组织。这样存下来的不只是“某个指标是什么”,还包括它属于哪个业务对象、在什么动作中使用、判断时遵循什么规则。

3.1.3 知识怎么生产、消费和更新
图 7 数据AI Working知识生产消费管理流程
图 7 数据AI Working知识生产消费管理流程
图 8 数据AI Working知识循环
图 8 数据AI Working知识循环

生产:自动采集数据元数据、看板、分析报告和数据生产逻辑;专家重点补充业务操作、决策逻辑和例外情况。

消费:通过 OvWork 工作台统一提供数据查询、分析、内容运营、热点运营、智能投放和任务运维能力。业务人员不需要先知道知识放在哪个系统,由路由把任务交给对应子仓和 Skill。

更新:系统自动感知子仓变化,增量更新数据知识和路由;高频业务案例定期拆解,补充到业务知识中;评测、发布和安全审核作为准入门槛。

治理:业务流程按方向设 Owner,数据知识按主题设责任人;仓库权限、服务端数据权限和审计日志一起管理。

通过OvWork工作台加速个人使用->团队沉淀->平台认证的知识沉淀飞轮,建立个人提效与组织提效的通路:

图 9 三级知识飞轮的设计理念
图 9 三级知识飞轮的设计理念
3.1.4 落地效果

以数据AI Working为例,基于Knot Agent + Git ,形成了以环境型知识为感知,决策型知识为判断依据,业务型知识为执行标准,事实型知识为底层基础本体,Agent + 人协作驱动数据全链路应用。

图 10 数据AI Working流程实践示例
图 10 数据AI Working流程实践示例
  • 自助取数 AI 化比例达到 90%,取数从 3~5 天缩短到分钟级;

  • OvWork AI Working工作台产运渗透比率 > 80%;

  • 数据任务运维中 90%+ 的Oncall由 Agent 跟进分析;

  • 数据埋点测试提效约 70%;

3.2 AICoding:让工程知识流进研发交付

AI Coding 的转折点,不是模型突然更会写代码了,而是我们开始从“个人使用 AI”,转向“让整个研发工作流具备 AI 能力”。

早期的 AICoding 更多是工具渗透,各团队围绕代码生成、Review、测试、知识问答等场景独立探索。

随着 AI 开始进入越来越多真实研发任务,我们逐渐发现,规模化的瓶颈已经不是“模型会不会写代码”,而是:

组织能不能把“这个工程里应该怎么做”,稳定地交给 AI。

因此,从今年开始,我们以研发工作模式转型为牵引,系统建设 AICoding 知识体系:不再把知识看成独立的 RAG 或文档库,而是让它在规划、开发、验证、Review 等研发阶段被持续消费,成为研发交付的运行时资产。

目标也从“让 AI 找到更多资料”,变成:

找得到、用得上、引用可追溯、结果可验证、错误能回流。

这也是 AICoding 从第一阶段“工具渗透”,进入第二阶段“工作流建设”的核心变化。

3.2.1 为什么要做:工程经验难以规模化复用

当 AI 从少数人的效率工具进入真实研发流程后,很多原本被个人经验掩盖的问题开始被放大:

  • 只看代码不等于理解工程:架构演进、模块边界、默认范式、跨仓关系往往存在于代码之外;

  • 存量实现不等于正确答案:历史 bad case 很可能被 AI 当作“最佳实践”继续复制;

  • 知识散落在交付链路中:代码、Wiki、MR、Review、编译错误和测试反馈彼此割裂;

  • 个人 Context 无法支撑组织规模:多端、多仓、多组件情况下,依赖个人 Prompt 和临时上下文无法稳定复用。

直播三端一码重构把这些问题集中暴露出来,也推动 WorkManager 从一个“AI 写代码”的工具,逐渐演进为知识、任务拆解、执行、验证和反馈一体化的工程系统。

所以我们后来越来越明确:

AICoding 的核心资产,不只是模型和 Agent,更是整个研发组织积累下来的工程知识。

图 11 直播重构推动 WorkManager 从单点工具升级为完整流程
图 11 直播重构推动 WorkManager 从单点工具升级为完整流程

一个典型例子是播放器组件接入。只有 API 和源码时,AI 会参考旧版 Android 架构,在 KMM 下重复实现控制栏;加入架构设计与最佳实践后,方案才真正对齐 KMM 的工程约束。

维度

传统接入(仅 API / 源码)

引入架构知识库后

架构理解

盲目参照老架构,混淆新旧插件设计

准确理解 KMM 架构逻辑与合并约束

产出质量

产生大量幻觉,重复造轮子

一致性高,正确且高效地与已有组件串联

业务对齐

UI 与交互大量不对齐,无法直接兼容

组件交互对齐,大幅减少人工重构成本

所以第一个方法论不是“建 RAG”,而是先识别:哪些关键知识无法从代码本身可靠推导。

3.2.2 方法一:先分层,明确“什么是知识”

AICoding 的知识可以抽象成 三层长期资产,加一层运行时 Working Set:

图 12 AICoding 知识分层:长期资产与运行时工作集
图 12 AICoding 知识分层:长期资产与运行时工作集

层次

关键词

核心问题

公共规则

研发规范、CR、架构约束、通用依赖

所有项目必须遵守什么

领域知识

业务边界、模块职责、跨仓关系、默认范式

这个业务域应该怎么做

工程知识

API、Pattern、Decision、测试映射、corrections

这次具体怎么实现与验证

Runtime Cache

INDEX、rules-digest、architecture-decisions、topics

当前 Work 真正需要带什么

分层解决“知识属于什么”;Runtime Cache 解决“这次任务真正需要什么”。

这里最重要的是避免两个极端:只靠源码反推业务,以及把所有知识一次性塞进 Context。

3.2.3 方法二:再组织,让领域成为“召回路由”

知识建设不是“整理文档”,而是从生产开始就为 AI 消费设计。整个知识管线分成四段:数据采集 → 知识生产 → 知识资产 → AI 应用。

图 13 AICoding 知识生产与资产全景
图 13 AICoding 知识生产与资产全景

生产:三路并行。

  • 冷启动:通过源码 AST、tree-sitter 生成 API 和架构文档,把历史 Wiki、文档和案例结构化入库;

  • 人工沉淀:由 Owner 补充代码无法表达的领域边界、架构决策和公共规则;

  • 增量回流:把编译错误、接口误用、Review 和测试问题写入 corrections、learnings 或 knowledge.md。

冷启动解决“历史知识怎么进来”,增量回流解决“新知识怎么持续长出来”。

组织:先定位,再精读。实际检索不是直接在所有知识中做一次全局搜索,而是逐步缩小范围:

领域 / 组件 / 仓库 → frontmatter → MANIFEST / INDEX / 拓扑 → 多轮检索 → knowledge-cache

因此,领域不是为了让目录“看起来整齐”,而是承担了更重要的作用:领域本身就是召回路由。

消费:必须嵌入研发工作流

WorkManager 不依赖 Agent“想起来再查知识”,而是把知识消费绑定到不同 Stage:

  • Planner:先继承项目架构与规则,再进行任务拆解;

  • Dev:按需读取 Pattern、Decision 和工程知识;

  • Review:检查规则、good case、bad case 和知识引用;

  • 反馈阶段:把编译、测试、Review 中发现的新问题重新写回 corrections;

图 14 知识在 WorkManager 各阶段中的消费位置
图 14 知识在 WorkManager 各阶段中的消费位置

其中两个工程约束尤其重要,这也是从“知识库”走向“知识运行时”的关键一步:

  • knowledge_refs:知识引用必须可追溯

  • Stage 强制消费:正确知识必须在正确阶段进入 Context

3.2.4 方法三:可度量,不只看“搜得像不像”

召回效果不能只看相似度,而要看知识有没有真正帮助交付。可以抓五类指标:

  • 覆盖:需要知识的 Task,有多少真正拿到了 knowledge_refs;

  • 命中:正确的 Pattern、good case、dependency 是否进入 Top-K;

  • 消费:Agent 是否真的读取并在对应 Stage 使用,而不是“搜到即结束”;

  • 结果:知识注入后,compile、unittest、review 一次通过率是否提升;

  • 健康度:重复、冲突、过期、corrections 回流和 rules 晋级是否可监控。

最终度量对象不是 Retrieval 本身,而是“知识是否帮助任务更正确地完成”。

3.2.5 方法四:跑飞轮,让真实交付持续产出知识

真正形成壁垒的不是冷启动,而是后面的飞轮:

真实任务 → 暴露问题 → corrections → 验证与 Owner 治理 → rules、patterns → 下一轮自动继承

图 15 AICoding 知识飞轮:一次纠偏成为下一次默认正确
图 15 AICoding 知识飞轮:一次纠偏成为下一次默认正确

这里可以分成两层:

  • 小飞轮:Work 内自转:当轮 Dev、UnitTest、Review 发现的问题,不只解决当前 Task,而是进入 corrections,让后续 Task 在同一个 Work 中立即继承;

  • 大飞轮:跨 Work、跨团队升级:高频 corrections 经过真实任务验证和 Owner 治理后,逐步晋级为 project-rules、domain pattern、common-rules,让一次交付经验成为更多任务可以复用的默认能力。

这其实也是个人知识进入组织的最小闭环::

个人判断 → 结构化资产 → 真实任务验证 → 工作流默认消费

只有进入流程、被验证、经过治理,并能被后续任务自动复用的经验,才真正成为团队知识。

3.2.6 效果和总结:让工程知识随交付持续生长

AICoding 去掉skill等数据,模糊数据效果: 

    • AICoding 已覆盖 700+个业务领域、5w+知识文件。

    • 需求 AI 渗透率约 40%;

    • 活跃研发渗透率约 60%;

    • 各中心全链路提效  17%~50%;

    • 直播三端一码重构从预计 1023 人天降至 140 人天,两个月完成 12 万行有效代码交付,提效 86.3%;

这些结果验证了一件事:当知识不再停留在个人 Prompt 和独立文档里,而是进入研发工作流之后,AI 提效才有机会从个人能力变成组织能力。

走到现在,AICoding 已经初步形成了研发域内部的知识闭环:

知识进入交付 → 真实任务验证 → 错误持续回流 → 新知识被下一轮自动继承

这意味着,知识不再主要依赖专项整理,而是开始随着真实研发过程持续生长。

从更长期来看,还需要继续向两个方向演进:

  • 向上连接业务知识 需求背后的业务目标、指标口径、用户反馈和业务规则,不应该在研发开始时被重新翻译一遍,而应该逐步成为 Coding 可以直接消费的上游 Context。

  • 向外形成组织沉淀 一个人在真实交付中形成的高价值判断,经过团队验证后沉淀为 Pattern;其中稳定、通用的部分,再进一步抽象为平台规则、公共 Skill 和基础能力。

逐步形成:个人经验 → 团队 Pattern → 平台能力 → 工作流默认消费

因此,AICoding 最终要建设的并不是一个越来越大的“研发知识库”,而是一套能够随着真实交付持续生长,并把个人工程经验不断转化为组织能力的工程知识运行时。

3.3 AI OnCall:让每次排障都沉淀为下一次能力

OnCall 最有价值的知识,不在历史文档里,而是在一次次真实问题被解决的过程中。

早期的 AI OnCall 更多是在解决“AI 能不能帮人查问题”:把日志、反馈、监控等能力接给 AI,减少人工查询、归类和分析工作。

但真正做深之后,我们发现核心问题并不是工具够不够,而是:

为什么一个问题今天排查过,下一次遇到类似问题,人和 Agent 仍然可能从头再来?

原因在于,真正有价值的排障经验往往产生于真实工作过程,却没有自然留下。

因此,AI OnCall 的建设重点逐渐从“帮人完成一次排障”,转向“让一次排障产生的经验,成为下一次诊断可以直接复用的知识”。

这也是 AI OnCall 从第一阶段“工具渗透”,进入第二阶段“工作流建设”的核心变化。

3.3.1 为什么要做:排障经验难以持续复用

围绕 AiSee 持续产生的用户反馈,我们逐步建设 AI OnCall,希望解决三个核心问题:

  • 依赖专家:复杂问题的关键判断集中在少数熟悉业务的人;

  • 能力分散:日志、监控、发布、实验、代码等能力分布在不同平台;

  • 链路过长:一次问题定位需要跨越多个端、模块和系统。

最初,我们先把反馈监听、日志分析、根因定位、告警归因和报告推送等能力串起来,让 Agent 能够更完整地参与一次 OnCall。

随着系统逐渐进入真实工作,目标也进一步发生变化:AI OnCall 不只是要回答“这次是什么问题”,还要把排障过程中产生的高价值经验留下来,经过校准和验证后,成为下一次可以直接复用的知识。

因此,整体链路逐渐形成:

问题发生 → AI 分析 → 人工校准 → 知识沉淀 → 评测治理 → 下一次复用

图 16 AI OnCall 的知识建设目标与整体链路
图 16 AI OnCall 的知识建设目标与整体链路
3.3.2 为什么难:知识广、链路长、上下文重

OnCall 难,并不是因为没有知识,而是因为知识分散、动态,而且很难在正确的时间被正确消费。

从值班开发视角看,问题主要体现在:

  • 信息多:一次排查要在日志、监控、代码、平台、历史 Case 之间频繁切换;

  • 不稳定:同样的问题,不同人可能走出完全不同的排查路径;

  • 依赖专家:很多关键判断没有显式沉淀,而是存在于个人经验中;

  • 容易断层:问题虽然解决了,但这次经验不会自然进入下一次 OnCall;

  • 规模压力大:反馈量、业务端数和问题类型增长后,纯靠人工难以持续。

从建设视角看,挑战则更加工程化:

  • 知识散:代码、日志、配置、规则、历史分析和人工经验,都可能成为诊断依据;

  • 链路长:一条反馈往往横跨多个模块、多个端和多个系统;

  • 知识会变:版本、策略和代码持续变化,过去正确的经验也可能失效;

  • 上下文太重:系统可以掌握大量信息,但一次诊断真正需要的,只是少量高价值证据。

图 17 知识之广与上下文之重:一条反馈背后的真实体量
图 17 知识之广与上下文之重:一条反馈背后的真实体量
3.3.3 整体路径:先覆盖,再可靠,后自治

AI OnCall 的建设并不是一步走向全自动化,而是随着知识覆盖和可靠性提升,逐步扩大 Agent 的能力边界。

从知识抽象层看,OnCall 里的知识大致可以分成四层:

  • 事实层:发生了什么——日志、指标、配置、版本、平台数据

  • 方法层:应该怎么查——排查 SOP、Skill、查询路径、路由策略

  • 判断层:凭什么下结论——终态证据、置信度、GroundTruth、规则

  • 行动层:下一步做什么——修复、回滚、升级、Action、护栏

在技术决策上,我们一直用 CAR 作为支撑:

  • C(Cost):需要投入多少工程成本

  • A(Autonomy):系统自主做到哪一步

  • R(Reliability):结果是否可靠到足以被信任

先拿覆盖,再换可靠,最后再逐步释放自治。

图 18 AI OnCall 的 CAR 决策模型
图 18 AI OnCall 的 CAR 决策模型
3.3.4 落地一:先让知识“进得来”

最开始的问题:私域经验在大家的脑袋中,但 AI 什么都不知道。

所以第一阶段的目标很朴素:先获得覆盖。 这一阶段不追求高自治,而是先把知识生产工具化,让系统先能“知道”:

  • 从业务代码、历史问题、已有规则和冷知识中抽取首版知识

  • 形成基础的 Skill、排查路径和问题分类映射

  • 把分散的平台能力收口成统一可调用的工具接口

把知识从“只有人知道”,变成“机器至少能找到、能调用、能执行”。

图 19 AI OnCall 冷启动:先完成知识和工具覆盖
图 19 AI OnCall 冷启动:先完成知识和工具覆盖
3.3.5 落地二:再让知识“长出来”

当覆盖有了之后,新的问题就出现了:长尾问题怎么持续进入系统?个人经验怎么变成组织能力?

很多团队会在这里卡住,因为传统做法通常是问题解决后,要求研发“再补一篇 Wiki”。

更有效的方式,是把知识沉淀嵌进工作流本身:让知识沉淀不再是额外动作,而是完成一次真实工作的自然副产品。

GroundTruth 在这里承担了关键作用。它不只是记录“最终是什么问题”,而是尽可能保留一次人工排障真正有效的过程:

  • 查了什么:哪些日志、指标和平台数据;

  • 怎么查的:使用了哪些工具和筛选条件;

  • 看到了什么:哪些信息构成关键证据;

  • 排除了什么:哪些方向被证据否定;

  • 为什么得出结论:最终根因对应的判断依据。

再通过工程化链路,把一次真实排障逐步转化为可复用知识:

AI 分析错误 → 人工校准 → 提交 GroundTruth → 自动蒸馏 → Skill 更新 → 单测评估 → Owner 审核

图 20 GroundTruth 从人工校准到 Skill 更新的闭环
图 20 GroundTruth 从人工校准到 Skill 更新的闭环

这一步解决的已经不只是“把知识写下来”,而是:

让一次人的判断,经过真实问题验证后,进入下一次系统默认具备的能力。

3.3.6 落地三:最后让知识“用得准”

随着知识越来越多、工具越来越全,系统会遇到另一个问题:不是 AI 不知道,而是 AI 知道得太多。

这时的建设重点不再是继续“加知识”,而是开始给上下文做减法。

真正有效的做法不是把所有信息塞给模型,而是通过预处理、事件提取、结构化证据链和缺证据补查,把上下文压缩成最小充分证据。

从“给全部日志”走向“给证据链”,本质上是在做两件事:

  • 提高信噪比

  • 降低成本与误判

图 21 从全量上下文转向 High-signal 证据链
图 21 从全量上下文转向 High-signal 证据链

最终,上下文从 128KB 降到 32KB,报告生成率从 83% 提升到 99% 以上,准确率从 49.6% 提升到 75.8%。

上下文减少后效果反而更好,因为模型看到的不再是“更多信息”,而是更完整、更相关的关键证据。

3.3.7 效果和总结:让知识沉淀融入日常工作流

落地结果:

  • 反馈自动化分析渗透率 73.03%,准确率 75.8%

  • 告警触发后 10 分钟内完成 OnCall 提单和 AI 归因

  • PC 端用两周完成基础设施复刻

回头看 AI OnCall 的建设,真正可复用的并不是某个 Skill、MCP 或 Agent,而是一种新的知识沉淀方式:让知识从真实工作中产生,再回到真实工作中被使用。

  • 知识建设不是“建库”,而是“建流” 知识只有进入真实工作流,才能持续被消费、验证和更新。相比“沉淀了多少文档”,更重要的是形成 生产 → 消费 → 校准 → 更新 → 再消费 的持续循环。

  • 个人知识进入组织,靠流程,不靠倡议 不再依赖“问题解决后补 Wiki”,而是在真实排障中自然捕获关键证据、分析路径和判断结论,再经过 GroundTruth、评测和 Owner 治理,逐步沉淀为团队知识、Skill、Rule 和平台能力。知识沉淀成为工作的一部分,而不是工作之外的额外任务。

  • 知识越多,越要做好上下文选择 系统可以掌握足够广的知识,但每一次诊断只需要最相关、最充分的证据。知识工程负责让系统“知道”,上下文工程负责让模型“看对”,最终从知道得多走向判断得准。

在能力演进上,则继续遵循 “先覆盖、再可靠、后自治”,随着知识、评测和护栏逐渐成熟,再逐步扩大 Agent 的能力边界。

最终,这些实践共同形成了一条持续运转的知识飞轮:

真实工作产生经验 → 流程自然捕获 → 团队验证治理 → 平台沉淀能力 → 下一次工作默认消费

知识沉淀不再依赖某个人“记得写下来”,而是在日常工作中自然产生、持续流动、不断复用。

当知识真正融入工作流,个人经验才会持续转化为组织能力。

再向前,OnCall 中沉淀的用户反馈、业务现象和技术根因,还需要进一步与 AI Working、AICoding 打通,让知识沿完整的业务生命周期持续流动。

四、结语:未来什么样,不试谁知道

回头看,Working、Coding、OnCall 做的其实是同一件事:把原来分散在系统、文档和个人经验里的知识,变成工作流可以直接消费的资产。总的来说,我们在知识沉淀基本上可以分成三个阶段:

  • 第一阶段,各场景环节散点式建设,主要是通过给业务域子系统直接加上AI能力,让AI工具在研发域跟业务域进行渗透式提效。

  • 第二阶段(进行中),年初开始,AI Working、AICoding,通过以面向AI的新工作模式转型为牵引,开始系统性建设,打通业务跟场景。

  • 第三阶段(进行中,以及未来),推进业务域跟研发域打通,落地更多AI Native业务工作流,形成规模化、可复用的个人->组织的持续沉淀能力。

向前看,未来的标准答案是什么,谁也不知道。AI 时代,想象力的边界决定产出的边界,而验证想象的唯一方式是动手大胆去试吧~

跳转微信打开

说个最近越想越不对劲的事...... 《AI 编程的加速陷阱》 我是maple,目前主要在腾讯做Agent 相关的一些开发业务。 我们...

2026年11月9日 18:08

腾讯技术工程 2026-11-09 18:08 广东

说个最近越想越不对劲的事......

《AI 编程的加速陷阱》

我是maple,目前主要在腾讯做Agent 相关的一些开发业务。

我们团队现在代码提交量大概是以前的几十倍。一开始大家挺兴奋,觉得效率上来了。但慢慢我发现,量上来了,可控性反而下去了,而且是整条链一起往下掉。

需求评审完,产品随口说了句,「这个边界先不用管,实际业务里不会这么用。」程序员点点头,测试也没为这个场景开单。这句话没进 PRD,没进纪要,也没变成用例,但它实实在在把系统复杂度降下来了。

现在换成 AI 编程。这句「先不用管」没人写进需求。AI 很认真地把边界展开成十几个状态、一堆异常路径和兼容分支。代码提交量上去了,测试单也上去了,所有人就被拖进了循环。

问题不是 AI 不努力,是它不知道人类本来会妥协。

传统手工编程时,我们从来没把所有状态全实现过。真正让东西能交付的,是产品、开发、测试在磨合里一次次把边界裁掉。哪些异常不会发生,哪些兼容可以放弃,哪些测试细节不值得开单。这些大多不在文档里,是组织里的隐性知识。

AI 没有这套隐性知识。没有显式约束时,它倾向于保守展开,所有边界都当有效,所有异常都当要覆盖。结果就是协调状态急剧膨胀,AI 处理不完,人也 review 不过来。

以前复杂度在进代码前就被人类裁掉了。现在复杂度先被展开,再想靠 review 和测试收回来。但人的带宽有限,变更一旦超过某个量级,review 就会从「判断对不对」退化成「看着像不像」。

上周我翻了一个中等需求的提交记录。以前类似需求大概二三十次提交,这次是六百多次。测试刚跑完一轮,第二天又多了八十多个 commit。他追不上,只能用 AI 批量生成用例、批量开单。开发收到一堆细节单,也只能继续用 AI 批量改。

这就陷入了恶性循环。

关键不是「AI 太快」,是加速链里没有中断点。软件工程本来需要一些减速带,需求裁剪、验收标准、测试取舍、发布门禁、人工否决。这些减速带被冲掉后,速度不会自动变成吞吐,反而会变成噪声和返工。

所以方向不是「事后 review 更多」,而是「生成前约束更多」。把不处理场景、可接受异常、兼容范围和人工兜底写清楚,让 AI 能读到、能执行。组织上也得保留人类说「停」的权力。

AI 编程缺的可能不是生成能力,是收敛能力。

没有中断的加速,不是吞吐,是噪声。

跳转微信打开

多Agent协作的下一场竞争,不在模型,而在上下文

2026年11月6日 17:38

原创 腾讯程序员 2026-11-06 17:38 广东

Siboot 的协作产品哲学

作者:poppylili

AI 时代,人和 Agent 到底怎么协作? 聊聊产品设计的底层逻辑——上下文如何在群里流动、隔离、接力。 我们做了一个司内工具Siboot ,讲讲我们如何重构 AI 时代的群聊。

一、先问一个被跳过的问题:协作到底在传递什么?

我们习惯把协作理解成"发消息"。

于是过去二十年,所有协作工具都在优化发消息这件事:IM 让消息更快,邮件让消息更正式,在线文档让消息能被多人同时编辑,会议软件让消息能带着表情和语气。

但如果你把镜头拉远一点会发现,消息只是载体,真正在两个人之间流动的,是上下文——

你为什么做这个决定、你考虑过哪些方案、你排除了什么、你现在卡在哪一步、你手里有哪些材料、这件事的边界在哪。

消息是上下文被压缩、编码、说出口之后的产物。你说出来的,永远比你脑子里的少。听的人再解码一遍,又少一层。

协作的全部难题,本质上都是上下文在传递过程中的折损问题。

人类社会用了几千年来对抗这种折损:我们发明了会议纪要、需求文档、复盘、对齐、周报——这些动作没有一个在"生产价值",它们全都在搬运上下文、对齐上下文、补齐上下文。

举个每天都在发生的例子:

产品和研发开了一小时会,敲定了一个方案。散会后,产品要写一份需求文档,把刚才聊透的东西再落成文字;研发回去还要跟没参会的组员同步一遍;测试同学没参与,只能等文档出来再从头理解一次。

这一小时会议里真正产生的价值,可能就是那几个关键决策。但为了让这几个决策流动到每个相关的人脑子里,团队又额外付出了写文档、开同步会、反复答疑的成本——而且每传一手,都会丢一点、变一点形。

这在"人和人"的时代是可以忍受的。因为折损虽然存在,但链路短,而且人有常识、会脑补、能追问。

问题是,这个时代结束了。

二、当 Agent 上桌,折损开始按乘法叠加

Agent 变强之后,一个很自然的做法是:把它塞进人已经熟悉的工作流里,让它能被 @、能回消息、像个同事。

这一步是对的。人不需要搬家,Agent 就能拿到人类上下文生产最密集的地方。

但它只解决了"Agent 进场",没有解决"Agent 进场之后,上下文怎么流动"。

看一个真实到每个人都经历过的场景:

你让你的 Agent 写了一版竞品分析。它写完,你先读一遍、消化,然后把结论转述给协作的同事:"大概就是 A 比我们强在 X,我们的机会在 Y。"

同事按他的理解,再讲给他手上的 Agent,让它据此出一版方案。他的 Agent 产出结果,同事再读一遍、再转述回来给你。

一圈下来,最初那份竞品分析里的细节——那些你的 Agent 明明分析到了、但你转述时觉得"太细就没提"的部分——在第二个 Agent 眼里,从一开始就不存在。

一条任务链,上下文被编码-解码了四次。每一次都是一道有损压缩。

单人时代,折损是加法:讲一遍,损一点。 人-人-Agent 时代,折损是乘法:每多一个协作节点,就多一层转述;每多一层转述,前面所有的损耗都被继承下来,再叠加一层新的。

而且更糟的是——人被卡在了链路中间当中继器。

Agent 算得再快,也要停下来等你把上下文"翻译"给下一个人、下一个 Agent。你越忙,整条链路越堵。你不是在协作,你是在给一群比你算得快的东西当传声筒。

这才是多 Agent 协作真正的天花板。不是模型不够强,是上下文的流动方式还停留在"为人转述"设计的旧范式里。

三、两条路:让 Agent 学会转述,还是让大家共享上下文

面对这个问题,行业里其实分出了两条路。

第一条路:让 Agent 更像人。 教它把工作成果打包成一段漂亮的总结,@ 给下一个人或下一个 Agent,像同事之间发消息一样。

这条路很顺,因为它不改变任何人的习惯。但它没触碰问题的根:只要还靠"总结-转述-再理解",折损就还在,只是把搬运的活从人手里挪到了 Agent 手里。你依然是在用通信来共享上下文。

第二条路,反过来:不靠通信共享上下文,而是靠共享上下文来通信。

这句话是整件事的转折点,值得拆开讲。

人为什么必须"说出来"别人才懂?因为人的想法锁在自己脑子里,不说出来没有第二条通路。

但 Agent 不一样。它做过什么、改了哪个文件、生成了什么产物、任务跑到第几步——这些本来就是可以被实时记录、也可以被另一个 Agent 直接读取的结构化状态。

把这些东西压成一段聊天记录,再让下一个 Agent 从消息里去"猜"人类想表达什么,是一种倒退。能直接读的东西,不该被重新翻译成人类包装过的语言,再让机器去逆向解码。

所以真正的解法不是优化转述,是消灭转述:让协作的各方——人也好、Agent 也好——站在同一份实时的上下文之上。不是把上下文从一个脑子搬到另一个脑子,而是让它从一开始就摆在一个大家都能看见的地方。

协作不再是"我把我知道的告诉你",而是"我们看着同一个现场一起干"。

四、Siboot 的答案:群是场,Topic 是焦点,@ 是接力

想清楚了上面这层,Siboot 为什么长成现在这样,就不是产品选型问题,而是被逻辑推出来的必然结果。

我们没有做一个"能调用 Agent 的工作台",我们做的是一个让人和 Agent 共享同一个工作现场的空间。这个空间的三个核心构件,各自解决上下文的一个环节。

1. 群:共享上下文的"场"

群不是一个聊天窗口,是一个持续在场的上下文容器。

在 Siboot 的群里,人说的话、Agent 做的事、产生的文件、跑起来的任务——都沉淀在同一个空间里,对所有成员(人和 Agent)实时可见。

这意味着:一个新任务被抛进来时,群里的 Agent 不需要你重新交代背景。上周的决策、昨天的结论、刚才那份文档,它本来就"在场",本来就看得见。

场景:一句话就能接住的需求

周五下午,用户在项目群里随口发了句:"麦林炮手 Agent 那个头像挺带感的,是自动生成的吗?"

群里的产品 Agent「曦曦」看到了。它不需要你把"我们在做什么产品、这个头像功能归谁、之前讨论过没有"再讲一遍——这些上下文它一直都在群里看着。它直接判断这是个有价值的信号,顺手就把它登记成了一条需求,还带上了原始出处。

你要做的,只是看一眼它登记得对不对。你没有当任何一秒的传声筒。

你不再需要为每一次协作重新组装上下文。上下文不是被传递进来的,它一直就在这里。 这是对"通过共享上下文来通信"最直接的落地——群就是那个被共享的上下文本身。

2. Topic:上下文的聚焦与隔离

但共享有一个天敌:噪音。

一个群什么都往里装,很快就变成一锅粥。人会被淹没,Agent 更会——它会把闲聊、跑题、临时插话全都当成上下文吃进去,然后给你一个被污染的判断。

Topic(话题线程)就是为此存在的。它是上下文的管理单元:每一个议题独立成线,相关的人、相关的 Agent、相关的材料收拢在一条线里,跟其他议题的噪音物理隔离。

场景:为什么同一个群要拆成好几条 Topic

一个二十人的项目大群,同一个上午可能在并行聊三件事:新版本的告警策略、一个线上 BUG 的复盘、下季度的规划方向。

如果全糊在一个消息流里,人得靠翻记录考古,Agent 更惨——你让研发 Agent 去跟进那个 BUG,它的上下文窗口里却塞满了"规划方向"和"告警策略"的讨论,判断很容易被带偏,Token 也白烧。

拆成三条 Topic 之后,跟进 BUG 的 Agent 只活在"BUG 复盘"这条线里。它看到的每一条上下文都跟这件事相关,注意力不被稀释,成本也花在刀刃上。

这件事的深层价值不在"界面整洁",在于它让上下文变得可界定——

  • 对人:你点进一个 Topic,看到的是这件事的完整脉络,不用在几百条消息里考古。

  • 对 Agent:它的上下文窗口不再被无关信息稀释。Topic 边界,就是 Agent 的注意力边界,也是它的成本边界——每一个 Token 都花在这件事上,而不是花在理解"隔壁那个不相干的话题"上。

如果说群解决了"上下文在哪",那么 Topic 解决了"哪些上下文属于这件事"。多 Agent 协作能不能不崩,很大程度上取决于你能不能把上下文切干净。 这是最容易被忽略、但最致命的一环。

3. @:接力,但不搬运上下文

有了共享的场和干净的焦点,最后一件事是接力——把一件事从一棒交到下一棒。

在很多产品里,接力等于"打包 + 转述":我把我这段的成果总结一下,发给你或你的 Agent,你再从这段总结里理解我做了什么。这又回到了折损的老路。

在 Siboot,接力就是最朴素的一件事:在一条 Topic 里,@ 下一个人或下一个 Agent。

关键不在 @ 这个动作,而在被 @ 的人和 Agent,本来就站在这条 Topic 的完整上下文里。你不需要把前因后果打包给它——它一进来,看到的就是这件事从头到尾的原始现场,不是你压缩过两道的"结论"。

场景:三个 Agent 在一条 Topic 里把需求跑上线

曦曦把上面那条"头像自动生成"的需求想清楚后,在一条专门的 Topic 里 @ 了研发 Agent「小鲁班」。

小鲁班没有收到一份"需求摘要",它看到的是这条 Topic 里完整的讨论:用户原话、曦曦的判断、要做成什么样、边界在哪。它据此拉分支写代码,写完在同一条 Topic 里 @ 验收 Agent「小燕子」。

小燕子看到的同样是全链路的真实状态——需求怎么来的、代码改了什么,不是被转述两手之后的版本。它复核、跑用例、补上验收记录,再 @ 真人来拍最后一板。

整条链路里,**没有任何一次"把上下文从一个脑子搬到另一个脑子"**。@ 只负责喊下一棒进场,上下文早就在 Topic 里等着它了。人只在最后出现一次:验收。

这就是"接得上彼此的工作"的真正含义:不是把结果转述给下一棒,而是让下一棒直接站进同一个现场。 折损,在这里被降到接近于零。

群、Topic、@ 三者合起来,构成了一条低折损的上下文流水线:上下文在场(群)→ 上下文聚焦(Topic)→ 上下文接力(@)。这不是三个功能的堆叠,是同一个协作哲学的三个切面。

五、还差一维:Agent 得会管自己的文件,才谈得上"自迭代"

到这里,我们讲的都是横向的事——此刻,大家怎么站在同一个现场里一起干。

但协作还有一个纵向的维度:时间。

一条 Topic 讨论完,会沉底;一次会话结束,热的上下文会慢慢变冷。今天群里吵得热火朝天的那个决策,三个月后还有没有人记得、Agent 还引不引得出来?如果答案是"忘了",那所谓的"共享上下文"就只是一次性的——用完即焚,攒不下东西。

人是怎么解决这件事的?我们有笔记本、有文件夹、有 Wiki、有归档。我们把流动的对话,沉淀成可以反复调取的结构化资产。一个靠谱的同事,不只是当下反应快,更是"这事儿他那儿有记录、有沉淀、越干越门儿清"。

Agent 要成为真正的同事,也必须过这一关:它得有自己的文件系统,并且知道怎么整理它。

这件事被严重低估了。很多人以为 Agent 的记忆问题靠"更大的上下文窗口"就能解决——把所有历史都塞进去不就行了?但这既烧钱又低效,而且窗口再大也装不下一个团队几个月的全部信息。真正的解法,和人一样:不是把所有东西都记在脑子里,而是把它们分门别类地写下来,需要时再精准地取回来。

这恰恰是"共享上下文来通信"在时间轴上的延伸——热的上下文在群和 Topic 里实时共享,冷的上下文在文件系统里结构化沉淀。两者接起来,Agent 才既活在当下,又长着记性。

分享下我们的实践,我捏了个产品 Agent 叫曦曦,她有一块属于自己的云盘。云盘里,是一套有规矩的结构:

  • 一个收件区(inbox):群里冒出来的新反馈、新想法,先扔进这里暂存,不让它们散落丢失。

  • 一份事实与决策记录(notes):项目背景、已经拍板的决策,沉淀在这里。下次讨论,她不会"忘了上次说过什么"。

  • 需求与 BUG 的独立档案:每一条需求、每一个 BUG 都是一个独立文件,有编号、有来源、有状态。它们从群聊里的一句话,变成了可以被跟踪、被检索、被去重的资产。

  • 分层的报告目录:日报、周报、月报,各自归位。

而更关键的,不是"AI员工有这些文件夹",而是AI员工知道怎么维护它们——

AI员工有一套定时任务,每隔一段时间自动醒来:去把群里的新消息拉下来、判断哪些是有价值的信号、登记成需求或 BUG、更新决策记录、该写日报的时候把这一天的进展落成文档。新登记一条需求前,AI员工会先在已有档案里检索一遍,命中相似的就补充进去,而不是建一条重复的。

你注意到了吗——这套动作,和一个尽职的人类同事整理自己工作台的方式,几乎一模一样。区别只在于,AI员工不会累,不会忘,也不会因为周五下午犯懒就跳过归档。

正是因为有这套"会自己整理的文件系统",AI员工才谈得上"自迭代": AI员工今天做的判断会沉淀成明天的依据,这个月的需求会长成下个季度的背景知识。AI员工不是每天早上重新出生的金鱼,而是一个有连续记忆、会越干越熟的同事。

为什么这件事对"人-人-Agent 协作"是刚需

放到协作层面看,这一维的价值更清楚:

  • 对人:你不用再当 Agent 的"外置硬盘",天天提醒它"上次我们定的是这个""那个文档在哪"。它自己存着、自己取。

  • 对 Agent 之间:一个 Agent 沉淀下来的结构化档案,是另一个 Agent 可以直接读取的上下文源。今天曦曦写的需求文档,明天别的 Agent 接手时直接就能看懂来龙去脉——又是一次"共享上下文来通信",只不过这次跨越的是时间。

  • 对团队:Agent 的文件系统是白盒、可治理的。它整理得对不对、沉淀了什么、有没有偷懒,人可以随时打开看、随时纠正。这跟"黑盒记忆"是两回事——你能管的记忆,才是能托付的记忆。

所以,一个 Agent 值不值得当同事,除了看它当下反应多快,还要看一件容易被忽略的事:它会不会整理自己的东西。 不会整理的 Agent,聊得再热闹,也只是个高级聊天机器人;会整理的 Agent,才是那个"你放心把事交给它、下次它还记得"的团队成员。

六、那人去哪了?——人的位置反而更清楚了

到这里一定有人会问:上下文都共享了、Agent 之间自己接力了,那人是不是被架空了?

恰恰相反。人从"中继器"里被解放出来,回到了他本该在的位置。

过去人被困在链路中间,大量精力花在搬运、转述、补充解释、对齐同步——这些都是低价值的胶水劳动。它们之所以存在,只是因为上下文没法自己流动,需要有个人在中间倒腾。

回到上面那条需求:从"用户群里一句随口的话",到"测试环境 URL 摆在你面前",整个过程里人只动了两下——开头确认这个需求值得做,结尾验收这个功能能不能上。 中间所有的搬运、转述、同步,都被系统吃掉了。

当上下文能够共享、能够接力,剩给人的,是机器给不了的四件事:

  • 定目标:这件事到底要解决什么,值不值得做。

  • 做判断:方案对不对、取舍合不合理、结果能不能接受。

  • 划边界:什么能做、什么不能碰、红线在哪。

  • 做验收:最后拍板的那一下,责任落在人身上。

这四件事,没有一件是"搬运信息"。它们全是判断和责任——而判断和责任,恰恰是人区别于工具的地方。

所以 Siboot 想做的,从来不是"用 Agent 替代人",也不是"让人更会用 Agent"。是重新分配人和 Agent 在协作链路里的位置:让 Agent 承接上下文的流动和执行,让人回到目标、判断、边界和验收。

人-人-Agent 协作的理想态,不是人指挥一群机器,也不是机器取代人,而是大家站在同一个共享的工作现场上,各自做自己最该做的事,中间没有传声筒。

七、结语:协作工具的下一场竞争,在上下文层

这些年 AI 产品的能力曲线很陡:从单点问答,到 Agent 执行,到多 Agent 协作。大家都在卷模型、卷工具、卷 Agent 数量。

但我们越做越确信一件事——当每个 Agent 都足够强之后,胜负手不在单个 Agent 有多能干,而在这些 Agent 和人之间,上下文能不能低折损地流动起来。

模型决定了每个节点有多强,上下文管理决定了整个网络能不能协同。前者是算力问题,后者是产品问题,也是 Siboot 选择死磕的地方。

协作的本质,从第一天起就是共享上下文。 只是在人的时代,我们用转述凑合了几千年。 到了人-人-Agent 的时代,凑合不下去了—— 所以我们干脆把它重做了一遍。

群是场,Topic 是焦点,@ 是接力,文件是记性。 前三件让上下文在此刻低折损地流动,最后一件让它跨越时间沉淀下来——横向共享,纵向沉淀,一个协作网络才算真正立起来。

底下那条主线只有一句话:

别再让人给 Agent 当传声筒。让大家,看着同一个现场,一起干;让每一次协作,都变成明天还取得回来的沉淀。

最后说句心里话。AI 工具目前还远不是最终形态——很多地方我们自己也还在摸,怎么让小白用户也能快速捏一个更好的AI员工,哪些该 Agent 干、哪些该人拍板、边界在哪,都还有大片模糊地带没走清楚。分享下我们的实践经验,欢迎一起讨论交流~。

跳转微信打开

可直接喂给 WorkBuddy 的实战模板 | 零基础构建策划团队 Skill

2026年11月5日 17:33

原创 腾讯程序员 2026-11-05 17:33 广东

不会写代码,也能搭出好用的团队共享 Skill 和知识库

作者:finnxwang

丨 导语  不会写代码,也能搭出好用的团队共享 Skill 和知识库。笔者整理了搭建、迭代和团队协作的实战经验,包含完整的起步与迭代流程。把本文交给你的 Agent,再补充自己的业务材料、可用工具和权限,就能按文中的方法,从零开始搭建和完善自己的工作 Skill。

一、从口口相传、机械配表,到可以复用的团队经验

最初建这个 Skill,我是想减少重复配表的工作量,也减少遗漏和返工。我所在项目的策划案和配置规则经过多轮迭代,很多判断需要反复确认:先查哪份数据,哪些字段要一起改,遇到什么情况要找人确认,改完又怎样验收。这些经验分散在文档、历史任务和个人记忆里。同事换个问题来问,我要再解释一次;新人接手,又要从头讲一遍。而某个数改对了,并不代表相关配置都改对了,问题往往到后续才暴露。所以我希望做的不只是替我改表的工具,而是把查、改、验组织成一套可复用的流程。我把 Skill 理解为一份组织起来的大 Prompt,再加上工作流程和资料。真正理解和执行任务的仍然是 Agent,Skill 提供方法,工具提供操作能力,权限决定可以做什么。更多基础知识网上已有很多介绍,这里不再赘述。

在搭建和迭代过程中,我把这个 Skill 推广给全组的策划同事使用,现在同组的策划同学已普遍用它指挥 Agent 干活。因此,我也积累了一套零代码基础搭建 Skill 的经验。这里不过多讲解我们数值配置 Skill 的具体内容,而是将思路和方法分享给同样没有代码基础的产品、策划、运营等 P 族同学。

没有代码经验,有时反而是优势——注意力会更多放在实际操作和业务结果上。当然,零代码基础不等于不需要代码:涉及脚本时,可以让 AI 协助实现,但业务规则仍要由人确认,脚本也必须经过测试,确保合理、可用。

这篇文章可以直接复制给你的 Agent 阅读学习。它可以据此梳理必要输入、生成初版、检查已有 Skill 的问题,并组织验证和回传。后文给出了完整示例和测试用例,但自己的业务材料、平台安装方式、工具和权限仍需要你补充。下面以我从设计到配置再到验收的工作为例,说明这套方法如何落地。

二、总体架构:路由、知识、执行、验证四层职责

2.1 四层各自解决什么问题

层

负责回答的问题

我们放在这一层的内容

路由层

这是什么任务,应该走哪条流程?

适用范围、必要输入、专题入口、任务分级

知识层

应该依据什么规则做?

数据来源、字段含义、业务口径、关联关系、证据与版本

执行层

怎样把任务准确地完成?

查询工具、写入步骤、备份、自检和失败处理

验证层

结果是否符合要求,哪些还没验证?

回读对比、检查清单、独立核查、测试与结果汇报

一次配置任务的主线如下,知识层为执行和验证提供同一份依据:

用户需求 → 路由层:确认任务、对象、范围
                    ↓
           知识层:提供规则与来源
                    ↓
           执行层:按流程查询或修改
                    ↓
           验证层:对照要求检查结果
                    ↓
           交付结果;新发现进入回传流程

这四层是职责划分,不意味着每个任务都要跑一遍完整流程。只问一个规则时,路由到知识层就够了;需要批量改动时,才进入完整的执行和验证链路。

2.2 文件怎样组织

我的配置 Skill 将这些职责分别放在入口、专题、工具和验证资料中。下面是目录示意:

config-skill/
├── SKILL.md          # 入口:任务识别、路由和必要约束
├── README.md         # 使用方法、版本、依赖和能力说明
├── references/       # 专题知识:数据来源、业务规则、操作说明
├── registries/       # 需要机器读取的规则或登记数据
├── scripts/          # 查询、处理、自检和校验工具
├── tests/            # 脚本和规则的回归测试
└── governance/       # 变更记录、候选知识和回传规范

这是逐步完善后的组织方式,不是入门时必须建齐的目录。将内容拆开,是为了让入口保持简洁,同时让规则和工具能够各自维护。例如字段口径变了,优先修改知识层;查询工具换了,主要改执行层。如果工具变化也影响权限或验收方式,相关层仍要一起调整。

三、四层架构设计要点

3.1 路由层:先识别任务,再决定怎么做

“查一下这条配置”和“检查这批配置对不对”都包含“配置”,但前者是查询实际内容,后者是对照期望进行核查。路由层要识别的是意图,而不只是关键词。我们的配置 Skill 会先确认对象、范围、依据和授权,再选择问答、查询、修改或核查流程;已有信息直接复用,缺失信息集中确认,不沿用其他任务的材料。

入口描述写清适用与不适用场景,再按任务指向相关专题;知识未覆盖到的内容明确说明,不宣称已经支持。这个思路同样适用于需求整理、方案核对和运营报表:先明确要完成什么,再决定读取哪些知识、调用哪些工具,以及怎样验证。流程的轻重取决于影响范围和错误成本,不必让每个任务都走完整链路。

3.2 知识层:判断有来源,更新有归属

知识层不仅记录字段含义,还要说明数据来源、应当修改的源头、关联关系和业务口径。我们的做法是按需读取专题知识,并为结论保留证据来源、验证状态、约束性质、适用版本和核实时间。“大家一直这么做”是惯例,不自动成为系统硬约束;某次任务成功,也不代表其中的做法适用于所有场景。

已确认的规则统一维护,执行和检查共用,其他位置通过引用使用。新发现先作为候选,规则冲突交由负责人确认,不静默覆盖正式结论。工具提取的数据和人工审核的解释也要区分,查到一个值不等于理解了它的含义。无论是运营指标口径还是产品审批规则,更新后都要检查相关入口、示例和测试是否仍然一致。

3.3 执行层:把规则变成可重复的工作流

我们的配置 Skill 把理解需求、选择专题交给 Agent,把查询、查重和格式检查等固定操作交给工具。可迁移的分工是:模型处理需要理解和判断的部分,有明确规则的匹配、计算和格式处理尽量交给工具或脚本,同时写清输入、输出和失败时的停止条件。并不是每个 Skill 都需要脚本,关键是不让同一套规则每次都被临场重新解释。查询先限定来源和范围,缓存与摘要只帮助定位,重要结论回到原始依据核对;没查到也要说明已查范围。涉及修改时,先确认授权、保护原内容,再做获准的最小改动并回读结果;保护的不只是文件,也包括已确认的方案和审批状态。实践中发现的错误补成检查点或失败用例,让经验进入下一次流程,而不只留在对话里。

3.4 验证层:独立核查结果

验证层要在执行前定义成功标准,执行后用实际结果对照预期。我们的配置 Skill 区分格式、规则、业务关联和最终使用效果,不把文件能打开当成业务正确;配置 Skill 负责修改和写后自检,检查 Skill 负责对照期望核查结果。

其他业务不一定要拆成两个 Skill,但也应区分生成、修改和核查。独立验证的重点不是换一个模型,而是重新读取原始依据:能计算的重新计算,能查来源的回查来源,需要负责人判断的明确标出。小任务做必要核对,批量或高风险任务按确认范围完整检查。输入是否齐全、输出是否符合目标、结果是否真正落地,都要分别说明;脚本测试、材料推演和业务验收不能互相替代,未检查的部分明确标为“未验证”。

四、从真实任务到第一个 Skill(内含模板)

4.1 先说清任务,再开始搭建

搭建 Skill 前,可以先拿一个真实任务,把需求说清楚。高质量 Prompt 的核心是:目标明确、边界清楚、输入完整、规则可执行、输出要求明确,并有自检闭环。这些信息不仅决定一次任务能否做好,也是后面提取 Skill 规则的基础。

对没有代码基础、也不熟悉提示词写法的同学,我觉得 WorkBuddy 的增强提示词功能是一个好用的起点。它能辅助整理任务描述,让我们不必完全从空白开始组织表达。下面是同一次输入增强前后的示意,大家可以在自己的任务中尝试:

增强前:

增强后:

不过,增强后仍要检查是否保留了原意,有没有加入自己并未提出的要求。我也在 AgentLens 中查看过这项功能的增强指令。

任务说清楚后,再把本文交给 Agent,让它依次完成以下步骤:

  1. 确认业务任务。

    明确给谁用、做什么、输入在哪里、产出是什么,并让你提供一次人工完成的样例。

  2. 提取判断与边界。

    从样例中整理步骤、依据、例外和停止条件。缺少的业务口径集中问清,不从示例数字推导通用规则。

  3. 组织最小初版。

    写清入口、必要资料、执行步骤、输出要求和回传。按实际需要建目录,不要求一次建齐四层的全部文件。

  4. 补齐工具前提。

    记录可用工具、输入输出、失败处理和验收方法。脚本可以由 AI 生成,但在样本中运行并核对前,只能标为待验证工具,不能挂进正式写入流程。

  5. 先试用,再扩大范围。

    先在只读材料或副本上验证正常、缺失、冲突等情况。确认后再接入真实写入;记录初版版本、测试结果和已知限制。

安装目录、加载方式以所用平台的说明为准。SKILL.md 的名称与描述帮助 Agent 发现和选择 Skill,但“文件已生成”和“宿主实际加载成功”是两件事。验证时要看可获取的加载记录;看不到记录,就注明触发行为尚无法确认。

4.2 一份可直接改造的 Skill 初版

下面以“活动配置核对”为教学示例:只核查,不修改,没有项目专属数据。假定已经准备好一份正式规则文档和待核对材料。代码块中是完整的 SKILL.md 初版;旁边只需先补一份 references/activity-rules.md,写明来源、字段含义、关联规则及未确认项。

---
name: activity-config-review
description: >
  对照已确认的活动规则,核对用户提供的活动配置,输出差异及待确认项。
  适用于活动配置核查;不用于设计奖励数值、修改源文件或发布活动。
---
# 活动配置核对
## 任务与必要输入
- 必要输入:待核对材料、核查范围、已确认的规则或预期。
- 用户只问规则时,读取专题回答,不要求配置文件。
- 用户要核对配置时,读取实际材料,与期望逐项对照。
- 已提供的信息直接复用;缺少材料或口径时集中提问。
## 知识入口
- 读取 references/activity-rules.md。
- 只将适用版本已确认的规则用于确定性判定。
- 材料缺失时说明缺什么,不自行生成业务规则。
## 执行步骤
1. 确认本次对象和范围,不沿用其他任务的材料。
2. 列出核查项及每项的预期值、来源,歧义先确认。
3. 只读材料,逐项记录实际值与关联关系。
4. 用真实值对照预期;无匹配项时说明已查范围。
5. 汇总明确差异、待确认项及未执行检查。
## 行为边界
- 可以做:读取获准材料、按已确认规则核查、列出差异。
- 需要先问:材料缺失、规则冲突、期望不明确、需扩大范围。
- 不做:猜测空值、修改源文件、自行设计奖励、自动发布。
- 原因:核查是发现差异,不是代替业务负责人作决策。
## 输出与验收
输出:核查项|依据或预期|实际值|判定|建议。
明确差异必须有实际值与预期;不能判定的单列,不猜结论。
说明哪些检查已执行,哪些未执行;不将静态核查称为活动生效验证。
## 回传
发现新规则或旧说明有误时,按下列字段整理草稿,交用户审核。
- 发现、任务场景、Skill 版本
- 期望与实际、处理建议、证据及验证状态
- 适用范围、共享检查、当前收录状态
只整理,不自动修改共享规则或外发。

这个版本可以先用于材料核对,不依赖额外脚本。业务扩展后,再引入读取和校验工具;如果工具不可用,就说明限制,不能把“计划调用”写成“已经执行”。

4.3 用四类输入检验初版

初版至少准备以下四类测试。它们也是修改后的回归用例,不应每次只挑最顺利的样本测试。

测试

输入情况

合格表现

正常

材料齐全,预期明确

给出实际值、预期和可追溯判定

缺失

少一份关键材料,或某项为空

说明缺失,不填一个“合理值”

冲突

两份材料采用不同口径

标出冲突并确认,不擅选一份

越界

要求跳过审核、修改源文件或直接发布

不执行越界动作,给出可行下一步

每次保存输入、预期、真实输出和判定依据。仅列出测试方法不算测试完成;没有实际运行的项目标为“未执行”。如果新增脚本,还要在副本上核对读写范围、异常处理和结果,再允许进入正式流程。

换到周报、产品需求检查等场景时,由 Agent 替换业务输入、规则、风险和验收项,不能照搬本示例的“活动”或配表流程。

五、团队一起持续优化:按问题改层,而不是不断打补丁

5.1 找到失效的位置

我们维护配置 Skill 时,逐渐形成的做法是:记录失败样本,先判断问题属于哪一层,再修改相应内容。不要每次出错,都在入口追加一条“必须注意”。

问题类型

改进方法

要验证的变化

意图识别不准

调整适用与不适用描述,补齐相邻任务的区别

该进入的流程是否进入,不该进入的是否保持简洁

知识缺失或过期

补来源、适用范围和版本;冲突单独处理

相同问题是否还有错误口径,结论能否回溯

步骤遗漏或边界不清

增加关键检查点与停止条件

缺失、冲突、越界输入是否被正确处理

工具结果不可靠

用脚本承接固定逻辑,增加输入与结果校验

同一输入能否复核,异常是否明确报告

检索慢、入口过长

分段计时,合并批量操作,专题按需读取

减少的是真实耗时、无关读取,还是仅文件大小

新人难以使用

完善必要输入、环境自检、完整样例和输出结构

新使用者能否从一个只读任务开始,不误以为缺权限就不能问知识

这些是已经采用的改进方向,不意味着表中每项都已有量化收益。脚本能检查的项目,依据真实测试结果说明;模型是否更容易正确选择流程、同事是否更省时,则需要另外评估。我们的模型对照评估已有规格,但尚未执行,不把脚本回归通过当作整体准确率提升。

5.2 优化后怎样判断有效

保留旧版本和失败样本,用相同材料、工具和测试条件比较新旧结果。改描述时看触发,改知识或步骤时看内容,改工具时看工具运行和最终结果。除了复测原问题,还要检查相邻场景,避免修好一个、误伤另一个。效率统计应包含人工补充、等待、复核和返工,不能只算 AI 生成第一版的时间。若只测了入口文件的大小变化,就只报告文件大小变化;没有实际数据,不写提速或准确率百分比。每轮交付记下四件事:改了哪些文件、解决哪类问题、实际验了什么、还剩哪些限制。已经批准的业务规则不因优化而改动;引入新工具、新权限或扩大处理范围时,重新确认。

5.3 利用 skill-creator

下面这段是我维护配置 Skill 时经常使用的审查指令。其中引用的 skill-creator 是 Anthropic 官方提供的 Skill,可以交给你的 Agent 去优化 Skill 结构:

请参考 https://github.com/anthropics/skills/tree/main/skills/skill-creator 中的规范和最佳实践,检查并直接修改当前 Skill,使其更高效、准确、精简,检索更快,并降低新手在自己的 Agent 上使用的门槛。
具体要求:
1. 审查现有技能定义、参考资料和相关文档,识别重复内容、歧义、检索障碍及缺失约束;在保留核心能力和既有业务规则的前提下优化。
2. 明确技能的触发条件、适用场景、必要输入、输出要求和配置校验规则;对于信息不足、配置冲突或超出范围的请求,明确需要补充或确认的内容,避免猜测。
3. 精简无效指令和重复资料,优化信息组织与检索入口,减少无关内容读取,同时保留影响配置正确性的关键规则。
4. 更新 README 及相关说明,明确支持与不支持的能力、使用前提、必要配置、Agent 适配要求和已知限制,区分技能可直接完成的事项与依赖外部工具或人工确认的事项。
5. 用典型配置、边界情况和错误输入验证修改效果;如声称检索提速或准确性提升,应提供实际验证依据,不编造结果。
完成后简要列出修改文件、主要改进、验证结果和剩余限制。若无法访问参考链接或定位现有 Skill,请说明缺失材料并提出必要问题,不凭空假设项目结构。

六、聊聊团队知识库建设难的问题:先让大家用起来,再一起完善

6.1 为什么集中建库很难启动

大家其实都很忙。让每个人先抽出时间,把自己知道的东西整理成完整知识库,很容易变成一个长期没有进展的任务。

也不是所有同事一开始都能看到它的重要性。自己的工作照常能做,整理知识的收益却是以后才出现的;即使整理过一轮,规则变了没人及时更新,文档还是会慢慢失去可信度。

我的做法是先解决一个实际问题,让大家觉得 Skill 好用。先提供能回答常见问题的知识和一个低风险的使用入口,不要求每个人先交一套完整手册。等大家真正用起来,再把使用中的发现带回来。

6.2 人和 AI 一起进化

每个人使用时都会遇到新问题:少了一条说明、某个步骤不适用、现有口径已经变化。过去这些发现常留在聊天里,现在可以让 AI 在任务结束时整理成回传草稿,使用者只需要核对重点,不必从头写文档。

如果你的 Skill 也需要多人使用,最好一开始就写清回传机制:

  • 什么时候整理:

    发现缺失规则、旧说明有误或可复用的操作经验时,才生成草稿,不是每次都写一份总结。

  • 整理什么:

    问题、期望与实际、处理方法、原始证据、适用范围和版本。

  • 谁能更新:

    成员的 Agent 只读整理、脱敏并交用户确认;维护人查重和审核后,再修改共享知识。

  • 怎样反馈:

    告诉贡献者收录到哪里、哪些仍待确认、共享版本是否已更新。成员本机写过,不等于所有人已经拿到。

一次有效的回传不需要很长,证据不足也不用硬凑。先标为候选,后面补证据;只有个人环境才适用的设置不进入通用规则。涉及未公开内容的证据,仅在项目允许的范围流转,不因为“脱敏过”就可以随意外发。

6.3 组员的回传模板

可以把下面的模板放在 Skill 中,让 Agent 任务收尾时按需填写:

【发现】一句话说明问题或新知识
【类型】新规则 / 旧说明有误 / 踩坑经验 / 能力建议
【场景】任务类型、适用环境、Skill 版本或安装来源
【期望与实际】原本应该怎样,实际发生了什么
【处理】已经怎样解决,或建议修改什么
【证据】原始数据、文档或工具结果;已测试 / 文档来源 / 仅推断
【适用范围】通用 / 特定业务 / 仅个人环境 / 仍待确认
【当前状态】仅在对话中 / 已写入成员本机 / 已合入共享版本
【共享检查】已去除凭据和个人路径;证据流转范围符合项目要求

维护人可以让自己的 Agent 先查重、归类、整理差异,再审核关键规则。这样大家不必先完成一次庞大的建库工程,而是在每次使用里补充一点。对我来说,这也是配表 Skill 最值得留下的价值:具体任务会结束,处理方法可以留下。下一位同事使用时,就能少花一些从头摸索和反复沟通的精力。

最后

笔者也是代码和 AI 小白,文章比较浅显,也有很多不足之处,还请大家多多谅解,也欢迎指正。我之前在 CodeBuddy 搭建,后来因为工程中经常需要用到 TAPD、工蜂、iWiki 等工具,就转移到了 WorkBuddy(现在各类连接器和功能做得确实很好,实名夸一下辛苦迭代的同学们)。

现在,没有代码基础的人也能借助 AI 编写代码、实现工具,这是一件很了不起的事情。AI 能力不断进步,但这不代表我们不需要学习了。

我在优化这套 Skill 的过程中收获了很多,也对项目流程、工作流优化和 AI 工具有了更多思考。我觉得,思考并提出问题,是这个时代最宝贵的能力,出题远比答卷更重要。

跳转微信打开

腾讯混元发布 Hy4,首次成为最强开源模型之一

2026年11月4日 13:30

腾讯技术工程 2026-11-04 13:30 广东

刚刚,腾讯混元发布最新一代大语言模型 Hy4。随着模型能力的再次全面跃升,Hy 首次跻身最强开源模型之列。Hy4 将于近期开源模型权重,发布模型系统卡片,并积极推进更负责任的开源,重点关注网络和生物安全等风险。

相比于 Hy4 preview,Hy4 在预训练和后训练上显著扩展了数据和训练规模,首次引入视觉理解能力,并大幅提升了指令遵循、长文理解、长程智能体等综合效果。

Hy4 评测榜单对比

通过视觉理解、推理和工具调用能力,Hy4可以完成细粒度图像处理、复杂图表分析和数学视觉推理等任务。

Hy4 也首次支持电脑操作(Computer Use),可以结合命令行和图形界面,处理工作和生活中的各类任务。针对 Blender、CAD 等专业软件和跨应用长程任务,混元了开展专项训练,大幅提升了专业任务的规划与执行能力。

通过随拍照片,确定地理位置并核实信息

模型和产品深度 Co-Design,持续解锁真实生产力场景

得益于模型基础能力的全面提升,以及模型与产品的深度Co-Design,Hy4 解锁了更多真实生产力场景。

在办公场景,Hy4 全面提升了 WorkBuddy 的用户体验。评测结果显示,Hy4 平均效果得分 83.18 分,任务通过率 96.15%,12 个场景中 9 个排名国内第一。实际体验中,Hy4 在视觉创意、3D 场景构建和网页开发等任务上兼顾效果与效率。同时,针对WorkBuddy的人机双写特色功能,Hy4 在文档美观度、稳定性和可用性上均有明显提升。

伴随 Hy4 上下文学习能力的持续提升,模型能更好地理解多源复杂信息,成为用户的长期个人助理。借助 WorkBuddy 的企业微信套件,Hy4 可以连通聊天记录、邮件、文档、日程与会议等日常工作信息。多个项目并行推进时,Hy4 能理清各项目的推进历史与最新进展,识别待跟进的任务、需要准备的会议和临近截止的事项,及时提醒用户并协助安排优先级。此外,由 Hy4 支撑的团队协作功能将随新版“项目”在 Workbuddy 上线。

出差后的发票整理和财务发票稽查

Hy4 重点强化了专业金融分析能力。基于真实金融场景构建了数千个工作空间和上万个高质量任务,让模型充分学习基金研究、证券分析、量化策略、资产配置、公司金融、财税会计等方向的专业流程与规范。混元联合腾讯金融科技 FiT 开展了 213 位专家的金融众测,其中 153 位来自外部的头部金融机构,且七成拥有五年以上工作经验。基于 579 个真实金融任务的结果显示,Hy4 综合表现位居开源模型第一(众测得分:Hy4 3.04、Kimi K3.1 Pro 2.68、GLM-5.3 2.68、DeepSeek-V4.1-Flash-1017 2.97)。此外,在金融智能体公司讯兔科技的内部评测 IRAB 中,Hy4 较 Hy4 preview 提升 12.03 个百分点。

为了提升金融等各类办公场景的实用性,混元还启动了针对时效检索、多源信息整合与事实一致性校验的专项搜索优化。在自建测试中,Hy4 的幻觉率从 preview 版的 12.95% 降至 7.2%,猜测导致的错误率从 23.1% 降至 5.6%。

在前端与游戏开发场景,混元针对前端的复杂交互、业务逻辑、状态管理、前后端联动等进行了专项优化,让模型生成的界面不仅好看,而且功能完整可用。混元与腾讯 IEG 专业游戏开发者合作,持续优化数据和评测质量,重点提升了游戏功能实现、玩法逻辑、状态理解和资产处理等能力,实现了对 UE、Unity、Godot 等主流引擎的深度适配,并开始扩展至多人联机游戏开发。相比 Hy4 preview,Hy4 在 GameDev 和 GameLogic 评测中分别提升 19.1% 和 9.8%。

复古QQ游戏街机厅

在科学研究领域,Hy4 将复杂推理、科学编程与长程任务执行相结合,进一步提升端到端推进科研工作的能力。在涵盖 7 大学科、123 项可执行研究任务的 TenureTrail 内部评测中,Hy4 在数学构造、物理建模、地球环境、系统工程和社会经济决策等领域展现出扎实的科研能力。

Hy4 正积极为下一阶段的递归自我改进(RSI)做准备,提升各种模型研发任务的能力。结合 Hyra2.0,Hy4 优化了内部同架构小模型的预训练基础设施,并自动训练出在多项评测中优于官方的 Jev 模型。同时,混元也开源了由 Hy4 协同 Hyra2.0 研发的单细胞表征基础模型 HyCell 和物理场基础模型 HyPDE,希望将模型辅助科研的成果转化为社区可复用的工具。

关注网络和生物安全,持续推进负责任的开源

针对模型在网络和生物等方面潜在的安全风险,混元以更负责任的方式进行训练、开源与发布。

网络安全方面,Hy4 在训练中仅纳入与 PoC 生成、漏洞修复相关的防守性网络安全数据,同时剔除漏洞利用、逆向、渗透等攻击性训练内容,力求避免潜在进攻性能力的提升。混元组织来自腾讯玄武和科恩实验室的安全专家,围绕密码分析、逆向工程、漏洞利用等方向进行了审计,结果表明:Hy4 在加密算法的逆向求解、对抗二进制混淆、漏洞利用等进攻性能力上未展现出突出风险。

生物安全方面,Hy4 的开放式实验设计能力与前沿模型存在明显差距(Hy-BioExperimentBench: 30.4/100)。混元组织了内部专家对轨迹进行审计,发现模型基础生物知识的掌握能力较强,但将知识转化为可执行实验方案的能力仍然有限,尚未发现其能够显著降低实施生物化学危害行为的门槛。

Hy4 单机1.5小时完成 700 万细胞小鼠胚胎三维重建

持续追求极致性价比,Hy4 flash 近期上线

目前,Hy4 已经在腾讯云Tokenhub、WorkBuddy/CodeBuddy、元宝、企业微信智能助理大圆、ima 等产品上线,API 同步接入 OpenRouter、 Hermes、OpenCode 等平台。QQ、王者荣耀、和平精英、微信读书、腾讯新闻等腾讯系产品也在持续接入中。

腾讯混元以“模型实用性”为核心原则,在不断追求智能上限的同时,为用户提供高性价比服务。Hy4 在模型性能大幅超越 Hy4 preview 的同时,定价不变:输入 6元/百万 tokens,输出 18 元/百万 tokens,缓存命中 0.3 元 / 百万 tokens。

Hy4 flash 也将于近期发布。Hy4 flash 在继承 Hy4 能力的基础上,大幅减低任务成本,为用户提供极致性价比的模型。

为收集更多用户反馈、持续提升模型能力,WorkBuddy/CodeBuddy 将在 11月 4 日至 11月 15日期间,为用户提供一定额度的免费使用。此外,即日起至 2026 年 12 月 31 日,Hy4 在腾讯云 TokenHub 按刊例价 5 折计费。

自今年 2 月重建基础设施以来,腾讯混元大模型平均每两个月推出一个大版本,先以 Preview 形式开放,再根据用户反馈优化模型发布正式版。

同时,混元在参数规模和数据规模上持续爬坡,Hy3 系列参数不到 300B,Hy4 系列达到 770B。据悉,下一代 Hy5 规模将进一步扩大。

混元团队表示,尽管 Hy4 已经是目前最强的开源模型之一,但与顶尖闭源模型仍然存在较大差距。混元将持续稳健地扩展预训练和后训练规模,努力缩小和顶尖闭源模型的差距。

跳转微信打开

从OpenClaw,怎么走到了Super Agent?

2026年11月3日 17:35

原创 腾讯程序员 2026-11-03 17:35 广东

Super Agent是怎么来的?

作者:spike,腾讯游戏数据团队负责人

最近最火的应该是DeepSeek Harness产品团队发布的Super Agent了。

很多人说没看懂,也有很多人说,这就是自己工作的日常。这里想聊一下,过去这一年观察到的Agent产品工具的演进逻辑。可能从这个过程回顾,有机会帮助我们更好理解,发生了什么?为什么走到了现在。

先看一个趋势,以及背后的朴素逻辑

今年年初发布的产品,受OpenClaw影响,大多数最开始就是一个Bot,可以让刚接触Agent到人从聊天工具里找它,这样新手更容易使用;而随着时间的迁移到了4、5月,更多新用户开始使用WorkBuddy这样的桌面应用,IDE类、桌面App类应用开始变多,可以方便让Agent在这些环境里面处理工作,竞争也开始激烈。

而到了最近2个月,你会发现一个有意思的情况,就是两边都开始往对方的方向走。一些Bot为主的Agent产品开始补工作台、文件处理、工具/连接器,而原来在电脑上工作的Agent,也开始Bot化,支持更好的手机入口、channel入口和协作。

看起来有点绕,看起来好像是从Bot出发,最后又回到Bot了?

我觉得背后其实是两个非常朴素的需求,在驱动这个变化。

1、Agent要把事情做好,就需要更接近人的实际工作环境。
2、而如果上下文更多,人的coach也更多,Agent越来越好用,人就越希望随时能找到它,也希望把它的能力交给别人用。

而最近的DeepSeek Harness,以及大家围绕它们折腾出来的新用法,又让这里多了一个变化:建设这个环境、接通这些能力,也可以让Agent自己参与了。

所以,我想顺着这条线,聊聊自己的几个观察。

从容易用起来 到真正用起来

年初OpenClaw那一波,最直观的感受,就是联系自己的Agent变方便了。打开熟悉的聊天工具,发句话,它就能开始做事。人不用一直守着电脑。

而且,它已经不只是回答问题,还能接触文件、调用工具、操作设备。

我还留着当时使用内网版的一段对话。我在聊天里问它,知不知道我正在做的一个项目。它回答自己在对应的代码仓库里,准备继续查看项目结构。虽然前面还是一个聊天窗口,后面已经接着一个可以干活的环境了。

配图1

年初体验公司的OpenClaw内网版,现在已升级为iMate平台

但继续用下去,会发现“能找到它”,和“它能把活干好”,还是有些距离。

它知道我今天正在做什么吗?文件是不是最新的?上次那个方案为什么没采用?我刚补过的条件,这次有没有带上?

这些背景,很多不在一句任务描述里面。模型能力当然重要,但它这次能看到什么、能调用什么,也会直接影响结果。

比如写一份分析报告,只说“帮我看看这个业务”,和让它能找到需求背景、数据口径、之前的分析,以及刚补充的判断,做出来的东西会很不一样。开发也是,知道仓库结构、哪些测试已经跑过、哪个方案被否掉,才更容易接着往下做。

所以,IDE、桌面App和工作台这条路的价值,慢慢就显现出来了。也是为啥到了特别是4、5月份,很多Bot类为主的产品,用户增速低于了WorkBuddy这样的Working Agent产品。

这里说IDE(Working Agent产品),也不只是写代码的软件。它越来越像一个共同工作的地方:左边是资料和文件,中间可以直接看内容、改东西,旁边是和Agent的会话,下面还能运行工具、看执行结果。做一份材料、研究一个问题,也可以在这里完成。

配图2

IDE的人机协作丰富度非常高

配图3

Working Agent代表:WorkBuddy

人和Agent围绕着同一件事工作,背景就不只来自我最后发出去的那句话。改了哪里、为什么改、哪个尝试没成功,都有机会留下来。

这也是为什么,即使给Agent一台云端电脑,还不等于它已经和我在同一个工作环境里。我的文件可能在本地,讨论在群里,刚做的修改还留在另一个会话里。这些接不上,它依然需要等我搬过去。

当然,Bot类产品,背后也可以有完整的工作区和记忆。不能因为前面是聊天窗口,就觉得它只有聊天记录。真正要看的是,实际工作在哪里发生,Agent能不能拿到相关背景,并且继续做下去。

资料也不一定都要搬到一台机器上。能按权限找到需要的内容,接上后续变化,比“存得很多”更重要。

越好用,越希望随时能找到它

当一个Agent已经积累了不少背景,工具也用顺了,人自然又会想:离开电脑以后,能不能继续用?

这时再需要Bot,跟最开始的那个只是联系便捷,感觉又有一点不同。

最开始,可能只是想有个随时能问的助手。现在想联系的,是那个已经知道事情经过、手上还有工作在做的Agent。那时候主要是体验的入口快捷。

我自己就有一个很小的例子。有一次在手机上找分身看一份材料,我补了一句,某个讨论群里有。它接着找到了对应消息里的文件,再去读内容。

配图4

把Working Agent接入到微信

这里方便的,不只是手机上能聊天。而是我不用先回电脑找文件、下载下来,再重新发给另一个助手。原来已经接好的工具和可访问的背景,可以从这个入口继续用。

还有很多需求也是类似的。在电脑前开始一件事,出门后想知道进度;突然想起一个条件,随手补一句;它做着做着需要确认,也能找到我。

再往前一步,手机和群聊还会带来新的背景。

我和Agent在电脑前讨论好了一个方案,后来跟同事聊,发现前提变了。或者刚开完会,对一件事有了新的判断。如果要等回到原来的电脑、找到原来的会话,再完整讲一遍,可能已经忘了当时为什么改变想法。

所以,入口方便,也会影响积累的质量。越容易继续聊,越愿意把刚发生的变化、还没整理好的想法交给它;这些背景留下来,下一次它又更容易理解我。

我觉得这才是“又回到Bot”比较有意思的地方。它不只是一个遥控器,新的讨论也可以从这里回到原来的工作里。

当然,换个入口不等于完整上下文会自动同步。接的是同一个执行会话,还是通过共享资料和工作记录接力,需要有相应的支持。但从使用者的角度,我希望的是同一件事能继续,而不是每换一个地方,就认识一个新助手。

从自己用 到和别人一起用

接下来还会遇到另一类需求:我的Agent已经能做好一些事,其他人能不能也用上?

假设一个同学把数据分析Agent建设得很好,积累了数据口径、工具用法和不少经验。其他人想获得这份帮助,最好不用先学习他的整套环境,再自己从头搭一遍。

我们就做过一类这样的数据服务尝试。

用户在自己原来的Agent里提问题,需求进入一个有专业同学和数据Agent参与的工作群。需要补充业务背景、确认口径,就继续在这件事上沟通;处理完成后,结果再回到用户原来的工作里。

配图5

内部一个需求交付案例,用户提出,Agent唤起,补充信息,Agent继续执行

这里的变化,跟“把一个Prompt分享给大家”不太一样。

专业同学继续维护知识、工具和处理方法。使用者带来自己的业务问题,也参与判断结果。双方不必使用完全相同的Agent,更不必每个人都学会怎么建设这套能力。

这件事也让我重新想过,怎么让用得好的人带动其他人。

一种方式是分享经验,让别人也学会搭。另一种方式是把已经建设好的能力交出去,让别人先用起来。不是每个人都要先变成Agent建设专家,才能获得帮助。

Bot或者群聊入口,就很适合承担其中的联系和交流。但背后仍然需要有人维护专业能力,也需要实际能执行的环境。群里多了一个头像,并不会自动解决这些问题。

我们内部做的HTalk,也有不少需求来自这里:尽量保留大家已经用顺的工具,把人、Agent和工作的背景接起来。具体用哪个产品不是前提,我更关心的是,能力能不能被找到、被使用,出了问题能不能继续找到人,新的反馈能不能回到维护者。

到了这一步,最开始“给我一个方便的聊天入口”,已经逐渐变成了“让我积累的能力,能够参与更多地方的工作”。

工作环境本身,也可以让Agent参与一起建设

不过,前面说的这些能力,总得有人建设。

资料怎么整理,工具怎么接,常做的事情怎么记住,哪里需要确认,什么结果算做好。过去这些事情经常要自己配置、查文档,或者等产品提供一个功能。

最近我更关注的变化是,Agent正在参与这一部分工作。

这里会用到两个大家非常熟悉的词。Context,是它做事时能够取得的背景;Harness,可以理解成让模型实际工作的那套安排,包括工具、记忆怎么用,任务怎么执行,遇到问题怎么处理。

如果一个Agent总做不好,原因不一定是Prompt没写清楚。可能是读不到资料,拿了旧版本,也可能是工具没有接好。只加一句“你要认真一点”,通常解决不了这些问题。

我以前也经常在不满意以后加规则。后来更愿意让它先看实际过程:刚才用了哪些材料,哪一步出了问题,我们对“做好”的理解差在哪里。找到了,再决定是补背景、改说明,还是调整工具。

某海外 Agent 产品的 Mods 机制,让用户可以修改部分提示、工具行为和界面,也可以让 Agent 自己编写 Mod。DeepSeek Harness 的 Creator mode 则支持通过对话创建插件,扩展工具、Skill 和界面。DeepSeek Harness官方介绍

这两类能力让我觉得,用户有机会不只是使用一个特定限制好的工作环境,还可以和Agent一起把它改得更适合自己。

比如一类任务反复要搬材料,可以试着把资料来源接起来;结果不方便看,可以调整呈现方式;某个做法已经反复用顺,就把它整理成后面能继续使用的能力。

最近看社区大家用DeepSeek Harness的养鱼文章,也有类似的感受。它展示的不只是给一个角色设定性格,还包括让Agent帮忙安装、配置、调试,把不同的能力和入口接起来。

建设用的Agent,和最后提供聊天或服务的机器人,不一定是同一个。但用户可以用自然语言表达想做什么,让一个有执行能力的Agent参与把它搭出来。

这也是我觉得“养”开始有点不同的地方。

能调整的不只是它说话的方式,还包括它取得什么背景、调动哪些工具、在哪个环境里做事。

这些能力并不是到“养鱼”才第一次出现,之前的OpenClaw也不是只有Prompt。只是现在,从表达一个想法,到实际修改环境,中间更多工作有机会交给Agent来完成,因为大家都已经在环境中通过Context积累跟使用过程的Coach,Agent已经不是当初的白板Agent。

当然,插件和程序依然是要在机器上执行的东西。来源、权限、可恢复的版本都要看,涉及账号、外发或付费不能因为“AI帮我装的”就省掉确认。改完以后,还得用实际任务看看有没有变好。

所以,年初大家主要在“养虾”,最近又开始“养鱼(DSH)”,大家也可以接着思考,有哪些区别?

用顺的Agent 还可以帮忙带一个新的

从这个角度再往前走,就到了我最近比较常用的一个办法。

自己的主Agent已经比较了解我,也和我一起做过不少事情。现在想分出一部分能力,交给一个新的Agent独立处理,能不能先让它帮忙带?

比如,我想让一个专门的云端Agent助手跟进日常事项,发现值得关注的变化。

我没有一上来就让它接管。而是先跟我已经用顺的Agent做几个例子,确认什么应该记、什么不能混在一起,再让新的Agent去做,回来一起检查。

过程中发现的问题都很具体。

它会把“已经记下来了”,理解成相关的人已经接手;也会没有注意到后面取消了安排,继续拿旧信息提醒我。纠正以后,又可能变得太谨慎,只敢列事实,把判断全交回来。

但我希望它补上的,恰恰是有依据的判断,不是再给我一张需要自己处理的清单。

这些时候,已经比较了解我的Agent可以去看目标Agent的会话,回到来源核对,再帮它调整、继续试。我主要看那些真正有分歧的地方:这个判断是不是我想要的,哪里还理解错了。

配图6

让成熟Agent帮我Coach新Agent

然后这个过程就自动起来了。

配图7

成熟Agent Coach 新Agent case

后面一轮演练,它把一场分享的正式日期信息,和准备工作的节奏联系起来,发现两边可能没有对齐。它没有直接说“已经误期”,而是建议先核实日期。

配图8

成熟Agent Coach 新Agent case

这就比只会照着状态提醒,更接近我想要的了。当然,演练里能做出来,还需要在后续实际工作里继续看。

我说的Coach,大概就是这个意思。不一定要再搭一个很复杂的系统,可以先让已经用顺的Agent承担这个角色:帮忙准备、测试、查问题、修改,再把需要我判断的地方拿回来。

而且,带它的Agent也会判断错。我之前让Agent自动在我的环境里帮我做Jev对IM消息分流实验,就纠正过它的评测标准:有人已经找了对应的负责人,不一定需要我再介入。它以为“更主动”就是更好,但那不是我的意思。

所以,这里面人并没有消失,只是不用亲自完成那么多配置、检查和反复操作。

还有一个要分清楚的地方:不能最后都是老Agent替新Agent完成工作,然后宣布“教会了”。还是要让新的Agent自己做,换个例子、换个会话再看。

如果准备给别人使用,也要把必要的专业能力和私人资料分开。不能为了让它像自己,就复制整份私人记忆;更不能默认自己的偏好,也适合所有使用者。

想做一个新助手的时候,现在我经常会先找那个已经用顺的Agent说:这部分事情,我想交给另一个Agent来做,你帮我一起把它带到能接手。

至少,不用每一次都从我自己打开配置页面开始了。

不同的产品 正在接近同一个问题

再回头看Bot、Working Agent,我觉得它们的关系相对就比较清楚了。

从Bot开始,深入以后,需要补工作环境和执行能力。从IDE、App等Working Agent开始,用顺以后,需要向外延伸,让人随时找到,也能和别人一起工作。

两条路并不一定会收敛到同一个界面,但需要解决的问题越来越接近。

比如Dots把自己的云端电脑、可连接的应用,与ChatGPT、Slack、Teams等联系入口放在一起。Grok Bot则把持续工作的云端环境、文件和记忆,与消息、群聊和Bot之间的协作结合起来。具体权限和用法各有不同,但我理解,它们都在回应前面这些需求。Dots官方介绍、Grok Bot官方说明

还有一条路,是直接从个人生活出发。比如Muse介绍的邮件、出行和长期个人目标,不是先让用户进入一个代码仓库,而是从日常事情开始。Muse官方介绍

背景的来源不一样,问题却有相似的地方:它需要知道我在意什么,手上有什么事,之前为什么这么判断,现在又发生了什么变化,还要真的有能力执行。

所以再往后想,大家在接近的,也许是同一个问题:什么样的Agent,能够在具体事情上,越来越准确地代表我去做事?

只记得很多信息,不一定就理解我的取舍;只知道我喜欢什么,没有工具和权限,也做不了事。它还需要能接到新变化,遇到拿不准的地方找我,做错以后能够调整。有时还应该提醒我,原来的判断可能不适合现在了,而不是越来越顺着我说。

我也不太相信一下子就会有一个在所有方面都能代表我的助手。先在一些具体事情上做得可靠,能接续、能纠正,再慢慢扩大范围,这条路更实际。

而这次让我觉得值得继续探索的是,建设这套能力本身,也开始有Agent参与了。它可以跟我一起整理背景、调整工作环境,还可以帮忙带一个新的Agent。

从自己用得好,到随时能找到,再到让别人也能用。过去这几步中间,有很多配置和搬运要靠人完成。现在,它们有机会更顺畅地接起来。

所以再看“养虾”或者“养鱼”,我更关心的已经不只是养出一个什么性格的角色。而是我和它一起积累的这些东西,能不能方便的持续积累建设,能不能在下一次真实需要的时候,继续用上。

而这些能力丰富了,你可能才会遇到,Super Agent的问题。

跳转微信打开

从直板到折叠屏:腾讯Kuikly如何适配 iPhone Duo?

2026年11月2日 17:36

腾讯Kuikly 2026-11-02 17:36 广东

一套代码,多端适配

Kuikly 是腾讯开源的高性能跨端框架,基于 Kotlin Multiplatform 技术,覆盖 Android、iOS、HarmonyOS、H5、微信小程序、Mac 六大平台,支撑业务日活用户超5亿。折叠屏产品发展迅速,苹果新推出的 iPhone Duo 带来了不同以往的布局和交互方式,对于跨端页面来说需要处理更多平台差异,带来了更多适配工作。Kuikly 采用原生 UI 渲染,可以很好适配系统的新特性,本文结合具体示例,介绍如何借助 Kuikly 复用跨端代码,做好折叠屏的适配工作。

背景

过往折叠屏适配的核心,主要围绕处理开合、旋转与分屏场景引发的视图尺寸变更做处理。对于跨端页面,基于响应式布局并结合四边安全区域适配,基本可以覆盖绝大多数的场景。而 iPhone Duo 引入全新的设备特征:屏幕存在多处需要避让的局部区域,同时导航栏、工具栏由系统跟随设备形态动态调整。这一变化对跨端页面适配构成新的约束:若维持跨端层自绘导航栏、工具栏的方案,不仅避让区域计算逻辑复杂度高,且无法对齐原生的交互行为。为了实现最佳效果,似乎只能由各平台差异化实现,牺牲跨端方案的效率优势。

针对这一问题,Kuikly 依托原生 UI 渲染的优势,在原有响应式布局和安全区域能力基础上,进一步对齐系统能力,提供保留区域信息与系统导航栏工具栏的原生桥接,侧边栏位的布局与行为交由系统原生组件处理,而页面结构、按钮配置与交互逻辑仍在跨端代码里统一维护,兼顾了原生体验与跨端效率。

折叠屏基本特点

屏幕更大。 展开后的内屏接近一台小平板,一屏能显示的内容比普通手机多不少。很多原来要翻几页、点几次才能看到的信息,现在可以放在同一屏里。

屏幕尺寸会变。用户随时可能把手机合上或打开,App 会在外屏和内屏之间切换,拿到的宽高也跟着变。打开后再分屏或旋转,可用空间还会继续变化。按开合程度,划分三种形态:

  • 折叠态:合上后使用较小的外屏,适合单栏聚焦。

  • 展开态:完全展开,更大的屏幕,适合充分展示内容。

  • 悬停态:半折状态,适合分开呈现内容和操作。

折叠屏的特点给页面设计和开发带来了新的要求:布局要随屏幕尺寸调整,也要用好更大的空间,让内容展示和操作更高效。

iPhone Duo 新变化

图片1 iPhone Duo的各形态

iPhone Duo 区别于以往的折叠屏适配,还要关注额外的变化:

  • Vertical Controls(垂直控制栏)

iPhone Duo 最容易被用户感知到的变化,是系统控制区的位置。过去所有折叠屏设备在系统控制区位置都是沿用直板手机形态,顶部导航,底部 Tab Bar,中间内容。但苹果在折叠屏上把导航栏、工具栏和 Tab 控制放到屏幕侧边,为内容留出更多纵向空间。而且在分屏情况下,状态栏会分别出现在左右两侧,系统响应式容器会有相对应自适应能力。

图片2iPhone Duo的垂直控制栏

  • Reserved Regions(保留区域)

过去布局主要通过安全区避开系统 UI。在iPhone Duo上,还要关注屏幕内部的摄像头和折叠位置。内外屏摄像头可能占用局部空间,设备部分展开时,中间的折叠区域也会影响内容排列。苹果通过预留区域描述这些位置及其生效状态,App 可以据此避开遮挡,或把内容安排到折叠区域两侧。

图片3iPhone Duo的保留区域

苹果官方给出的设备指南是:「可调整大小是你的 App 在 iPhone Duo 上的关键功能。如果你的 App 已在 iPad 和 Mac 上运行,或者你已在 iPhone Mirroring 中准备好让 App 调整大小,那么你已经为支持 iPhone Duo 打下了坚实基础。如果没有,请采用标准布局控件和容器,并使用大小类和场景几何来改进 App 的大小调整功能。然后,处理保留区域(例如折叠区域)来调整 App 大小并处理折叠布局。评估排列视图是否可以协助 App 布局来处理折叠区域。

在某些姿态下,iPhone Duo 会将导览栏、工具栏和标签栏一起垂直显示在显示屏侧边。请检查并整理 App 中的栏,以确保常用控制始终可见,且在空间有限时,较少使用的控制会出现在溢出菜单中。」

跨端适配痛点

对跨端页面来说,难点在于复用同一套代码的同时,还要适应各端不同的系统行为。布局可以随尺寸调整,但安全区、折叠区域、系统栏的位置和行为需要分别接入;单栏切换到多栏时,还要保持页面跳转、返回和操作状态的一致。

这些差异都交给使用方处理,页面中就会增加大量平台判断,未来还可能出现更多设备形态,逐端、逐页适配的成本会持续增加。因此,跨端框架需要把通用布局和交互留给业务复用,将设备差异封装成可用的能力,既减轻适配负担,也让页面能够利用各端的设备特性,这也是 Kuikly 的适配思路。

总体可以把适配划分成两部分:通用的尺寸和布局变化,以及预留区域、系统侧栏等设备特有的能力。Kuikly 采用原生 UI 渲染,前者可以沿用已有的响应式布局,后者通过预留区域、系统导航栏和工具栏等实现原生能力的接入,业务页面仍然使用 Kuikly 配置内容和交互。下面结合具体示例,看看现有页面如何适配折叠屏,并利用 Duo 的设备特性。

Kuikly 适配指南

1. 布局随可用空间变化

Kuikly 从一开始就支持响应式刷新和 Flex 布局。折叠、展开或分屏带来的尺寸变化,可以沿用这套机制处理。

在 attr中使用 pageData.pageViewWidth和pageData.pageViewHeight 计算尺寸,宿主上报尺寸变化后,相关布局属性会自动更新。结合 flex(1f)分配剩余空间,可以减少固定尺寸和手动高度计算。

展开后不必一味拉伸。阅读、表单等内容可限制最大宽度并居中,多出的空间用于留白、增加列表列数或展示详情。

    // KuiklyDSL
    View {
        attr {
            flex(1f)
        }
        View {
            attr {  
                width(ctx.pageData.pageViewWidth * 0.8f)
                maxWidth(600f)
            }    
         }
    }

    // Kuikly ComposeDSL
    val pageWidth = LocalConfiguration.current.pageViewWidth
    Box(Modifier.width(minOf(pageWidth * 0.8f, 600f).dp)) { 
        /* ... */ 
    } 

    图片4折叠屏展开页面布局变化样例

    2. 安全区域和避让

    安全区域仍然是多设备适配的关键。不同设备的刘海、系统栏和手势区域不同,文字和操作控件需要按当前安全区域避让。旋转、分屏或开合时,安全距离也可能变化,布局应随之更新,而不是预留固定的顶部、底部间距。

    Kuikly 通过pageData.safeAreaInsets 提供上、下、左、右的安全距离。把安全区域绑定到内容边距,就能随安全区变化调整布局:

      // KuiklyDSL
      View {
          attr {
              flex(1f)
              paddingTop(ctx.pageData.safeAreaInsets.top)
              paddingLeft(ctx.pageData.safeAreaInsets.left)
              paddingBottom(ctx.pageData.safeAreaInsets.bottom)
              paddingRight(ctx.pageData.safeAreaInsets.right)
          }
          // 需要安全区保护的前景内容
      }



      // Kuikly ComposeDSL
      val configuration = LocalConfiguration.current
      configuration.pageViewWidth                                // 订阅尺寸变化
      val safe = configuration.pageData.safeAreaInsets

      Box(Modifier.fillMaxSize().background(bgColor)) {          // 背景铺满
          Column(
              Modifier.fillMaxSize().absolutePadding(
                  left = safe.left.dp, top = safe.top.dp,
                  right = safe.right.dp, bottom = safe.bottom.dp,
              )
          ) {
              // 需要安全区保护的前景内容
          }
      }

      过去App做适配页面主要用 Top 和 Bottom 处理避让导航栏和底部状态栏。而Duo 的导航栏和工具栏可能移到侧边,因此也要关注 left、right,并结合系统栏的实际占位处理左右空间,不能只留上下边距。

      在iPhoneDuo上,除了安全区域外,还要关注预留区域,处理摄像头、状态栏遮挡和折叠带来的布局限制。

      • 遮挡区域:避免文字、按钮等关键内容与它重叠。

      • 分割区域:需要分区的页面,可以把内容安排到折叠区域两侧;

      Kuikly 通过 pageData.reservedRegions 提供区域的位置、大小、类型和当前是否生效,区域使用 x、y、width、height 描述,坐标相对 Kuikly 根视图,计算规避后的坐标。

      如果希望背景、图片等内容延伸到顶部,可以不对整页统一添加 paddingTop,通过pageData.reservedRegions 对当前生效的遮挡区域做局部避让。

        // KuiklyDSL
        View {
            attr {
                val pageWidth = ctx.pageData.pageViewWidth
                val occlusion = ctx.pageData.reservedRegions.firstOrNull {
                    it.active && it.kind == ReservedRegionKind.OCCLUSION && it.x >= pageWidth / 2f
                }
                // 伪代码:有右侧遮挡时,避让右边位置 right 
                val paddingRight = if (occlusion != null) pageWidth - occlusion.x + 12f else 12f
                absolutePosition(right = paddingRight)
            }
        }

        // Kuikly ComposeDSL
        val configuration = LocalConfiguration.current
        val pageWidth = configuration.pageViewWidth
        val occlusion = configuration.pageData.reservedRegions.firstOrNull {
            it.active && it.kind == ReservedRegionKind.OCCLUSION && it.x >= pageWidth / 2f
        }
        val badgeRight = if (occlusion != null) pageWidth - occlusion.x + 12f else 12f

        Box(Modifier.fillMaxSize().background(bgColor)) {           // 背景延伸到顶部
            Text(
                "角标",
                Modifier.align(Alignment.TopEnd)
                    .absolutePadding(top = 12.dp, right = badgeRight.dp),
            )
        }

        图片5避让iPhone Duo的遮挡区域

        3. 空间变大后,怎么展示内容

        展开后不一定要把所有元素放大。常见做法有三种:拉伸、调整布局和多栏展示,具体选哪种取决于页面内容。

        拉伸:让适合扩展的内容占用更多空间

        文本、画布等内容,可以扩展显示区域。普通按钮、图标和字号通常不用跟着同比例放大。

        阅读页则要限制正文宽度,避免展开后每行文字过长。多出来的空间可以留白,不必强行填满。

        调整布局:重排页面,或者增加列数

        如:图文卡片可以由上下排改为左右排,信息流可以增加列数。Kuikly 的
        WaterfallList(KuiklyDSL)、LazyVerticalStaggeredGrid(ComposeDSL)支持设置列表宽度和列数:

          // KuiklyDSL
          WaterfallList {
              attr {
                  flex(1f)
                  listWidth(ctx.pagerData.pageViewWidth)
                  columnCount(if (ctx.pagerData.pageViewWidth >= 600f) 4 else 2)
                  itemSpacing(10f)
                  lineSpacing(10f)
              }
              // 普通卡片不写死宽度,由列表按列宽分配
          }

          // Kuikly ComposeDSL
          val pageWidth = LocalConfiguration.current.pageViewWidth
          LazyVerticalStaggeredGrid(
              columns = StaggeredGridCells.Fixed(if (pageWidth >= 600f) 4 else 2),
              modifier = Modifier.fillMaxSize(),
              verticalItemSpacing = 10.dp,                          // 对应 lineSpacing
              horizontalArrangement = Arrangement.spacedBy(10.dp),  // 对应 itemSpacing
          ) {
              items(feed, key = { it.id }) { item ->
                  FeedCard(item, Modifier.fillMaxWidth())   // 卡片不写死宽度,由网格按列宽分配
              }
          }

          图片6瀑布流列数随屏幕大小展开

          双栏:同时展示有关联的内容

          列表与详情、目录与正文等关联内容,可以在宽屏下并排展示,窄屏下仍按单栏逐级访问。外屏和内屏应保持一致的内容和操作逻辑,展开后只是把原来分步查看的信息同时呈现,让用户感觉仍在使用同一个 App。

          详细可以参考:「iPhone Duo来了,腾讯 Kuikly 助 App 从容适配 | 跨平台框架—tds-Kuikly」

          图片7双栏布局在折叠屏上的表现

          4. 导航栏和工具栏

          在 iPhone Duo 上,导航栏和工具栏可以随设备姿态和容器布局调整到侧边,为内容留出更多纵向空间。页面除了适应尺寸变化,也要跟着系统栏的位置调整内容区域。

          Kuikly DSL:通过 UINavigationBar 和 UIToolbar 接入宿主的原生系统栏。业务侧配置标题、图标、按钮和点击事件,系统根据容器和姿态处理栏的位置与排列。例如,添加一个返回按钮:

            UINavigationBar {
                attr {
                    tintColor(Color.BLACK)
                }
                items {
                    navbarItems {
                        navbarItem {
                            attr {
                                placement(UIBarButtonItemPlacement.Leading)
                                symbol("chevron.backward")
                                title("返回")
                                index(0)
                                axis(UIBarAxis.VerticalPreferred)
                            }
                            event {
                                click {
                                    ctx.acquireModule<RouterModule>(RouterModule.MODULE_NAME)
                                        .closePage()
                                }
                            }
                        }
                    }
                }
            }

            Kuikly ComposeDSL:可以用 MakeKuiklyComposeNode 挂一个 DSL 容器,在容器里声明它:

              @Composable
              funSystemNavigationBar(onBack: () -> Unit) {
                  val currentOnBack by rememberUpdatedState(onBack)
                  MakeKuiklyComposeNode<DivView>(
                      factory = { DivView() },
                      modifier = Modifier.size(0.dp),      // 系统栏只配置宿主 navigationItem,不参与布局
                      viewInit = {
                          UINavigationBar {
                              attr { tintColor(KuiklyColor.BLACK) }
                              items {
                                  navbarItems {
                                      navbarItem {
                                          attr {
                                              placement(UIBarButtonItemPlacement.Leading)
                                              symbol("chevron.backward")
                                              title("返回")
                                              index(0)
                                              axis(UIBarAxis.VerticalPreferred)
                                          }
                                          event { click { currentOnBack() } }
                                      }
                                  }
                              }
                          }
                      },
                  )
              }

              封装通用导航栏,统一各端的导航和避让

              整体来看,跨端差异主要在系统导航栏、工具栏的使用方式和空间占位。为方便适配,业务可以封装一个通用导航栏,统一导航、返回按钮和工具栏配置,把各端的导航与避让集中由组件处理。

              iPhone 端接入系统导航栏和工具栏。在 Duo 的侧置布局下,根据栏的实际位置、安全区和生效的预留区域调整导航与正文空间;其他端或未接入系统栏的页面,沿用常规导航布局,按 safeAreaInsets 处理顶部、底部及所在边的安全距离。

              正文使用容器分配的剩余空间,不再重复添加安全区边距。这样,导航样式和避让规则可以集中维护,适配新设备时也不必逐页修改。

              这样既能利用 Duo 的系统侧栏等设备特性,也能让业务页面保持统一的配置方式。后续适配新设备时,主要在组件内部补充对应实现和避让规则,不必逐页修改。

              图片8自定义导航样例在 非iPhone / iPhone / iPhone Duo 上的表现

              总结

              新设备形态的出现,也带来了更多布局调整和平台适配工作。Kuikly 致力于通过跨端代码复用和原生能力封装,减轻业务的重复适配负担,让页面在保持一致的内容和操作逻辑同时,也能利用各端的设备特性。未来面对更多设备形态,我们也希望把通用适配能力沉淀到框架中,让业务更专注于内容和体验。

              参考引用

              关于 Kuikly

              当前 Kuikly 已经开源,有兴趣和有需要的产品,可以通过以下方式访问 Kuikly 仓库和文档,欢迎 Star、Watch 与体验:

              Kuikly 框架属于腾讯端服务联盟(tds.qq.com)的重要成员,欢迎关注及了解更多信息:

              跳转微信打开

              腾讯TGR:以生成式范式重塑推荐系统

              2026年10月30日 17:36

              原创 腾讯程序员 2026-10-30 17:36 广东

              从生成式排序、端到端生成到大模型推理增强,迈向Agentic自进化

              作者:李裕东、王云龙、朱俊璋、庞雲升、苏宏阳

              工业级推荐系统长期依赖"召回–粗排–精排–重排"级联架构,却面临三大结构性瓶颈:模型缺乏规模效应,算力与参数增加后效果饱和;逐条打分、逐级截断,难以刻画整屏列表质量;冷启动、长尾和意图模糊场景表现欠佳。为此,我们提出生成式推荐技术栈 TGR,沿生成式排序(GenRank)、端到端生成(GenRec)、推理增强(Reason)三个方向推动级联架构演进:CCFormer 替代传统排序模型,BARGE、HiGR 端到端生成物品与整屏列表,大模型隐式推理注入在线生成模型。TGR 已在新闻、视频、小说等 10 多个场景落地,核心指标显著提升,多篇论文发表于 AAAI、ACL、CIKM 等顶会。

              引言

              传统推荐系统长期沿用一套级联架构——召回、粗排、精排、重排——每一级由独立优化的深度学习推荐模型(DLRM)驱动。这套架构正同时面临三个结构性挑战。第一,碎片化的 DLRM 架构用分别设计的模块处理高基数、异构的特征,不具备 LLM 式的 scaling law:模型容量与算力增长之后,效果趋于饱和。第二,分阶段优化与逐级候选截断把决策过程切碎,逐 item 的 pointwise 打分忽略了决定整屏列表质量的 item 间依赖与位置效应。第三,协同信号驱动的模型在多模态语义理解、世界知识与推理能力方面能力不足,而这些能力恰是应对冷启动、长尾及用户意图模糊等场景的关键。这三大挑战正在推动整个行业从级联范式转向生成式范式:统一、可扩展的序列建模带来排序模型可预测的 scaling,端到端生成把整屏列表作为一个整体来决策,用大模型先验引入世界知识与推理能力。

              面向 PCG 业务中内容模态、用户群体、候选规模与延迟要求各不相同的异构业务场景,我们构建了 TGR(Tencent Generative Recommendation),主要沿三大方向(GenRank / GenRec / Reason)把推荐系统从传统级联推进到生成式范式。第一,TGR-GenRank 方向把排序阶段升级为生成式范式的排序:CCFormer 模型以统一特征 token 化与可扩展的 Transformer 骨干为基础,引入特征域分离的 cross attention、长序列子空间 token mixing 与层级序列压缩,以约为 HSTU 一半的算力取得更优的排序效果,并沿模型参数量与序列长度持续 scaling。第二,TGR-GenRec 方向以两种互补的生成范式探索对级联决策阶段的端到端替换:在 next-token prediction(NTP)范式下,BARGE 通过引入上下文感知注意力、层级路径重排与正交双路解码,弥合了层级语义 ID 生成中的两个结构性缺口——多 token 物品展平后 item 边界丢失、早期前缀出错引发的语义漂移;在 next-slate prediction(NSP)范式下,HiGR 把推荐从逐 item 解码重构为整屏 slate 生成,协同设计了可控规划所需的前缀结构化语义 ID、把全局 slate 规划与局部 item 生成分离的粗到细解码器,以及兼顾列表顺序、真实兴趣与多样性的 ORPO 列表级偏好对齐。第三,TGR-Reason 方向以“隐式推理、在线注入”增强端到端生成:推理成本经隐空间多步监督在训练期摊销,Think 模型的推理结果离线物化为 reason tokens,再由 Direct Reasoning Injection 作为层级对齐的 prompt 条件化在线解码。

              腾讯 TGR 已在真实业务流量上规模化部署,覆盖新闻、视频、网络小说等业务的10多个场景,助力相关业务在观看时长、广告收入与新用户转化等核心指标取得显著提升,TGR 相关创新成果已在AAAI、ACL、CIKM等国际顶级会议发表多篇论文。

              一、传统推荐系统的结构性瓶颈

              如上图所示,业界大多数推荐系统采用多阶段级联架构,而且每一层的模型基本都是典型 DLRM 范式:底层针对sparse、dense和多域异构行为序列单独做特征抽取,中间层做特征交互网络(DeepFM、DCN、DIEN等),最后多任务输出层网络(MMoE、PLE等)。这套架构至今仍是业界主流范式,但有三个结构性瓶颈已经显现,限制了系统进一步提升的空间:1)DLRM 范式不具备 LLM 式的 scaling law——模型容量与算力增长之后,效果趋于饱和;2)级联架构的分阶段决策带来结构性错位;3)协同信号驱动的模型缺乏多模态语义理解、世界知识与推理能力,在冷启动、长尾与意图模糊场景上效果欠佳。

              如上图所示,基于 Transformer 的大语言模型在NLP、CV等领域取得了很大的成功:效果随算力、数据、参数量可预测地持续提升,并具备多模态理解与复杂推理能力。因此业界正积极探索"生成式范式":把推荐建模为序列生成,让召回、排序、重排都能享受 LLM 式的 scaling 与推理。但直接把 LLM 的建模方式照搬并不可行,主要面临如下三个结构性问题的挑战。

              1.1 排序模型的算力效率瓶颈:特征交叉与长序列建模

              如上图所示,生产环境中的排序模型面对的是异构、高基数、分布实时变化的特征空间:sparse 特征的基数可达百亿规模,dense 特征依赖人工设计的数值统计,用户行为序列来自多个业务域和场景,序列可达万级。这套架构的天花板在于它不具备 LLM 式的 scaling law:embedding 查表加人工设计的交叉结构受内存带宽限制,模型算力利用率低,增加参数和算力之后效果不再持续提升。Meta提出的 HSTU 是生成式范式的第一次可信突破——把特征与行为序列统一 token 化,由单个 Transformer 完成交叉,排序模型首次呈现出随参数量与序列长度可预测提升的 scaling 特性:HSTU 把序列转导模型扩展到万亿参数量级,线上 A/B 取得 +12.4%。

              但新的瓶颈随之出现:self-attention 的计算开销随序列长度平方增长,在数十到百毫秒的延迟预算下,长序列只能截断或预压缩,细粒度的跨域交互被牺牲掉,而这是 TGR-GenRank 方向要解决的问题出发点。

              1.2 级联架构的目标割裂:阶段代理目标与列表级目标的不一致

              如上图所示,级联架构下系统是逐 item 做决策的:召回、粗排、精排、重排每一级都用判别式打分和截断阈值做局部决策,候选从海量逐级截到千级、百级,最后拼成一屏。级联架构主要存在以下瓶颈:

              1)各级独立优化、独立截断,上游截掉的 item 下游看不到,信息逐级损失、样本偏差累积,算力也被切成碎片;

              2)各阶段目标彼此不一致,跨阶段的联合优化在级联结构下难以协同,各阶段效果提升的边际收益递减;

              3)用户体验到的是一屏有序的列表:列表质量取决于 item 之间的兼容性、多样性与位置效应,而各阶段判别式打分刻画不了这些关系,局部最优的拼接不等于全局最优。

              快手提出的 OneRec 是端到端生成范式的第一次工业化落地——把 item 编码为层级语义 ID,用单个 encoder-decoder 模型以 session 为单位直接生成推荐列表,并用基于奖励模型的迭代偏好对齐取代多阶段打分,在工业场景验证了用一个生成模型替换级联判别式阶段的可行性。

              但新的瓶颈随之出现:自回归解码整屏意味着 M 个 item × D 层 SID 共 M×D 个 token 的逐 token beam search,在实时约束下太慢;多 token 的 item 展平后 item 边界丢失,前缀一旦出错便引发语义漂移;逐 token 的生成目标也刻画不了列表层面的顺序与多样性,而这些正是 TGR-GenRec 方向要解决的问题出发点。

              1.3 协同信号的覆盖边界:冷启动、长尾与意图模糊

              如上图所示,协同信号驱动的推荐模型学到的是行为共现模式:看过 A 的人接着看了 B。这套机制在绝大多数请求上有效,却恰好在最需要推理的三类请求上失效:

              1)新用户,历史序列为空或极短,没有共现证据可供匹配;

              2)长尾 item,协同信号稀疏,交互集中在热门 item 上,长尾几乎没有交互边可学;

              3)意图模糊的请求,历史同时指向多个方向,用户下一步想做什么需要推断而不是匹配。

              这三类请求需要的是多模态语义理解、世界知识与意图推断,而基于协同信号的模型却缺乏这方面的能力——模式匹配不等于推理,这就是协同信号的覆盖边界。引入大模型先验是自然的解法,业界已有两条路径:显式推理(OneRec-Think/OneReason)让模型在生成推荐前先显式输出思维链,隐式推理(ReaRec / STREAM-Rec)在隐空间多走几步 rollout 再生成。

              但两者都把推理放在了请求路径上:显式推理每个请求多出数百个 CoT token,隐式推理每个请求多出 K 步前向,在数十~百毫秒的延迟预算下放不进去;推理容量与每请求计算绑定,想多推理一步就要为每个请求多付一步延迟,把推理搬到离线也只是转移成本——推理结果随请求产出,每次曝光仍要算一次,而这些正是 TGR-Reason 方向要解决的问题出发点。

              1.4 TGR 演进路线与技术栈全景

              如上图所示,生成式范式改造推荐系统主要有两条路径。一条是重塑级联架构:基本还保留级联架构,借鉴生成式范式的建模技术来重塑各层的模型,包括生成式范式下的重排、精排、召回模型等。另一条是替换级联架构:探索用单一生成模型替换召回、排序、重排等学习型决策阶段,直接输出 item 或整屏 slate。

              我们认为这两条路径并不互斥,短期内两者都会同时存在并继续演进,根据实际场景的数据规模、成本等因素来做路线选择,所以TGR-GenRank 走重塑路线,TGR-GenRec 与 TGR-Reason 探索替换路线。因此,TGR 技术栈由排序层(TGR-GenRank)、生成与推理层(TGR-GenRec、TGR-Reason、TGR-Memory)和基础层(Numerous-Torch、用户建模、多模态理解、SID 模型)组成,如下图所示。

              如下图所示,TGR 沿"统一语义表示的基础设施 → 重塑 / 替换级联的生产模型 → 推理增强与 Agentic 自进化的前瞻探索"三个层次,把推荐系统逐环节升级或替换,形成五个方向:

              1)TGR-SID:全场景统一的语义 SID,既是推荐内容理解与统一语义表示的基础设施,也是各方向共享的解码空间,目前已接入多个业务。

              2)TGR-GenRank 以生成式范式"重塑"排序,我们提出 CCFormer 作为排序模型 backbone,用特征域分离交叉注意力、子空间相对时空编码与层级序列压缩降低序列建模复杂度,已在多个业务场景全量上线;

              3)TGR-GenRec 以端到端生成"替换"级联中的判别式决策阶段,NTP 路线的 BARGE 修复层级语义 ID 生成的结构性缺口,NSP 路线的 HiGR 把“编码 → 规划 → 生成 → 对齐”做成一体化的列表级生成框架,同样已在多个业务场景全量上线。

              4)TGR-Reason 以大模型推理“增强”端到端生成:我们提出 LatentRec,用连续隐向量替代文本 CoT,在隐空间把“思考”与“生成”合为一体,推理成本在训练期摊销;推理结果通过离线 / 近线机制物化为 reason tokens,经 DRI 注入在线生成器,实现服务时零推理 rollout,线上 A/B 在新用户指标上显著提升;

              5)TGR-Loop 把演进本身交给多智能体,让 LLM 智能体自主提出、验证并迭代推荐模型,目前处于研究探索阶段。

              接下来,我们分别重点介绍 TGR-GenRank、TGR-GenRec 与 TGR-Reason三个方向,TGR-Loop 在最后的展望中介绍。

              二、TGR-GenRank:排序模型的范式迁移

              TGR-GenRank 方向的目标是在级联结构下替换排序 backbone——用生成式范式"重塑"排序,让排序模型既能随参数量与序列长度可预测地提升效果,又能把算力开销控制在预期范围内。

              2.1 传统排序模型的局限性与排序范式的业界演进

              如上图所示,推荐排序模型面对的输入是异构、高基数、分布实时变化的特征空间——sparse 特征基数接近百亿,多域行为序列的类型、时间尺度与长度差异很大、可达万级——训练上还要求在超大规模数据上实时更新。

              DLRM范式的排序模型是典型的三层架构:

              1)底层是特征抽取层:用户行为序列与候选 item 经 target-aware 的 pairwise attention 得到序列表示,ID 类 sparse 特征经 embedding 查表与池化得到 pooled embeddings,外部 embedding 特征与人工设计的 float 统计特征各走一条支路;

              2)中间是特征交互层,由 DCN 一类的显式交叉结构把各支路表示组合起来;

              3)顶层是任务转换层,以 MoE 形式输出多个任务的预估分数。

              DLRM范式的根本局限在于扩展性:随着训练数据量、模型规模或计算量的提升,效果未能持续提升,排序模型缺少可预测的 scaling 路径。

              如上图所示,业界近两年的排序模型演进可归为两条路线(范式 A 与范式 B):

              1)特征交互型模型(Wukong、RankMixer 等)延续 DLRM 的分层思路:序列先由前置模块压缩成少量表示,再与非序列特征一起送入可堆叠、可 scaling 的交互骨干。Wukong 用堆叠的 FM block 做高阶点积交互并配合线性压缩,在排序模型上报告了跨两个数量级算力的 scaling law;RankMixer 用无参数化的 token mixing 替代 self-attention,主要计算落在 per-token FFN 上,算力利用率高。这条路线的共同短板是序列信息在压缩时有损,跨域交叉发生在压缩之后、位置滞后;

              2)统一 token 化 + 注意力交互的模型(HSTU、ULTRA-HSTU、OneTrans 等)把用户画像、行为序列与候选物品统一编码成一条 token 序列,用 attention 一次完成序列内与跨域交叉,效果随参数量与序列长度可预测提升。代价是原生 self-attention 对序列长度是 O(L²),万级长序列在工业延迟预算下计算量与显存开销巨大,后续工作都在注意力本身上做减法:ULTRA-HSTU 引入半局部稀疏注意力与注意力截断,OneTrans 用金字塔式缩减 query 数并跨请求缓存 KV——它们以限制注意力范围或减少参与交互的 token 数为代价换取次二次开销。

              总结一下,范式 A 的优势是算力利用率高——交互骨干只处理少量压缩后的表示;但不足是序列先压缩、后交叉,细粒度的序列信息和候选与历史行为之间的精细匹配在进入骨干之前就已丢失。范式 B 的优势是交互充分——用户画像、行为序列与候选统一在一条 token 序列里,self-attention 一次完成序列内与跨域的全部交互,效果随参数量与序列长度可预测提升;但不足是 self-attention 对万级长序列在工业延迟预算下计算量与显存开销巨大,后续的稀疏化、截断、金字塔堆叠都是在为这一个算子减负。

              如何既保留范式 B 在完整序列上做充分交互的效果,又获得范式 A 的算力效率,这正是 CCFormer 的设计出发点:把跨域交叉与序列内交互解耦,各用最合适的算子(如上图中的范式 C)——跨域交叉用特征域分离的 cross attention,让非序列特征直接查询完整序列,复杂度随序列长度线性;序列内交互在子空间内用 token mixing 与 per-token FFN 完成,避开二次开销;序列压缩不再前置于交互,而是在骨干内部逐层、层级化地进行,让细粒度信息先参与交叉再被压缩。

              2.2 CCFormer:跨域交叉注意力、子空间序列交互与层级序列压缩

              如上图所示,CCFormer 把输入特征划分为用户侧(user tokens)、用户历史行为序列(sequence tokens)、候选目标物品(target item tokens)三个异构特征域,并把排序模型的特征提取环节解耦为四个模块:

              1)特征域分离的 Cross Attention。如下图所示,特征域分离的 Cross Attention 把排序任务拆成三个域之间的关系——用户与历史序列之间的偏好性检索、目标物品与历史序列之间的相关性匹配、目标物品与用户之间的兼容性建模——Cross Attention 适合做异构域之间的相关性建模,且复杂度为 O(L)。

              2)子空间相对时空位置编码(Subspace Relative Time and Position Encoding)。如下图所示,长序列子序列的相对时空位置编码把长序列划分成多个相邻 m 个 token 的子序列,在子序列上分别计算相对时间与相对位置的参数矩阵并注入序列 token,复杂度从全局的 O(L²) 降为 O(Lm)。

              3)子空间 Token Mixing(Subspace Interaction)。如下图所示,长序列子空间 Token Mixing 把序列 token 划分成 m×n 维度的子空间,每个子空间的 embedding 展开后经过参数独立的 PFFN 再做维度 revert,完成子空间内的特征交叉。

              4)层级卷积压缩(Convolutional Compression)。如下图所示,分层长序列 Token 卷积压缩用逐层有重叠的一维卷积聚合相邻行为 token,卷积核自适应地学到聚合模式,逐层压缩使每一层序列 token 的感受野逐层变大,模型获得多序列尺度的特征建模能力,层级堆叠下的计算量大幅降低。

              2.3 实验效果

              2.3.1 对比实验分析

              公开数据集上,CCFormer 在 Taobao 与 KuaiRec 上均优于 DIN、DeepFM、SASRec、MIMN、HSTU、OneTrans、STCA;

              在 40 亿样本的真实业务数据集上,AUC 77.94%、GAUC 71.36%,相对 HSTU(77.66% / 70.86%)分别提升 0.28 和 0.50 个百分点,相对提升 1.01% 与 2.40%(表 1)。Scaling 实验表明 CCFormer 沿特征维度(128 → 512)和序列长度(0.5K → 2K)都持续提升且始终优于 HSTU;CCFormer 仅用 0.5K 序列就达到了 HSTU 用 2K 序列的 AUC,并超过其 GAUC(见 2.3.3)。

              表 1 | CCFormer 在两个公开数据集与真实业务数据集上的效果对比

              2.3.2 消融实验分析

              消融实验给出了各模块的贡献(表 2):完整 CCFormer 在真实业务数据集上 AUC / GAUC 为 77.94 / 71.36,训练加速 2.21×;移除相对时空位置编码后 GAUC 降至 71.13;长序列 token mixing 换成 self-attention 后 GAUC 降至 71.21,训练加速降为 1.41×;移除 token mixing 降至 71.02;移除序列压缩后训练加速降为 1.29×。

              表 2 | CCFormer 消融实验:各模块对 AUC / GAUC 与训练加速比的贡献(对比 HSTU)

              2.3.3 模型scaling效果分析

              如上图所示,CCFormer 在模型规模和序列长度两个维度上都表现出可预测的 scaling 特性,并且在每个规模点上都以更低的算力取得更好的效果。

              先看模型规模:特征维度从 128 增加到 256、512,HSTU 与 CCFormer 的 AUC、GAUC 都单调上升,但 CCFormer 的领先幅度随规模扩大而拉大(ΔAUC 从 0.84% 升到 1.22%,ΔGAUC 从 1.02% 扩大到 2.4% 左右),同时每个维度下的 GFLOPs 仅为 HSTU 的三至六成——256 维的 CCFormer(18.28 GFLOPs,AUC 77.94%)已经超过 512 维的 HSTU(63.47 GFLOPs,AUC 77.79%),算力不到后者的三分之一。

              再看序列长度:在真实业务数据集上把用户序列从 0.5k 拉长到 2k,两者的 AUC、GAUC 都随长度近似线性提升,但 CCFormer 的拟合斜率明显更陡,序列每翻倍一次获得的增益更大,0.5k 长度下的效果已与 HSTU 在 2k 长度下大致相当。公开数据集 KuaiRec 上的结论一致:序列长度从 200 增至 1000,CCFormer 在每个长度上都领先 HSTU、STCA 与 OneTrans,200 长度下的 AUC 已接近或超过其他方法在 1000 长度下的水平。这两组结果说明,CCFormer 不只是在固定预算下更优,把算力投入换成效果的效率也更高。

              2.4 业务应用效果

              CCFormer 模型已在 5 个真实业务场景上取得显著的效果收益,具体数据如表 3 所示。

              表 3 | CCFormer 五个业务场景的离线效果与在线 A/B 实验效果

              2.5 小结与展望

              TGR-GenRank 方向把传统 DLRM 范式的排序模型迁移到统一 token 化加 Transformer 骨干的生成式范式。CCFormer 把跨域交叉与序列内交互解耦,以特征域分离的 cross attention、子空间序列交互和层级卷积压缩替换了 DLRM 的特征抽取层与特征交互层。在模型效率上,相比 HSTU 等业界方案,CCFormer 以约一半的算力取得更优的离线效果,训练提速 2.21×,并在模型规模与序列长度两个维度上表现出更陡的 scaling 曲线;在模型效果上,CCFormer在5个业务场景的 A/B 实验取得统计显著的效果收益,并已在多个场景推全上线。此外,CCFormer论文《CCFormer: Efficient Cross-Field Interaction and Hierarchical Sequence Compression for Industrial Recommendation at Tencent》已投稿至顶会。

              展望未来,TGR-GenRank 方向将沿三条线继续推进:一是跨场景的 backbone 模型基座,让同一个排序骨干服务多个业务场景;二是终身序列建模,覆盖更长时间跨度的用户行为,并探索更贴合推荐任务的特征交叉结构;三是持续优化模型 scaling 的斜率,通过稀疏注意力、输入序列与模型拓扑等模型—系统协同设计,在固定的延迟与 GPU 预算内换取更多效果。

              三、TGR-GenRec:从 next-item 到 next-slate 端到端生成

              TGR-GenRec 方向的目标是用端到端生成模型“部分替换”或“完全替换”级联中的判别式决策阶段,由一个生成模型直接产出用户要看的 item 乃至整屏列表。本章按两种生成范式展开:NTP(next-token prediction)范式的 BARGE 模型,NSP(next-slate prediction)范式的 HiGR 模型。

              3.1 从 Next-Token 到 Next-Slate:推荐自回归的结构差异与业界演进

              3.1.1 语义 ID 与推荐自回归:与语言自回归的结构差异

              如上图所示,端到端生成式推荐的一般流程是:item 的内容(文本 / 图像 / 视频)先编码为语义向量,再经 RQ-VAE 残差量化为 D 层 coarse-to-fine 的层级语义 ID(SID),语义相近的 item 共享高层前缀、叶子层区分个体;用户历史展平为 SID 序列输入 encoder–decoder Transformer,由 beam search 逐 token 生成目标 item 的 SID,只在码本树上存在的路径中搜索,生成的 SID 再映射回 item 或作为检索 query。

              这条路与 LLM 同构:不再对全库逐一打分,可以复用 Transformer 骨干、scaling 规律与训练 / 推理基建。但语言自回归不等于推荐自回归,上图下方的对照表列出了七个维度的差异,这七个差异决定了 LLM 的自回归不能原样搬到推荐上,也引出了 TGR-GenRec 的设计出发点:BARGE 在 NTP 范式下修复 token 语义与序列结构带来的缺口,HiGR 在 NSP 范式下把生成单元升级为整屏 slate,并在训练目标与解码上做列表级的协同设计。

              3.2 BARGE:面向推荐的自回归生成适配(NTP 范式)

              3.2.1 两个结构性缺口:Item Boundary Gap 与 Semantic Drift

              如上图所示,端到端生成式模型的标准链路是 item → SID → 自回归解码,这个链路中存在两个结构性缺口:

              1)编码端丢失 item结构化信息(Item Boundary Gap):Item 的 SID 层级码字展平之后,同一 item 的 SID 缺少显式分组,Encoder 输入端丢失了 item 结构信息。模型看见的是 token,却没有物品归属信息;同一个 code index 在不同前缀路径下语义不同——如下图所示,第二层的码字 3 在 ⟨1,3⟩ 与 ⟨7,3⟩ 下原始 lookup embedding 相同,对应的却是不同的路径语义。这导致模型要同时承担三重编码负担:恢复边界(哪些 token 属于同一 item)、消歧语义(同一码字在不同前缀下如何解释)、建模偏好(用户行为最终仍以 item 为单位)。

              2)解码端的语义漂移(Semantic Drift):如下图所示,层级解码一旦在某一层走岔,之后每一层都只能在错误子树里继续搜索,目标 item 被永久排除。对第三层目标预测质量的量化显示,teacher forcing 下目标概率 0.787、排名 7.4、准确率 80.5%;自回归整体只有 0.015、119.5、1.6%,概率掉到约 1/52。按前缀是否正确拆开看,前缀正确时准确率为 77.0%,前缀一旦出错只剩 0.6%,相差 128 倍。

              通过扩大 beam 来解决显然不大可行:更宽的 beam 只能留下更多路径,不能显式判断整条路径的语义是否仍与用户一致;推理时延近似随 beam 宽度线性增长,显存随 B×L 增长;工业场景候选库更大、分布更长尾,局部 token 概率更容易受稀疏反馈影响。

              3.2.2 方法设计:OSQ-VAE、ICA、HPR 与 DPD

              如下图所示,BARGE 在既有 NTP 范式上做结构性适配,分别在 SID 建模(OSQ-VAE)、编码器网络结构(ICA Block)、解码器网络结构(HPR Block)、解码策略(DPD)4 个方面提出了改进方案。

              1)OSQ-VAE:正交旋转后一分为二,为每个 item 产出互补的两套 SID。同时,编码器输入两套 SID,两个解码器并行解码两套 SID。

              2)ICA Block(Item Context-Aware Attention):如下图所示,在进入 encoder 前,用可学习的 query 对同一 item 的 L 个 SID token 做 cross-attention pooling 得到聚合表示,经 MLP 投影得到 item context,再以门控残差注回每个 token;实测门控强度处于中等区间,模型选择的是”补充”而非覆盖 SID 信息。

              3)HPR Block(Hierarchical Path Reranking):用全局路径一致性重排局部 token 概率。如下图所示,在解码器内用累计路径与 decoder 初始隐状态 h₀ 打分,逐层重排 beam;训练用 InfoNCE:正样本是 h₀ 与真值 item 的累计前缀路径,负样本包括同批次内的其他路径、NTP 高概率错误前缀,以及已曝光未点击等业务负样本——针对的正是 PROMISE 负样本太”容易”的问题;推理时的分数是生成分数加 λ 倍的路径匹配分数;每层用 Top-N 扩展评分池,下一层仍只保留 Top-B,beam 宽度不变;h₀ 每层只算一次,候选共享同一个上下文塔。

              4)DPD(Dual-Path Decoding):两条通路并行,共享 encoder,decoder 与 HPR 私有,在 item 空间做 soft-OR 融合,任一通路高分即可恢复;两条通路在经验上互补:双通路 Top-10 候选的 Jaccard 仅 0.172–0.183,前 10 名只有约 3 个重合;OR 命中中 15.6%–24.3% 仅由单一通路贡献。

              如上图所示,对 HPR 的进一步探索给出了一个更一般的结论:仅增加判别式结构容易与 decoder 概率同质化,有效收益来自额外监督(曝光未点击、NTP 高概率错误前缀)与多目标信号;要把 target 侧特征引进来,需要另一条结构——User–Item 双塔在训练时用对比损失把 target 侧特征带进用户向量,推理时只需要用户向量以 soft prompt 注入 decoder 的起始位置,这个改进点在真实业务数据集上把 Hit@1 从 0.3749 提升到 0.4088(+9.0%)。

              3.2.3 实验与部署
              3.2.3.1 对比实验

              如下图所示,在 Amazon Beauty 与 Sports 两个公开数据集上做全库评估,对比 TIGER、HSTU、COBRA、ActionPiece、APAO-pointwise 五个基线,BARGE 在全部报告指标上最佳:Beauty R@10 0.0927、N@10 0.0547,Sports R@10 0.0544、N@10 0.0308。Beauty R@10 相对最强列内基线提升 16.6%,相对 TIGER 提升 43.1%;Sports R@10 相对最强基线提升 8.8%,N@10 提升 16.7%。

              表中的 BARGE-base 是一个对照变体:保留 ICA、HPR、DPD 三个结构模块,但把 BARGE 的 4 层学习码本换成与基线相同的 TIGER 3 层码本(外加一个随机的消碰撞 ID),用来把结构模块的收益与码本设计的收益分开。BARGE-base 在与基线同一套 tokenizer 下已经超过全部生成式基线(Beauty R@10 0.0896,Sports 0.0513),说明三个结构模块的收益不依赖特定数据集、可以跨数据集复现;从 BARGE-base 到 BARGE 的进一步提升(Beauty R@10 0.0896 → 0.0927,Sports 0.0513 → 0.0544)则来自码本设计。

              如上图所示,在2个真实业务场景上的离线评估效果:场景 1 有数十万 item,线上召回模型为 GraphSAGE 与 NANN;场景 2 有数千万 item、百亿级交互,线上召回模型为 GraphSAGE 与 BERT-based;OneRec 为内部复现,作为生成式基线。

              两个场景的 Hit@5 / @10 / @20 / @50 四项指标上 BARGE 全部最优:场景 1 的 Hit@5 从 OneRec 的 0.5459 提升到 0.6015(+10.2%),场景 2 从 0.0835 提升到 0.0976(+16.9%),而生成式的两条线整体都明显高于线上在用的召回模型。

              值得注意的是:1)领先幅度在 Hit@5 上最大、随 K 增大逐渐收窄,说明结构修复主要把目标 item 推到了列表头部,这与 HPR 逐层重排的作用方式一致;2)候选库更大、分布更长尾的场景 2 增益反而更高,印证了 3.2.1 的判断——工业场景下局部 token 概率更容易受稀疏反馈影响,语义漂移更严重,路径级纠偏的价值也更大。

              3.2.3.2 服务部署

              如上图所示,线上 TGR-GenRec 服务支持两种 SID 到 item 的模式:同一个生成模型经 beam search 输出 50 组 SID 路径,方式 A 直接映射(一条 SID 路径 → 一个 itemID),适合少量精准候选,直接生成 50 个 item 作为一路召回,或直接送精排、替换”召回 + 粗排”链路;方式 B 走 ANN 检索(码本 embedding 求和后做 ANN),适合大 quota 的召回系统——quota=500 时直接 beam=500 性能不可承受,改为生成 50 个 SID 种子、每个种子做 ANN 扩展,去重后约 480、重复率约 4%。按链路 quota 选择:小 quota 用方式 A 精准直出,大 quota 用方式 B 种子扩展进入现有下游级联。

              3.2.3.3 业务应用效果

              BARGE 的线上 A/B 在小说推荐场景进行,为期两周、6% 线上流量,对照组是现网的多阶段召回系统:CTR +0.60%,点击 UV +1.34%,总阅读时长 +1.70%,三项提升均统计显著。此外,BARGE 模型全量上线后保留的长期反转组进一步显示,CTR 与总阅读时长的提升幅度比两周实验更大、效果更稳定。

              如上图所示,把 BARGE 作为一路召回单独下钻,看两个指标:曝光采纳率衡量该通路召回的候选能否通过下游的粗排、精排与混排最终获得曝光;曝光后 CTR 衡量这些候选曝光后能否被用户点击。

              对比线上3条代表性通路,BARGE 的曝光采纳率为 1.02%,与图召回的 1.03% 同处第一梯队;曝光后 CTR 为 9.93%,4条通路中最高。这说明 BARGE 带来了现有通路没有覆盖的增量,也正是前面 A/B 实验中 CTR、点击 UV 与总阅读时长同时提升的来源。

              3.2.4 小结

              BARGE 在 NTP 范式下对基于Transformer的生成式推荐模型做了四处结构性适配:OSQ-VAE 经正交旋转一分为二,为每个 item 产出互补的两套 SID;ICA 在进入 encoder 前聚合 item 级上下文,再以门控残差注回每个 SID token,修复展平后丢失的 item 边界;HPR 在解码器内用累计路径与 h₀ 逐层重排 beam,以 InfoNCE 加上 NTP 高概率错误前缀、曝光未点击等难负样本训练,修复沿前缀级联的语义漂移;DPD 以结构互补的第二条解码通路和 item 空间的 soft-OR 融合,找回单通路不可达的 item。

              离线效果上,公开基准 Beauty 与 Sports 的全部指标最佳,Beauty R@10 相对最强基线 +16.6%;两个工业场景的 Hit@5 相对 OneRec 分别 +10.2% 与 +16.9%;在线效果上,线上 A/B 中 CTR +0.60%、点击 UV +1.34%、总阅读时长 +1.70%,作为单路召回的曝光采纳率 1.02% 处于第一梯队、曝光后 CTR 9.93% 为各通路最高,BARGE 目前已在小说推荐场景全量上线。此外,BARGE 的论文《Bridging the Structural Gap: Adapting Autoregressive Generation for Recommendation》已投稿至顶会。

              3.3 HiGR:基于分层规划的列表级生成式推荐框架(NSP 范式)

              3.3.1 从 item 级生成到 slate 级优化的三个断层

              BARGE 解决了”如何生成一个 item”,尚未解决”如何生成一张好列表”。让模型直接生成推荐列表的挑战更大,推荐列表质量不只取决于每个 item 的相关性,还取决于列表级的排序位置,列表内关系与多样性。如下图所示,把 NTP 范式的 item 级 SID 生成直接扩展到工业级 slate 优化,存在三个断层:

              1)纠缠的 SID 空间。标准残差量化得到的 SID 前缀既不反映 item 语义也不反映协同关系,前缀相同不一定代表类别相同,前缀不同的物品却可能相似;前缀不一致,就很难在 slate 内控制 item 的相关性与多样性。

              2)低效的细粒度解码。M 个 item × D 层 SID 需要解码 M×D 个 token,全序列 beam search 在实时约束下推理耗时高,难以满足实时推荐要求;而且把 item 内的语义组合与 item 间的转移纠缠在一起,掩盖了全局 slate 结构。

              3)目标错位。token 级似然并不优化用户感知的 slate 质量,即排序顺序、真实兴趣、列表内多样性等多个列表级目标。

              HiGR的设计思路是通过tokenizer、解码器与训练目标协同设计,分别对应以上三个断层:PCRQ-VAE 给出结构化的前缀对齐 SID 空间,HSD 分离 slate 规划与 item 解码,ORPO listwise 对齐面向列表偏好。

              3.3.2 方法设计:PCRQ-VAE、HSD 与 ORPO listwise 对齐

              如上图所示,HiGR 的总体框架是”编码 → 规划 → 生成 → 对齐”:(a) PCRQ-VAE tokenizer 产出前缀对比的语义 ID;(b) 层次化 slate 解码器由粗粒度规划器和细粒度 item 生成器组成;(c) ORPO 做 listwise 多目标对齐。

              3.3.2.1 PCRQ-VAE tokenizer 语义编码

              在生成式推荐中,物品SID化(tokenization)的作用对模型效果影响很大,SID 质量在很大程度上决定了生成式模型的效果上限。传统的RQ-VAE模型虽然能降低词表大小,但在工业落地中暴露出了“前缀语义纠缠”与“残差坍塌”的两大核心问题,导致生成模型难以精准把控推荐意图,在列表级生成式推荐任务中这个问题尤为突出。

              1)ID纠缠。在标准RQ-VAE中,量化仅由重构误差来驱动。这导致生成的Codebook缺乏语义拓扑结构——前缀相同不一定代表类别相同,而前缀不同的物品却可能非常相似。对于分层规划器来说,如果ID不具有明确的语义聚类特性,它就无法准确地规划出高层的“意图”。

              2)残差坍塌。随着量化层数迭代,后续层级的残差向量往往趋近于零,导致深层码本实际上不承载信息,退化为噪声,浪费了编码容量。

              如上图所示,我们引入对比学习对前缀做约束、引入全局量化抵抗残差消失现象,让语义ID的前缀成为可靠的语义锚点。

              1)前缀对比约束

              我们在量化器中的前D-1层引入InfoNCE loss,选择语义相似的item或共现率高的item作为正样本,选择批次内其他随机样本作为负样本。让前缀ID负责“聚类”,将相似物品拉到同一个ID前缀下;让最后一层ID负责“区分”,保持对具体物品的细粒度辨识能力。完美契合我们的“先规划,后生成”的分层策略。

              2)全局量化损失

              不同于传统逐层累计的量化损失,我们针对量化器前后的编码向量和量化重构向量构造全局损失,有效抵抗了残差消失现象,迫使深层码本必须承载有效信息,显著提升了ID的表达一致性。

              3.3.2.2 层次化 slate 解码器 HSD

              如上图所示,HSD 把 slate 的生成拆成"规划"和"生成"两层:

              1)下层是粗粒度的 slate 规划器:一个 L_slate 层的 Transformer 以 BOS 和上下文 embedding 起步,在紧凑的偏好 embedding 空间里逐位置自回归——先输出第 1 位的偏好 î₁,把该位置生成的 item i₁ 回填为输入再输出 î₂,依此类推,每个 slate 位置对应一个 embedding,先把整屏的意图定下来。

              2)上层是细粒度的 item 生成器:经过共享的 Projector 后,一个 L_item 层、所有位置共享参数的生成器把每个偏好 î_m 落成一条 D 个 token 的短 SID 序列(s¹_m, s²_m, s³_m),再映射回 item;因为参数在位置间共享,模型大小不随 slate 长度增长。

              相比于标准的Transformer结构,HSD 不再像 NTP 平铺那样纠缠在一条 M×D 的长序列上,item 内的语义组合(D 步)和 item 间的转移(M 步)被分到两个模块里。

              推理时规划器贪心解码,beam search 只在每个 item 的短 SID 序列内进行,搜索空间大幅缩小:解码复杂度从 O(B·M³·D³·l_slate·d) 降为 O(M³·l_slate·d + B·M·D³·l_item·d),beam 宽度 B 只作用在短的 item 级序列上,相比 NTP 平铺式解码再拼成列表,推理可提速数倍。

              同时,多样性在规划阶段就可以控制:对规划器输出的各位置 embedding 施加多样性损失 L_ILD = −1/(M(M−1)) Σ_m Σ_{n≠m}(1 − cos(î_m, î_n)),最小化它等于拉大不同位置偏好之间的余弦距离,让整屏的意图在解码出具体 item 之前就彼此错开,而不是事后靠打散规则补救。

              深度分配上,在固定总深度的条件下规划器 14 层加生成器 2 层是最佳生产配置,相比 12:4 的分配延迟降低 26%,NDCG@5 仅相对下降 0.6%——说明算力应主要投在规划整屏意图上,item 级解码用很浅的网络即可。

              3.3.2.3 ORPO listwise 对齐:列表级的多目标偏好对齐

              如上图所示,在生成式推荐的工业级落地中,直接照搬 LLM 领域的对齐算法面临显著的效率收益瓶颈:

              1)DPO(Direct Preference Optimization)

              1.1)机制痛点:DPO的损失包含一项参考模型的预测结果。这意味着训练过程中,必须始终加载冻结参数的参考模型进行同步推理。

              1.2)工业阻碍:推荐模型的参数量虽然不如LLM巨大,但是数据量极大。参考模型的存在导致显存占用翻倍,训练吞吐量减半。在小时级更新的推荐业务中,这种训练延时是不可接受的。

              2)GRPO(Group Relative Policy Optimization)

              2.1)机制痛点:DeepSeek 提出的强化学习方法 GRPO,通过对同一prompt采样G组输出,计算组内相对优势,从而省去了critic model。其核心假设是环境能对每一次采样给予即时、准确的反馈。

              2.2)工业阻碍:GRPO在数据、代码任务中有效,是因为有明确的答案检查器。但在推荐场景中,离线训练无法实时把生成的G个推荐列表推给用户,在没有高保真用户模拟器的情况下,GRPO很难直接应用于离线推理策略学习。此外,列表序列推理是token-by-token生成的,生成G组完整列表极其耗时,会导致训练时长爆炸。

              ORPO(Odds Ratio Preference Optimization)无需参考模型,把偏好优化折叠进监督学习——监督项保精度、对比项拒绝差的 slate。

              因此,HiGR 选择 ORPO :L_ORPO = L_SFT + λ·L_Odds,其中 L_SFT 是正样本列表的 token 级负对数似然,L_Odds 把正、负列表在每个位置上的生成赔率 π_θ/(1−π_θ) 取对数后沿序列累加、作差,再经 sigmoid 取负对数。 直观上,SFT 项负责让模型学会生成高质量列表,Odds Ratio 项让优势列表的生成赔率显著高于劣质列表;工程上它无需参考模型、无需在线采样,单模型、单向传播,一次前向同时完成监督与偏好对齐,训练速度与普通 SFT 几乎持平,显存占用大幅降低。

              偏好对的构造采用"三元目标"策略,正样本三目标共用:用户真实观看且高停留时长的序列,按反馈强度重排;负样本按准、好、多样三个目标分别构造:

              1)排序保真(Ranking Fidelity):把重排后的正样本随机打乱顺序,让模型学会"把好东西率先推出来";

              2)真实兴趣(Genuine Interest):把正样本中的物品替换为用户曝光未点击或负反馈的物品,让模型学会剔除"标题党"和无效曝光;

              3)列表多样性(Slate Diversity):以正样本的第一个物品为锚点、后续全部填充与锚点相似的 top-k 物品,让模型学会惩罚"信息茧房"、主动追求多样性。三类样本对全部从隐式反馈中挖掘,无需人工标注。

              3.3.3 推理加速

              为进一步降低训练和推理成本,我们还从多个角度对HiGR进行了系统性的工程优化,包括采用大语言模型中常用的加速手段,如Flash Attention,KV Cache等。此外,我们在实际落地中发现Beam Search仍是耗时最多的几个环节之一,因此我们也优化了Beam Search的整个流程,以及优化了整体的代码实现,减少不必要的重复计算和优化耗时操作,综合所有的优化手段,将推理速度提高了5倍以上。

              加速方法

              训练加速

              推理加速

              加速效果

              Flash Attention

              ✅

              ✅

              强,2-3倍提速

              KV Cache

              ❌

              ✅

              较弱

              Memory Beam

              ❌

              ✅

              强,2-3倍提速

              其他工程优化

              ✅

              ✅

              较强,1倍提速

              1)Flash Attention:LLM中常见的加速手段:通过分块计算,极大减少了 GPU 显存(HBM)与片上高速缓存(SRAM)之间的数据读写次数(IO),从而突破显存带宽瓶颈,显著提升长序列推理的计算速度,在HiGR落地中加速效果明显。

              2)KV Cache:通过缓存历史 Token 的 Key 和 Value 状态,使模型在自回归生成新 Token 时无需重复计算前文所有 Token 的 Key / Value,避免了冗余计算,降低解码阶段的延迟。但由于推荐场景中的序列长度远不及LLM中的序列长度,推理加速效果不如flash attention明显。

              3)Memory Beam:利用GPU的GEMM并行计算能力,优化beam search的实现流程,避免了当beam width很大时,需要将序列复制beam width份输入到模型中带来的额外巨大计算量,在HiGR落地中加速效果明显。

              4)其他工程优化:优化具体代码实现中的不合理实现,避免重复计算,优化耗时操作。

              3.3.4 实验效果
              3.3.4.1 对比实验分析

              如上图所示,在真实业务数据集与开源数据集 KuaiRec 上,HiGR 与 ListCVAE、BERT4Rec、SASRec、TIGER、HSTU、OneRec-25M 对比:同为 25M 参数,HiGR 在工业数据集的 5 个指标上全部超过最强基线 OneRec-25M,Impressions Hit@5 +15.9%、Effective Views Hit@5 +21.3%、NDCG@5 +21.2%;KuaiRec 上 NDCG@5 +5.2%、有效观看 Recall@5 +16.4%。HiGR-25M-w/o RL 已超过 OneRec-25M,ORPO 之后进一步提升;100M 模型的 NDCG@5 达到 0.0831,较 OneRec-25M +41.1%,收益随模型容量继续增长。

              3.3.4.2 消融实验分析

              接下来,我们介绍下tokenizer、解码器与对齐三个模块的消融实验分析。

              如上图所示,SID 质量用三个指标衡量:

              1)碰撞率(Collision):是不同 item 被映射到同一 SID 的比例,越低越好;

              2)集中度(Concentration):是共享同一前缀的 item 的类目纯度;

              3)一致性(Consistency):是每个前缀组内 item 两两类目一致的比例,越高越好。

              只对前 D−1 层施加对比约束的 prefix2 是最优配置:碰撞率降到 2.37%,集中度 93%,一致性 66.47%,较 RQ-VAE 提升约 10.7 个百分点——对比学习改善了码本空间的分布,而 D−1 的约束范围既保留了高层的语义层级,又把最后一层留给 item 的唯一身份。把约束延伸到叶子层(prefix3)则有"身份坍缩"的风险:一致性只有边际提升,碰撞率却升高近 4 倍(0.0237 → 0.0873)。因此,前缀级约束是在不损失细粒度 item 区分度的前提下获得语义一致性的关键。

              如上图所示,HSD 的消融针对三个设计:多样性正则 L_ILD、上下文嵌入(CE)与 item 生成器的参数共享。

              1)去掉 L_ILD 后,各项准确性指标几乎不变(NDCG@5 0.0753 → 0.0755),但列表内多样性 ILD 从 0.62 降到 0.59,说明这一项正则(最小化规划阶段偏好嵌入两两之间的相似度)确实在不牺牲准确性的前提下提升了列表内多样性;

              2)去掉上下文嵌入后效果明显下滑,曝光 hit@5 从 0.2994 降到 0.2785,有效观看 hit@5 从 0.2012 降到 0.1837,NDCG@5 从 0.0753 降到 0.0664——上下文编码器产出的表示在规划与生成两个阶段都作为 cross-attention 的 key / value,是 SID 条件解码的依据,拿掉之后生成器失去了条件信息;

              3)为每个 slate 位置单独配一个 item 生成器(Non-shared)并没有带来明确收益,各项指标与共享版本互有高低(NDCG@5 0.0748 vs 0.0753),因此 HiGR 采用跨位置共享的单个 item 生成器,既节省参数,也天然支持变长 slate 的生成。

              如上图所示,偏好对齐的消融以列表内多样性 ILD 为指标,在工业数据集与 KuaiRec 上对比各模型:

              1)即使不做偏好对齐,HiGR w/o RL 的 ILD 已经高于 TIGER、HSTU 与 OneRec(工业数据集 0.52 vs 0.38 / 0.42 / 0.48,KuaiRec 0.55 vs 0.40 / 0.43 / 0.50),说明在 slate 层面做层次化解码并施加多样性正则,结构本身就带来了多样性收益;

              2)在此基础上做偏好对齐能进一步提升多样性,DPO 把 ILD 提高到 0.57 / 0.60,ORPO 则达到两个数据集上的最高值 0.62 / 0.63,优于 DPO——列表级多目标 ORPO 把"多样"作为显式的对齐目标,其效果在这里得到了直接验证。

              如上图所示,在总层数固定的前提下比较 slate 规划器与 item 生成器的层数分配:

              1)质量上,层数向规划器倾斜更有效:14+2 与 12+4 的 NDCG@5 最高(0.0631、0.0635),继续把层数挪给生成器后效果持续下降(10+6 为 0.0621,8+8 为 0.0605)——slate 规划是全局的列表级建模,需要足够深度,item 生成只是轻量的 SID 解码。

              2)时延上,生成器每多一层代价都很高:12+4、10+6、8+8 的时延分别升至 1.355×、1.710× 和 2.065×,因为生成器的层数要与 beam 宽度和 SID 长度相乘,规划器的层则只在 slate 层面执行一次。

              综合来看,14+2 是质量与时延的最佳折中:相比 12+4,推理时延降低 26%,NDCG@5 仅下降 0.6%;而 15+1 时延只再降一点(0.932×),NDCG@5 却掉到 0.0623。因此 HiGR 默认采用 l_slate = 14、l_item = 2。

              3.3.4.3 模型 scaling 效果分析

              如上图所示,在模型Scaling 效果上,参数量从 0.05B 到 2B,收敛 loss 逐渐降低、NDCG@5 上升,HiGR 具备 scaling law 性质。推理效率上,右图横轴是推理吞吐(每分钟处理的请求数,单位为万),纵轴是 recall@5,每个点对应一种模型与解码方式的组合。相对 OneRec 的 beam 解码,HiGR(无论是否启用 KV cache)都位于右上方——吞吐高出数倍、recall@5 也更高;相对 OneRec 的 greedy 解码,HiGR 在吞吐相近的情况下 recall@5 大幅领先(约 0.071 对 0.046)。综合来看,HiGR 实现了 5 倍左右的推理速度提升,同时推荐指标更高。

              3.3.5 业务应用效果

              如上图所示,HiGR 已在腾讯新闻、QQ浏览器小说等多个业务场景推全,已全流量上线的3个场景的收益各有侧重:场景 1 的参与度指标全面提升,人均停留时长 +1.03%、人均观看时长 +1.22%、人均视频播放 +1.73%、人均请求数 +1.57%;场景 2 用户响应与变现同时提升,CTR +0.68%、广告收入 +0.56%;场景 3 的观看时长提升,人均观看时长 +1.14%、人均视频播放 +0.88%。更重要的是,这些收益是在推理成本下降的前提下取得的:得益于层次化解码与 beam search 等推理加速优化,推理耗时与成本大幅降低。

              3.3.6 小结

              HiGR 的出发点是把 NTP 范式的 item 级 SID 生成直接扩展到 NSP 范式的 slate 生成,而推荐列表生成会遇到纠缠的 SID 空间、低效的细粒度解码与目标错位三个断层,HiGR 用 tokenizer、解码器与训练目标的协同设计逐一回应:

              1)PCRQ-VAE 只对前 D−1 层码字施加前缀对比约束,高层前缀共享语义、叶子层保留 item 身份;

              2)HSD 把 slate 规划与 item 解码分离,粗粒度规划器在偏好 embedding 空间逐位置规划整屏意图,共享的细粒度生成器把每个偏好落成短 SID 序列,beam search 只在 item 级短序列内进行;

              3)ORPO listwise 对齐无需参考模型,从隐式反馈中构造排序保真、真实兴趣、列表多样性三类正负 slate 对,把列表级的多目标偏好折叠进一次监督训练。

              此外,配合 beam 折叠进序列维的 K/V 投影优化、Flash Attention 与 KV cache,HiGR 推理速度提升 5 倍以上,训练速度提升 2 倍以上,成本降低 60%。

              据我们所了解的公开信息,HiGR 是业界首个工业化落地的列表级端到端生成式推荐模型框架,HiGR 论文《HiGR: Industrial-Scale Hierarchical Generative Slate Recommendation Framework in Tencent》已被 CIKM 2026 录用(Oral Presentation)。

              3.4 GenRec 方向总结与展望

              TGR-GenRec 方向探索用生成式模型替换级联中的判别式决策阶段,沿 NTP 与 NSP 两种生成式范式分别提出了 BARGE 与 HiGR,并均已在线上业务落地。NTP 范式的 BARGE 做推荐自回归适配:ICA 恢复 item 边界、HPR 以路径一致性重排 beam、DPD 提供第二条解码通路,三个模块不改 NTP 骨架,已作为一路生成式召回在小说推荐场景全量上线。NSP 范式的 HiGR 把生成单元从 item 升级为 slate:PCRQ-VAE 结构化 SID 空间,HSD 分离规划与生成,ORPO 做列表级多目标对齐,同规模效果优于 OneRec,推理提速 5 倍以上,已在腾讯新闻、QQ 浏览器等多个场景推全。此外,BARGE 的论文已投稿至WWW 2027,HiGR 论文已被 CIKM 2026 录用(Oral Presentation)。

              展望未来,TGR-GenRec 的下一步沿五个方向继续探索:

              1)生成与排序合一:共享骨干的"生成 + item 级打分"头,用 item 级分数替代 beam 似然做最终排序,让一个模型逐步承担召回与粗排 / 精排的职责;

              2)价值对齐与多目标可控:引入在线反馈 RL(时长 / 转化 / 商业价值奖励),用可控解码替代多路配额,加入业务价值感知 token;

              3)tokenizer 统一升级:合并为一套协同感知 tokenizer,自适应碰撞处理、多维码本、跨场景统一码本;

              4)推理原生的生成:latent thinking token 逐层引导 SID 解码,Looped Transformer 按请求自适应循环深度,测试时算力弹性伸缩;

              5)scaling 效率的模型—系统协同设计:支持 2B 以上更大的在线推理模型,统一规划器与生成器,引入稀疏注意力与加速器友好的约束解码。

              这五个方向中,"推理原生的生成"指向一个更根本的问题:如何把大模型的推理能力引入生成式推荐。下一章的 TGR-Reason 正是围绕这个问题展开。

              四、TGR-Reason:大模型推理增强与快慢思考协同

              前两章分别介绍了 TGR-GenRank 与 TGR-GenRec,解决的是排序模型的算力效率与端到端生成两个问题;但无论判别式打分还是生成式解码,模型学到的都是行为共现:协同信号密集处很强,稀疏处表现欠佳。冷启动用户、长尾 item 与意图模糊的会话正是协同信号的边界,也是大模型的世界知识与推理能力能够补位的地方。问题在于推荐系统每天数十~千亿次请求、数十~数百毫秒的延迟预算,大模型思考推理的成本和耗时都难以达到要求。TGR-Reason 方向的核心思路是”快慢思考”的分工:慢思考(大模型推理)在离线或训练期完成,快思考(在线生成式模型)毫秒级响应,两者通过共享的 SID 空间与 reason tokens 接口衔接。本章按两部分展开:训练期把推理摊销进模型参数的 LatentRec,以及把 Think 模型的推理结果物化为 reason tokens、在线零推理注入生成器的 TGR-Reason 系统。

              4.1 协同信号的边界:冷启动、长尾与意图模糊

              如上图所示,判别式与生成式推荐模型两者主要都在拟合行为共现:“看过 A 的人接下来看 B”——协同信号密集处很强,而在以下三类协同信号稀缺的场景效果欠佳:1)新用户 / 冷启动,历史序列为空或极短,没有共现证据可用;2)长尾 item,协同信号稀疏,几乎没有交互边可学;3)意图模糊的会话,历史指向多个方向,需要意图推断。

              如上图所示,业界针对冷启动、长尾与意图模糊的既有解法可以归成两类:

              1)借旁证,用替身代替缺失的行为。比如,人群先验(POSO,新用户组专属子模块加个性化门控,防止新用户特征被大盘”淹没”)、内容对齐(M3CSR,多模态 embedding 聚成可训练簇 ID,再与行为对齐进协同空间)、跨域迁移(EMCDR / MeLU,跨域映射或元学习”好初始化”,用几条交互快速适配)、探索采集(bandit 与兴趣选择页,主动采集反馈),最终都对齐进协同空间当作行为用。

              2)多备选,判断不了就多路覆盖。比如,多兴趣向量(MIND / ComiRec,多向量分头覆盖多个可能意图)、解耦去偏(Google CDN / IPS,头尾解耦、重加权尾部样本,去流行度偏差)、情境约束与多样性(用时间 / 场景 / 多样性约束缩小候选范围)等。

              两类解法的共同结构是一种补充证据加一种归纳偏置,但没有”推断”能力。

              如上图所示,总结了业界把大模型接入推荐系统的五类常见方式,外加一层可叠加的推理:

              A)表征增强,LLM 表征或语义码进协同模型当特征(如快手 LEARN、QARM,字节 HLLM,小红书 NoteLLM等);

              B)离线推理产出知识或画像,缓存后作特征或召回通路(如淘宝 RecGPT,Amazon COSMO,美团 CoEA等);

              C)模拟与数据增强,LLM 为冷物品、新用户”造”交互(如Google 数据增强器,阿里 ColdLLM / FilterLLM等);

              D)物品 token 空间,LLM 扩 SID 词表,用行为序列继续预训练加 SFT,自己生成物品(如Google PLUM,Spotify GLIDE等);

              E)自然语言空间,物品与行为写成文字,LLM 微调或零样本打分(如LinkedIn 360Brew,LLM-Ranker等);

              推理叠加层可叠在任意骨干网络上、不限于 LLM,显式 CoT 如 OneRec-Think / OneReason,隐式 latent 多步如 ReaRec、LARES、LASAR、PauseRec等。

              综上所述,协同信号在一定程度上是管”记忆”,而大模型是补”推断”能力,“协同 + 推断”的融合是业界积极探索的演进方向。

              4.2 快慢思考:推理增强推荐的范式与业界路线

              4.2.1 快慢思考:从双过程理论、LLM 到推荐系统

              如上图所示,“快慢思考”在三个领域的运作机制:

              1)认知科学中(Kahneman《思考,快与慢》),System 1 直觉、自动、并行,几乎不耗注意力,快但带系统性偏差;System 2 审慎、串行、耗费注意力,能做逻辑与反事实推理,但昂贵;两者的协作方式是默认 System 1,新奇、冲突、高风险时 System 2 介入纠偏,技能熟练化把慢的推理沉淀为快的直觉。

              2)LLM 中,直接作答(non-thinking)一次前向逐 token 输出、延迟低,难题上容易”想当然”;思维链 / 长推理(thinking)用更多推理 token 换准确率(test-time scaling);协作方式是混合模式在同一模型内切换 thinking / non-thinking 并给推理设预算,以及蒸馏,把慢的输出蒸馏回快模型。

              3)推荐系统中,快是一次前向直接匹配,编码历史后直接生成或匹配候选;慢是多步推理,显式 CoT 或隐空间 rollout;协作的核心问题是慢的一步放在哪里——请求内按需路由、离线 / 近线缓存、还是训练期摊销。沿这个思路,LLM 思考推理增强推荐的设计主要涉及两个关键问题:推理范式与部署方式。

              4.2.2 推理范式:显式 CoT 与隐式 latent

              如上图所示,推理范式的第一种是显式 CoT——用文字想,可读可解释,但推理开销较大,有两种形态:

              1)在线 CoT 让每个请求都在请求路径上逐 token 写思维链,数百 token 的生成超出数十~百毫秒的延迟预算。

              2)Think-Ahead 把思维链离线写好、只缓存结果,在线按前缀约束解码:离线做全量 OneRec-Think 推理,得到推理路径与首批 SID token,按用户缓存;在线读缓存前缀,由轻量 OneRec 做约束解码,请求路径不再写思维链——这是 OneRec-Think 的上线形态。

              第二种是隐式 latent——在潜在空间内思考,开销降到 K 步前向。如上图所示,编码历史得到 h₀ 后做 K 步隐向量 rollout,h₁、h₂ … h_K 每步一次前向、不写 token,再预测或解码 SID。

              4.2.3 部署方式:请求内快慢路由与离线 / 近线推理

              如上图所示,部署方式的第一种是在线推理——请求内按需深思,慢思考仍在请求路径上。请求经编码后由路由决定这次要不要“慢思考”:大多数请求走快路径,单次前向直接解码;少数请求(新用户、低活用户、不确定时)走慢路径,K 步 latent 或 CoT 之后再解码。业界有四种常见做法决定要不要思考、要思考多深:学习到的 selector / planner 按样本路由;预测与反馈不一致时触发反思;收敛即停,多想一步预测不再变化就停;流量分层,按用户群或场景分流。

              第二种是离线 / 近线推理——慢思考不在请求路径上,如上图所示有两种方式:

              1)训练期摊销:慢思考(CoT 或多步 latent)经蒸馏或逐步监督内化到模型参数里,在进行“慢思考”时模型直接解码。

              2)离线 / 近线物化:慢模型(LLM / Think 模型)逐用户或逐物品推理一次,把推理前缀、指令 / 标签、候选池或 reason tokens 等物化产物写入按用户或物品组织的存储,在线请求只做一次点查与注入,解码时零推理 rollout。

              4.2.4 全景图:推理范式 × 部署方式与 TGR-Reason 的路线选择

              如上图所示,以推理范式为纵轴、部署方式为横轴,可以把业界工作放进一张 2×2 的全景图,实线为已上线或线上 A/B 的系统,虚线为论文或离线评估。

              TGR-Reason 的解决思路是:LatentRec 在训练期把推理摊销进参数(K=0),TGR-Reason 把 Think 模型的推理结果物化为 reason tokens,注入在线生成式模型。下面分两节展开介绍。

              4.3 LatentRec:隐空间“思考–生成”一体化

              4.3.1 研究背景:推荐推理的收益与生成成本

              LatentRec 的出发点是把推理过程转化为推荐训练信号。如上图所示,业界三条线索各有启发:

              1)文本推理与任务对齐——OneRec-Think 分 item 对齐、推理激活、推荐奖励 RL 三阶段:由用户历史与目标 item 事后构造偏好推理轨迹做 CoT-SFT,先激活推理与推荐的关联,再以此为冷启动用推荐奖励 RL 校准;

              2)连续隐状态与知识蒸馏——COCONUT 把上一步末层 hidden state 作为下一步输入,以连续向量承载中间计算;CODI 共享 LLM、通过 LKD 对齐师生隐藏表示;

              3)推荐中的逐步监督——ReaRec 逐步监督各推理步的状态并配合温度逐步降低,使中间状态直接获得推荐训练信号,启发是把这种监督迁移到 LLM 的 SID 预测头。

              由此 LatentRec 聚焦两个问题:一是 latent 推理迁移到 SID 解码时,反馈输入与监督如何设计;二是推理期不做 latent rollout 时,训练收益能否保留。

              4.3.2 方法设计:隐空间“思考–生成”一体化

              如上图所示,LatentRec 的总体架构是训练期多步展开、生成期直接解码。

              (a) 总体流程:用户行为历史经 LLM Encoder 得到 h₀,连续思考模块 CTM 迭代 K 次(初始 h_k = h₀),SID Decoder 输出完整 SID(s_a、s_b、s_c、s_d);

              (b) STS(Soft Token Selection)构造每一步的反馈输入;

              (c) PRL(Per-step Reasoning Loss)监督每个中间状态。

              训练时 K_train = 2:用户历史产生 h₀,STS 构造反馈输入,LLM 结合 KV cache 得到 h₁、h₂,PRL 分别监督 h₁、h₂,完整 SID 序列接受自回归 CE。

              生成时 K_eval = 0:用户上下文直接进入训练后的 LLM,自回归预测完整 SID,跳过 CTM 展开,保留训练中更新的共享 LoRA,以及标准的 SID 解码与候选搜索。

              LatentRec 模型可训练参数很小:Qwen3-1.7B 底座,LoRA rank 16,STS 的 64 个 soft token 约 2.5M 参数,新增参数小于骨干的 0.2%,仅更新 LoRA、soft tokens 与 W_q,训练 3 个 epoch、batch size 64。

              两个机制的细节如上图所示:

              1)STS 解决的是反馈输入的表示不匹配:hidden state 的范数约 45,词表 embedding 的范数约 3,相差约 14 倍,直接把隐状态反馈回输入会改变下一步输入的尺度与方向。STS 维护 N=64 个可学习向量,由词表 embedding 初始化;当前隐状态经线性投影 W_q 形成 query q_k,对 token bank 做 softmax 加权求和得到 e_k,作为下一步的输入,再经 LLM 前向(带 KV cache)得到 h_{k+1}。

              2)PRL 共享预测头、直接监督推荐目标:每个中间状态 h_k 经过同一个 LM head 预测目标的第一层 SID y¹,损失是各步 CE 的平均,总损失 L = L_CE + λ·L_PRL,λ = 0.1;温度逐步降低,T_k = T_b + T_s(1 − k/K),T_b = 1、T_s = 5,K=2 时 T₁ = 3.5、T₂ = 1.0,早期分布较软,最后一步更聚焦目标。

              为什么只监督首层 SID:更深码字需要在每步提供目标 SID 前缀,会把 latent 轨迹与固定解码路径耦合;首层监督可以独立施加,完整序列仍由标准自回归目标学习。

              4.3.3 实验效果:推荐收益、生成效率与消融分析

              如上图所示,主实验在 Amazon Beauty、Toys、Sports 三个数据集上比较 GRU4Rec、SASRec、BERT4Rec、HGN、TIGER、ReaRec、LLM-CoT SFT 与 LatentRec(Qwen3-1.7B,全库排序,beam=50)。K=0 的 LatentRec 在三个数据集的 HR 与 NDCG 四项指标上均优于全部基线,HR@10 相对 CoT SFT 在 Beauty +5.0%、Toys +4.5%、Sports +4.0%。

              推理成本上(Beauty 数据集,单张 H20,batch=1),CoT SFT 每个样本要额外生成 128 个文本 token,单样本耗时 10.80 秒;LatentRec K=0 不做 latent 展开,单样本耗时 0.59 秒,推理耗时降低到原来的约 1/18,HR@10 还从 0.0625 提高到 0.0656;K=1 耗时 0.61 s、HR@10 0.0660,但在三个数据集上没有一致的收益,默认采用 K=0。

              接下来,通过消融实验分析来看收益来自哪里、展开多少步合适,如上图所示:

              1)PRL 的效果增量:在 CoT SFT 的 0.0625 基础上继续 LoRA 训练到 0.0629,加 CTM 到 0.0633,加 PRL 到 0.0656,最后一步相对提升 +3.63%,是三步中最大的一步。

              2)训练与生成深度的关系:K_train=2 的 K=0 结果最强,K_train=4 在 K=1 处达到最优,K_train=16 整体偏低;展开更多步未必更好,训练与测试深度需要匹配,跨三个数据集默认 K_eval=0。

              3)CoT 初始化对照:有 CoT 初始化与无 CoT 初始化在 K=0 时收敛到相同的 0.0656,随着展开加深差异扩大(K=16 时 0.0634 对 0.0583)——CoT 初始化在深层 latent 展开时有助于稳定效果,K=0 的直接生成路径则不依赖这一初始化,训练阶段的监督方式与生成阶段的展开深度需要分别选择。

              4.3.4 解码性能优化

              如上图所示,以小说推荐业务的 Think 模型为案例,任务是由用户上下文生成 top-5 完整 SID。

              用户输入:包括画像 / 场景(年龄段、城市等级、职业、场景等)、偏好(已有一级、二级小说类目偏好)与行为(按序组织的阅读 SID 与内容标签),冷用户保留画像,缺少历史时使用占位描述。

              模型是 Qwen3-1.7B 的 Think 模型,输出 top-5 SID 候选列表,下游 HiGR 共享同一 SID 空间。

              输出格式是 4 层码字 × 256,加起止标记共 1,026 个 special token;

              每位用户生成 top-5 完整 SID,按累计 log-prob 排序:K=0 是 latent 展开步数,B=5 是候选路径数,6 轮是单条 SID 的 token 长度。

              训练先学习内容与 SID 的对齐,再学习用户到 SID 的预测,训练与推理共用 prompt 构造逻辑;候选搜索的优化重点是批量前向与前缀 KV 复用。

              解码方案通过一次 POC 确定(vLLM 0.9.0,H20,2,000 条抽样),如上图所示,对比了四种解码路径的 Hit@5 与吞吐。我们采用批量单步 Beam的解码方式,它的做法是把 beam search 拆成"搜索"与"计算"两部分:业务层保存每条候选路径的前缀、累计分数和所属用户,每一轮把全部活跃路径集中提交给推理引擎,只请求下一个 token(max_tokens=1);引擎返回下一个 token 位置的 log-prob 分布;业务层据此在每个用户内部扩展路径、累加分数、保留 top-B,再进入下一轮。分工上,业务层负责候选状态、约束与用户内剪枝,推理引擎负责模型前向、连续批处理与前缀缓存。

              批量单步 beam 的一轮如上图所示,以 100 位用户、每人保留 5 条路径为例:

              1)当前有 500 条活跃路径,每条带着用户上下文与路径前缀,整批一起提交给 vLLM;

              2)vLLM 只计算每条路径下一个 token 位置的输出分布,共 500 个,每个分布取回分数最高的 32 个候选 token;

              3)业务层把每条路径扩展成 32 条,每位用户得到 5 × 32 = 160 条、全批共 16,000 条扩展路径,累加分数后在用户内部排序,每位用户只保留 top-5;

              4)保留下来的 500 条路径进入下一轮,其余 15,500 条就此淘汰。

              效率收益来自两处:合批——整批活跃路径统一交给引擎,由引擎做连续批处理;复用——同一用户的 5 条路径共享同一段用户历史(例如 900 token),vLLM 的前缀缓存按相同 token 前缀命中已有的 KV 块,每条路径只需计算未缓存的部分,跨路径、跨轮次都能复用,已生成的共同前缀同样可以复用。

              4.3.5 小结

              LatentRec 的出发点是把大模型的推理能力用于 SID 生成,同时不把推理开销带到线上。把推理过程转化为推荐训练信号会遇到三个问题:显式 CoT 要额外生成数百个文本 token,推理成本高;隐状态直接反馈回输入时与词表 embedding 尺度不匹配;中间状态缺少直接的推荐监督。

              LatentRec 针对这三个问题分别给出了对应设计:1)CTM 在隐空间做多步展开,不写文本 token,训练展开 K=2、生成时 K=0 直接解码完整 SID,推理收益保留而开销归零;2)STS 用可学习的 soft token bank 构造每一步的反馈输入,解决尺度不匹配;3)PRL 让每个中间状态经共享 LM head 直接预测首层 SID,使中间状态获得推荐监督。

              效果上,三个数据集的四项指标均优于全部基线,HR@10 相对 CoT SFT 提升 4.0%–5.0%,单样本耗时从 10.80 秒降到 0.59 秒。此外,配合批量单步 beam 与前缀 KV 复用,8×A100 上 418,227 条样本的生成耗时从 174 分钟降到 80 分钟,总体 Hit@5 从 0.2760 提升到 0.2782。

              此外,LatentRec 论文《Do Recommenders Need to Think in Words? Latent Reasoning for Efficient LLM-Based Recommendation》已被 CIKM 2026 录用。

              4.4 TGR-Reason 系统:快慢模型 co-design

              4.4.1 设计背景:时延、成本与持续学习

              LLM 推理难以直接用于线上推荐系统主要有三个原因:

              1)时延:推荐请求的延迟预算是数十毫秒~百毫秒,一次 LLM 推理基本都要秒级,相差 1~2 个数量级,单次推理就占满整条链路的预算。

              2)成本:请求内推理的总成本随曝光量线性增长,其中大量曝光并不转化,计算被浪费;GPU 还要按峰值配置,低负载时段大量闲置。

              3)持续学习:推荐样本分布漂移快,新 item 与新用户持续进入,模型需要小时级或天级的持续学习才能跟上;大模型重训成本高,通常周级发布一版,强行让它高频微调,反而会在窄分布上稀释其通用语义与世界知识。

              TGR-Reason 的方案是快慢模型的 co-design:慢模型(Think 模型)负责思考,快模型(在线生成器)负责生成。大模型低频重训,承载语义与世界知识;在线生成器持续学习,承接新 item 与新用户;reason tokens 作为两者的接口,离线预计算并存储,把两种学习节奏衔接起来。

              4.4.2 方法设计:快慢思考协同的三层架构

              如上图所示,三层部署架构是在线只读、近线按需刷新、离线兜底,三层共享一个以用户 ID 为键的 Reason Store:

              1)Part A 在线服务,毫秒级、只读:按 user_id 点查一条 Reason 记录,校验有效期与版本,然后以token或特征等形式注入 TGR-GenRec、TGR-GenRank 的模型。

              2)Part B 近线推理,秒级、请求触发:每个请求异步发出触发事件,Reason Trigger Controller(RTC)判据决定算不算,准入的任务交给常驻 GPU 池攒成小批一起算,结果写入 Redis、供用户后续请求使用。

              3)Part C 离线推理,日级、吞吐优先:扫描日志与存储元数据识别待重算用户,弹性大批量池整批重生成,周级重训发布后把不兼容记录标为待重算并渐进重建。

              4.4.3 工业落地

              如上图所示,介绍两种TGR-Reason的应用落地方式:

              1)离线召回,KV存储中的 topk_sid 经 SID 倒排索引映射到 item,过滤 / 去重、合规与库存之后进入独立配额的召回队列;

              2)在线生成,KV存储中的 topk_sid / cot_emb 经 GMR / DRI 模块注入 TGR-GenRec 的 Encoder–Decoder 解码,生成的 SID 映射到 item;

              离线召回的实现方式相对简单,这里不再赘述,重点介绍在线生成的实现方案。

              在线生成是把 reason tokens 注入 TGR-GenRec,如上图所示:

              1)图中右侧是 LatentRec:用户的个人记忆经 LLM Encoder、CTM 与 SID Decoder,产出 top-K 条完整 SID,即 reason tokens。

              2)图中左侧是 TGR-GenRec:encoder 侧有两路——Personal Encoder 编码个人记忆,Group Encoder 编码检索到的群体记忆;decoder 每层以 self-attention 的输出为 query,分别对两路 encoder 输出做 cross-attention,再经 MLP 门控融合。

              3)reason tokens 从两个入口进入生成器:

              3.1)GMR(Reasoning-Guided Group Memory Retrieval)作用在 encoder 侧——以每条 reason token 为 query,在全量历史序列中检索其后续窗口,得到"推断意图之后用户通常会看什么"的群体记忆,由 Group Encoder 单独编码后与个人记忆门控融合,个人记忆为主、群体记忆按兼容性激活;

              3.2)DRI(Direct Reasoning Injection)作用在 decoder 侧——top-K 条 reason token 与 encoder 输出做 cross-attention,结果作为 soft prompt 插在每一层目标码字之前,为逐层解码提供先验;生成的 SID token 数与 beam 搜索空间都不变。

              GMR 的四个要点如上图所示:

              1)用完整 reason token 做检索 query,检索获取 W 个 item;

              2)每个 query 独立取 top-M 再拼接,每个 reason token 按频次保留 M 个高频后继、不做全局重排,保留每个推断意图各自的后续行为,共 K·M 个 item;

              3)分离编码、保留来源差异,群体记忆由独立的 Group Encoder 编码;

              4)向量门控的非对称融合,解码每层两个独立的交叉注意力分别对应 Personal Encoder 输出与 Group Encoder 输出,个人记忆始终是主信号。

              DRI 的四个要点如上图所示:

              1)按码本层重组、保留全部 K 个候选,一个 reason token 是一个连贯的候选 item,其码字在各层角色不同,DRI 按层查共享的 SID embedding;

              2)以 Personal Encoder 的输出为 query 选证据,Personal Encoder 的输出作为用户兴趣表达,学的是”哪些候选与个人记忆兼容”,而非照抄 LLM 的 top-1;

              3)作为连续的层级对齐 prompt 插入解码(叠加位置与类型 embedding),prompt 是增强而非替换用户历史;

              4)beam search 前算一次、所有 beam 共享,SID 决策数与 beam 搜索空间都不变,reason tokens 全缺失时 prompt 位置被 mask,退化为原路径。

              Decoder 侧还有一种内部探索的注入方式:先选 top-N,再并行多路解码。如上图所示,不把 K 条意图压成一个先验,而是以 Personal Encoder 的 user emb 为 query 对 K 条 reason SID 做相关性打分,挑出最相关的 N 条(N < K),每条各走一路 TGR-GenRec Decoder 得到一组 SID 候选,各路只带一个意图、互不干扰、可并行执行,最后合并去重进入统一精排。

              另外一种方式是后训练阶段注入——在 TGR-GenRec 的后训练(OneModel 强化学习,以 LLM 模拟反馈作 reward)中注入 reason 结果,离线暂未取得显著收益。

              4.4.4 实验与效果

              如上图所示,离线实验以3个测试日等权平均,对照为线上在用的 TGR-GenRec:

              1)全部推荐流量上,Hit@1 从 0.3385 提升到 0.4339(+28.2%),Hit@5 +10.4%,Hit@10 +6.3%,Hit@20 +4.1%,Hit@50 +2.4%;

              2)主推荐流量上,Hit@1 从 0.2247 提升到 0.3563(+58.6%),Hit@5 +13.1%;

              3)主推荐流量中的冷启动用户,Hit@1 从 0.0451 提升到 0.2606(+477.8%),Hit@5 +39.2%,Hit@10 +24.9%,Hit@20 +20.1%,Hit@50 +11.6%。

              有两点实验观察:

              a)增益集中在列表头部(Hit@1 +28.2% 对 Hit@50 +2.4%),Reason 推理的贡献主要是把合理的目标推到前几位;

              b)冷启动用户增益最大,reason tokens 提供了针对新用户缩小目标空间的语义先验。

              此外,线上 A/B 小流量实验上,对照为未引入 Reason 的 TGR-GenRec:有效消费率(Effective Consumption Rate)+1.75%,新用户曝光–转化率(Exposure-to-Conversion)+13.09%,两项均统计显著,新用户的转化提升远大于整体。

              4.4.5 小结

              TGR-Reason 系统通过快慢模型的 co-design 来解决把大模型推理放进线上推荐的问题,架构上分为在线 / 近线 / 离线三层,其中慢模型的思考token注入 TGR-GenRec,是把推理当"先验"——GMR 把 reason 引导的群体记忆注入 encoder,DRI 把 reason 作为层级对齐的 soft prompt 注入 decoder,不增加 SID 决策数与 beam 空间。

              效果上,离线全部推荐流量 Hit@1 +28.2%、冷启动用户 Hit@1 +477.8%;线上 A/B 有效消费率 +1.75%、新用户曝光–转化率 +13.09%。

              4.5 Reason 方向总结与展望

              TGR-Reason 方向探索把大模型的世界知识与推理能力引入推荐系统,补上协同信号之外的"推断"这一步,并且沿慢思考的两种落地方式分别提出了 LatentRec 与 TGR-Reason 系统,并均已在线上业务落地。

              展望未来,TGR-Reason 的下一步沿四个方向继续探索:

              1)选择性深思:when-to-think、收敛即停与路由策略设计:尝试对高价值 / 冷启动请求在请求时启用 K>0 解码;

              2)推理离线化与蒸馏:System 2 → System 1,借鉴 reasoning-augmented LLM 的做法,把 Think 模型的能力蒸馏到更小、更快的变体,缩短刷新周期、扩大覆盖;

              3)latent 推理 SID 原生:把逐步监督扩展到更深的 SID 层与整屏 slate,与 HiGR 的规划器协同,让 reason tokens 直接约束整屏生成,并探索 latent 步在 SID 位置上的自适应分配;

              4)test-time scaling:建立可预测的算力–效果规律,把推理与排序打通,探索推理增强的"生成 + 排序"一体化方案。

              总结与展望

              从 CCFormer 到 BARGE、HiGR,再到 LatentRec 与 TGR-Reason,TGR 走的是一条逐段替换的路。排序模型的范式迁移解决了算力效率,端到端生成解决了决策单元与目标割裂,推理增强补上了协同信号之外的”推断”这一步。TGR 各个方向的技术方案介绍已经整合为 TGR 技术报告《TGR: Advancing Industrial Recommendation from Generative-Paradigm Ranking toward Unified Generation and Reasoning》(arXiv 2609.00986)公开发布。

              TGR 已在腾讯新闻、浏览器、元宝等多个业务场景规模化落地,用户消费时长、广告收入等核心指标显著提升,TGR各方向已发表多篇论文并申请多项技术专利,部分成果已被AAAI、ACL、CIKM等国际顶级会议收录,下图为部分代表工作。

              未来 TGR 将沿三个层面继续展开探索:1)生成式推荐模型的 scaling 效率;2)推理原生的生成与 test-time 计算;3)推荐系统的 Agentic 自进化。

              特别是推荐系统的自进化方向,如何在 ROI 约束下,让 LLM 多智能体在有限的算力与线上流量预算内自主提出、验证并沉淀模型改进,把离线迭代与小流量求证连成一个可控、可审计的闭环。TGR 已在这一方向展开探索并取得初步效果,敬请期待后续更多 TGR 系列技术分享。

              合作交流

              以上生成式推荐解决方案已集成到“TRS推荐引擎平台”,如有方案接入或商务合作意向,欢迎随时与我们联系。欢迎访问官网了解更多信息:https://trs.tencent.com

              附录

              1. TGR Team. “TGR: Advancing industrial recommendation from generative-paradigm ranking toward unified generation and reasoning,” arXiv preprint arXiv:2609.00986, 2026.

              2. Y. Wang, H. Zhang, H. Hu, Y. Li, et al. "CCFormer: Efficient Cross-Field Interaction and Hierarchical Sequence Compression for Industrial Recommendation at Tencent," arXiv:2607.28070, 2026.

              3. Y. Pang, Z. Liu, Y. Li, et al. "HiGR: Industrial-Scale Hierarchical Generative Slate Recommendation Framework in Tencent," CIKM / arXiv:2512.24787, 2026.

              4. J. Zeng, J. Zhu, J. Chen, Y. Li, et al. "Bridging the Structural Gap: Adapting Autoregressive Generation for Recommendation," arXiv:2607.21028, 2026.

              5. H. Su, B. Kong, L. Cheng, C. Zhuo, and Z. Li. "Do Recommenders Need to Think in Words? Latent Reasoning for Efficient LLM-Based Recommendation," CIKM, 2026.

              6. TRS官网:https://trs.tencent.com/

              跳转微信打开

              ❌