铃阅
❌

阅读视图

构建 AI 时代的知识底座:直播数据 LLM Wiki 实践

楚翎、程知微 2026-11-16 14:53 浙江

编译散落知识,构建AI底座

图片

本文介绍直播数据团队构建LLM Wiki以解决领域知识散落、矛盾及易腐化难题的实践。传统RAG无法根治知识质量退化,LLM Wiki通过“编译”将DDL、代码等源材料转化为结构化、可验证的知识资产。其核心在于Schema契约、显式关系图及分层架构,结合Agent编排实现自动化构建与检索。实践表明,该方案在指标召回、SQL生成及模型迭代中显著提效,如血缘查询提速15倍,遗漏率降为0%,实现了从机械劳动到高价值决策的转变,为AI时代提供了高质量知识底座。

图片

为什么要知识库

领域知识决定了 AI 在业务中能发挥多大的价值和作用。任何 AI 系统都由模型、知识、架构三部分组成。模型由供应商提供,只能被动接受;架构常因模型能力升级而失效重做。相比之下,领域知识只能从内部积累——不可替代,且随业务演进而持续变化,是最值得长期投入的部分。

然而,领域知识的沉淀面临诸多挑战,在数据团队中尤为严重。知识散落在代码和注释、配置、钉钉文档、沟通记录等各处,没有统一载体,这带来两层后果:

  • 知识质量退化:传播靠口口相传,人走知识就断;口径不一致,同一指标在不同文档里定义矛盾,没人能仲裁;即便有人写了文档也无人持续维护,三个月后就和线上对不上。

  • 工程熵增:缺乏全局视图,团队无法判断一张表是否已经存在、一条链路是否已有人建过,重复建设不断累积数据负债。

数据团队中如口径答疑、问题排查、代码生成这些本可以被 AI 极大提效的场景,都卡在了"知识喂不进去"这一步。

直接套 RAG 解决不了这件事。RAG 的模式是每次查询都到原始文档碎片里现找现拼——chunk 召回、上下文拼接、模型生成——但它并不改变原始材料本身的状态。散落的还是散落的,矛盾的还是矛盾的,过期的还是过期的,只是多了一层向量索引。知识本身的问题一个没解决,只是把"人找不到"变成了"AI找到了但答不准"。

问题出在知识本身,不在检索。需要的是在检索之前加一道"编译过程"——把散落、矛盾、易腐化的源材料,预先加工为可被AI直接消费的知识。这是 LLM Wiki 的起点。

实际效果

先来看看实际效果,下面从指标维度召回、SQL代码生成以及数据模型迭代4个例子来介绍LLM Wiki的检索生成效果。

▐2.1 指标和维度召回

  • 主播xxx分维度召回

以"主播xxx分用哪张表"为例,系统首先通过 index.md 定位到 basic/审核打标域,然后全域搜索召回候选表,再逐张读取详情页判断覆盖度和相关性。最终精准推荐xxx分维表作为首选,同时区分出 DWD 增量明细表(适合追溯变更历史)和主播画像宽表(适合同时需要xxx分和其他属性时),并主动排除了名称相似但实际是"讲解xxx分"的干扰项。

  • 2.1.2 xxx交易指标召回

用户问"xxx交易指标怎么取",系统经域推断 → 多路搜索 → 详情验证三步,精准推荐 DIM 层标签表(直接有xxx字段)和 DWD 层明细表(xxx标记字段可自行聚合),并附带判定逻辑、SQL 示例和血缘链路,一次查询给出从选表到取数的完整答案。

▐2.2 SQL代码生成

用户问"不同主播等级的开播场次数怎么算",系统自动跨维表域和供给开播域,定位到主播基础信息宽表(主播等级)+ 主播标签预聚合表(预聚合多窗口场次数)或主播开播日汇总表(按天累加自定义范围),输出 JOIN 关联的 SQL 骨架,同时标注废弃字段、xx开播口径和多套分级体系的差异——从自然语言到可执行 SQL,一步到位。

▐2.3 数据模型迭代

  • 2.3.1 背景

数据模型迭代是数仓日常工作中高频且高风险的场景。一次迭代往往涉及:

  • 上下游传播:变更沿血缘链路传导,影响可达数十张下游表

  • 阈值/规则联动:字段参与 WHERE 条件、CASE WHEN 分档,改错会导致业务判定失效

  • 口径一致性:新旧口径差异可能引入数据偏差,需双跑验证

    需求理解 → 查表结构 → 查血缘 → 判影响 → 估风险 → 写SQL → 验数据
       ↓        ↓         ↓      ↓        ↓      ↓       ↓
    人工耗时   grep搜索  手动递归  看代码   凭经验   逐表改写  手写SQL

    传统做法依赖人工逐表排查 SQL 代码,耗时易出错,迫切需要一种新范式,让 AI 承担"查血缘、判风险、写代码"的机械工作,将人力聚焦在"决策确认"环节。

    • 2.3.2 基于LLM wiki的数据模型迭代

    基于LLM wiki知识库,把迭代需求拆解成6个步骤,按顺序调用对应的子Skill执行,关键节点用户确认。

    步骤

    做什么

    输入→输出

    需求拆解

    理解需求,识别需求类型

    需求描述 → 需求类型 + 指标口径

    知识库召回

    从Wiki查目标表,拉取DDL和口径定义

    表名 → 表结构 + 口径说明

    血缘查询

    用graph.json查全链路下游,强制完整性校验

    目标表 → 下游表完整列表

    风险评级

    看下游SQL,判断业务影响(高/中/低)+ 风险类型

    下游表 → 二维风险矩阵

    SQL生成

    批量生成DDL+ETL+验证SQL+回滚SQL

    影响分析 → 全套SQL文件

    报告输出

    整合分析结果,生成影响分析报告

    全流程结果 → 可交付报告

    • 2.3.3 具体实践场景

    场景一:数据源切换(data_source_switch)

    需求:xxx数据从加权计算切换到大盘数据源

    流程:

    • Step 1:确认切换含义(直接引用 vs 重新计算)

    • Step 3:查全链路下游血缘,发现 12 张间接下游表

    • Step 4 路径A:看下游 SQL,发现阈值判定→ 业务影响=高

    • Step 5:生成目标表改造 SQL + 12 张下游表适配 SQL + 口径对比 SQL

    关键发现:间接下游表中有 3 张参与准入判定,切换后阈值需调整


    场景二:新增字段(addition)

    需求:xxx数据链路新增"xxx分"等字段

    流程:

    • Step 1:确认指标一一映射

    • Step 4 路径B:列出 ** 张候选下游表,用户确认传播范围(选中 * 张)

    • Step 5:逐表判断血缘 JOIN 状态 → 生成 * 张下游表适配 SQL

    关键机制:路径B 强制用户确认,避免遗漏或过度传播


    • 2.3.4 最终效果

    事项

    传统人工

    AI 编排

    提效

    血缘查询时间

    30min(手动递归)

    2min(--impact)

    15×

    下游表遗漏率

    20%(间接下游易遗漏)

    0%(强制完整性校验)

    100%

    SQL 生成时间

    0.5天(逐表改写)

    10min(批量生成)

    72×

    风险判定一致性

    低(凭经验)

    高(二维矩阵标准化)

    质变


    • 2.3.5 总结

    通过 model-iteration-analysis 编排架构:

    • 全流程自动化:从需求输入到 SQL 输出,人工只做"三道确认"

    • 血缘完整性保障:下游详情补全,杜绝遗漏

    • 风险量化评级:二维矩阵替代模糊描述,判定标准一致

    • 状态可追溯:单一状态文件记录完整分析链路

    最终效果:模型迭代影响分析从半天缩短到小时级,下游表遗漏率从 20%降到 0%,数据研发工程师从"查代码、写 SQL"的机械工作中解放,聚焦在"决策确认"的高价值环节。

    LLM 编译器:怎么建

    ▐  3.1 核心思想

    LLM Wiki 不是一份"用 LLM 写出来的文档",而是一份结构化、有约束、可验证的知识资产。它和传统文档的区别在四个层面:

    • 结构可解析——单页内部结构。每个页面是 frontmatter + 正文的双层结构,frontmatter 是脚本可解析的 YAML,承载关系字段(type、domain、upstream、computed_by 等),正文承载语义描述。脚本可直接读取关系信息,不必依赖 LLM 反复解析正文。

    • 层级可下钻——跨页层级结构。域按业务主题嵌套组织,形成可逐层下钻的树。Agent 检索时可从根域渐进披露,避免一次性灌入全部上下文。

    • 关系可遍历——跨页关系结构。页面之间的血缘、归属、消费、引用关系以边的形式显式记录,构成有向图。脚本可遍历、可计算影响范围、可做多跳召回。

    • 正确性可度量——分结构、语义、人工三层校验。结构层用机械规则做自动化约束;语义层用 LLM 评审页面内容(描述准确性、口径一致性、域归属合理性);关键节点由人工确认兜底。三层叠加,知识库正确性从主观判断转为可度量的工程指标。

    让 LLM 来建,不是让人来建。人工维护 Wiki 的核心问题是成本高、腐化快、难持续。LLM 作为编译器,把散落的源材料(DDL、任务代码、文档、接口配置)编译成结构化页面,人只在关键节点做确认。

    整体构建过程可以抽象为六个步骤:提取 → 生成 → 归类 → 聚合 → 链接 → 验证——对应编译器的词法分析、代码生成、作用域解析、IR 构建、链接、静态分析,本质是一条将散落源材料编译为结构化知识的流水线。

    ▐3.2 LLM Wiki 与 RAG:互补而非冲突

    一个常见的疑问是:有了 LLM Wiki 是否还需要 RAG?需要,但两者定位完全不同。

    可以用"编译时 vs 运行时"来理解。LLM Wiki 是编译时产物,把原始材料预处理成高质量的知识页面;RAG 是运行时手段,在查询时刻做精准召回。

    Wiki 在构建阶段把散落材料固化为完整语义单元——血缘关系显式记录、口径以代码为准做仲裁、层级结构支持渐进式披露、每个页面自带 frontmatter 元数据。RAG 在查询时刻基于这些页面做精准召回:frontmatter 用于硬过滤(按层级、域、血缘),正文用于语义匹配,Wiki 尚未覆盖的长尾知识仍可回退到原始材料检索。

    一句话:Wiki 提供高质量语料,RAG 提供精准召回,组合起来才是完整的检索栈。

    ▐3.3 知识来源要全

    Wiki 编译的目标是让 AI 能回答业务问题,而一个业务问题往往跨越多种知识载体:表定义结构、接口定义契约、看板定义消费场景、文档承载业务背景。材料缺一类,编译出的 Wiki 就有相应的盲区——只有 DDL 没有任务代码,AI 知道字段叫什么但不知道怎么算;有表没有看板,AI 知道数据存在哪但不知道谁在用。材料的完整度直接决定了 Wiki 能回答的问题边界。

    因此知识来源需要从广度和深度两个维度保障:

    • 广度:分为编译时知识和运行时知识,两类知识各司其职,编译时知识提供"是什么、怎么算、怎么连",运行时知识提供"现在长什么样"。

      • 编译时知识:将相对稳定的知识在构建阶段固化为 Wiki 页面,覆盖 5 类载体——表(DDL)、接口(Config + Version)、文档(钉钉文档)、任务(独立任务代码)、看板(看板元数据)。

      • 运行时知识:对查询那一刻才能确定的信息(物理表数据、任务日志、监控指标等)通过 Agent 工具调用现取,不进 Wiki。

    • 深度:每张表不止抓 DDL,还要抓产出任务代码。DDL 提供结构信息(字段、类型、注释),任务代码提供逻辑信息(计算方式、过滤条件、聚合维度、上游依赖)。只有 DDL 的 Wiki 仅是骨架,加上任务代码才构成完整的知识。

    ▐3.4 知识构建要准

    "准"是 Wiki 编译的核心挑战。源材料本身就带噪音——注释长期未更新、文档写错口径、不同来源对同一对象的描述相互矛盾;LLM 生成时存在幻觉,容易把不确定的推断写成确定的事实;像域归属、指标聚类这类判断本身就有一定主观性。仅凭"我们要保证准确"这句口号无法解决,需要一整套覆盖事前、事中、事后的工程纪律:

    • 噪音过滤:分入口和生成两道。入口阶段做粗筛,从源头剔除明显过期、低质量的材料,降低后续编译需要处理的冲突量。生成阶段做细筛,由 LLM 在写 Wiki 时识别并跳过任务代码里的调试残留、文档里的过期片段,不让噪音进入页面正文。

    • 代码即真相:剩下的冲突需要明确的裁决规则。不同来源对同一对象描述不一致时,以任务代码为权威——注释和文档可能长期失修,但任务代码每天实际跑在生产上,代表系统当下的真实行为。这条规则把所有"以谁为准"的争议收敛到唯一答案。

    • 生成与判断分离:LLM 在生成基础 Wiki 时,需要推断的字段强制留空,只写有源材料直接支撑的内容,不允许在生成阶段做主观推断。等所有基础页面生成完,再独立跑一轮判断阶段,基于已写入的内容综合输出候选。判断结果同时经过两道门禁:机械门禁覆盖结构、链接、格式等可机械检查的维度,未通过则阻断发布;人工门禁覆盖域归属、聚类归并这类有主观性的判断,由用户确认。代价是多一轮处理,收益是把"生成"和"判断"两类容易出错的动作彻底解耦。

    • 证据链可追溯:每个页面在 frontmatter 中保留 sources字段,逐项指向具体的源材料(原始 DDL、任务代码、文档片段)。一旦某条信息被怀疑有误,可以立即定位到原材料;用户校验 AI 答案时,也可沿证据链反查依据。可溯源是事后兜底,也是 Wiki 与"凭印象写文档"最根本的区别。

    ▐3.5 知识的骨架是关系

    单页内容解决"一张表是什么",但业务问题往往不是关于一张表——"改了这张表影响哪些下游""这个指标是从哪些表算出来的""这个域下有多少资产"——都是关系层面的问题。如果关系只隐含在正文段落里,每次回答都需要 LLM 重新从文本中抽取,既不稳定也不高效。

    因此我们需要把关系从正文中抽出来,显式存储为图:血缘、归属、消费、引用等语义落到 frontmatter 字段,再由构建流水线统一扫描提取,沉淀为全局关系图。每条边都是结构化的、可遍历的、可计算的。

    显式建图带来三个能力维度:

    • 影响范围可计算:修改一张表后,沿图向下游遍历即可得到完整影响面,不依赖人工记忆。

    • 归属关系可聚合:任何一个域包含哪些表、接口、看板,一次查询完成,支撑全景感知。

    • 枢纽节点可识别:按引用频次(入度)排序,可以快速发现数仓中的公共依赖和关键路径。

    关系图同时也是多路召回的基础——检索命中图上任何一个节点后,可以沿边扩展关联节点,召回关键词未命中但血缘强相关的知识。

    ▐3.6 为检索而组织

    知识的构建和组织不是独立环节,而是为检索服务的。怎么生成页面、怎么划分层级、怎么记录关系,最终都要回答一个问题:AI 在有限的上下文里能否快速找到最相关的知识。围绕这个目标,层级结构和关系图分别承担不同的职责:

    • 知识聚合:把大量Wiki页面按主题进行聚合——字段聚合为指标和维度,表、接口、看板聚合为域,域按业务主题嵌套组织。聚合后,检索面从数百个分散页面收敛到少数几个域入口,AI 和人都能快速定位到目标区域。

    • 渐进式披露:Agent 上下文有限,不可能一次加载全部知识。层级结构天然支持逐层下钻:从全景概览定位相关域,从域定位关键页面,从页面获取字段和逻辑细节。每一层按需加载,在上下文预算内尽可能传递最相关的信息。

    • 多路召回:聚合和渐进式披露解决的是纵向定位——从全局逐层收敛到目标页面。但业务问题往往涉及横向关联:一张表的上游、一个指标的计算依赖、一个域下的全部资产。关系图在这里提供了第二条检索路径——命中一个节点后,沿边扩展到血缘相关但关键词未命中的知识,覆盖单靠文本相似度无法触达的关联页面。

    三者配合:聚合解决信息爆炸,渐进式披露解决上下文有限,多路召回解决召回不全——这是知识库能服务 AI 检索的三个工程支点。

    架构设计

    Wiki 系统以文件为底座,但在功能上构成了一个完整的知识管理系统。其中存储层(多级文件系统)、知识模型层(Schema)、计算层(Agent 编排)是三层主干,后续章节描述的构建、检索、增量、Lint 等流程都基于这三层运行。

    其架构可以与数据库系统做如下类比:

    数据库系统

    Wiki 系统

    对应关系

    存储引擎

    多级文件系统

    知识的物理组织和生命周期管理

    索引

    图索引 + 树索引

    加速检索的辅助结构

    DDL(建表)

    Schema 定义

    定义知识结构和约束

    写表(INSERT/UPDATE)

    Wiki 生成

    按 Schema 写入结构化页面

    查询(SELECT)

    Wiki 检索

    按索引和条件读取知识

    约束检查

    健康检查 + 验证机制

    保证数据一致性和正确性

    事务可恢复性

    断点续传 + 增量构建

    中断后幂等重跑,已有正确产物跳过,只补未完成部分

    执行引擎

    Agent 编排

    调度计算任务,管理并行与串行

    ▐4.1 多级文件系统

    知识库的生命周期跨越多个阶段:清单维护、材料抓取、Wiki 生成、关系图构建、健康检查。每个阶段产出的物料形态不同——清单是输入、原始材料是中间态、Wiki 是最终产出,需要分目录隔离,避免互相污染。多级文件系统的本质是把不同生命周期的物料放进不同目录,由目录承担状态语义。

    知识库根目录由环境变量 KB_ROOT 指定,目录结构如下:

    ${KB_ROOT}/
    ├── pre/                   # 待处理清单 + 临时下载产物(验证后移入 raw/)
    ├── raw/
    │   ├── ready/             # 完整可用,直接进入 Wiki 生成
    │   ├── pending/           # 存在缺失或问题,需治理后晋升 ready
    │   └── archive/           # 已下线或弃用,不治理也不参与生成
    ├── wiki/
    │   ├── tables/{db_type}/  # 表页面,按存储类型分目录
    │   ├── domains/{parent}/  # 域页面,按父域分目录
    │   ├── concepts/          # 概念页面
    │   ├── metrics/           # 指标页面
    │   ├── dimensions/        # 维度页面
    │   ├── dashboards/        # 看板页面
    │   ├── apis/              # 接口页面
    │   ├── datasets/          # 数据集页面
    │   ├── graph.json         # 全局关系图
    │   ├── index.md           # 全局索引
    │   └── overview.md        # 全景概览
    ├── log/                   # 构建日志、域候选、健康检查报告
    ├── tmp/                   # 跨 skill 协作的中间状态
    └── schema/                # 页面模板(5 个,定义 frontmatter 与正文契约)

    按职能可以分两类:

    • 主流程目录承载知识从源到产物的状态流:pre/ 维护待处理清单,并临时承接抓取下来的原始材料,验证通过后移入 raw/;raw/ 按状态分流存放原始材料,供下游编译使用;wiki/ 存放编译完成的结构化页面——清单 → 原始材料 → 结构化页面,三态接力构成完整的主路径。

    • 支撑目录服务于编译过程本身:log/ 提供可观测性(构建日志、健康检查报告),tmp/ 承载跨 skill 协作的中间状态,schema/ 定义页面契约(frontmatter 与正文模板)。两类目录互不干扰,主流程跑通即可对外发布。

    主流程中 raw/ 又进一步细分为三态,承担材料质量的入口保障:

    • ready/:完整可用,直接进入 Wiki 生成。

    • pending/:存在缺失或问题,需经过治理后晋升 ready/。

    • archive/:已下线或弃用,不治理也不参与生成,仅作为历史归档保留。

    Wiki 生成阶段只读 ready/,从源头杜绝低质量材料进入编译流水线,把"材料是否可用"从隐藏字段变成目录归属的物理事实。

    ▐4.2 Schema 即契约

    Wiki 系统中有多个环节需要读写页面:生成器写入、图构建器提取关系、健康检查校验结构、query 检索内容。如果每个环节对"页面长什么样"各有理解,就会出现生成器写了但检查器读不出的状况。Schema 的作用是对所有环节提供唯一的结构约定,类似微服务间的接口协议——生产者按它写,消费者按它读,任何工具用同一个 parser 就能拿到一致视图。

    每个页面是 frontmatter + 正文的双层结构,两者通过 Schema 绑定,形成统一契约。frontmatter 是 YAML 格式的结构化头部,包含共性字段(title、type、description、sources、created、updated 等所有页面都有的字段)和页面特有字段(如 table 的 upstream/downstream/domain/layer,metric 的 computed_by,dashboard 的 uses_datasets 等)。这些字段承载关系和元数据,脚本可直接按字段提取,不需要解析自然语言。

    正文是 Markdown 格式的语义内容,每种页面类型定义了固定的章节模板(如 table 页面包含"业务背景 / 加工逻辑 / 字段说明 / 下游 / 使用建议"五个章节)。正文承载业务背景、加工口径、字段说明这些需要 LLM 理解的内容,供检索和问答使用。

    正文中的 [[表名]] Wikilink 引用是 frontmatter 关系之外的兜底机制。frontmatter 记录的是显式声明的强关系(血缘、归属、消费),Wikilink 覆盖的是行文中提到但未落到字段里的弱关联,图构建器会扫描这些链接生成 wikilink 边,确保关系图不遗漏正文中隐含的引用。

    ▐4.3 Agent 编排:编排层与干活层分离

    Wiki 编译是一个多阶段、多类型的任务:材料预处理、基础页面生成、高阶聚合、图构建、健康检查,每个阶段的输入输出差异大,且 LLM 调用是主要时间瓶颈。如果用一个大 skill 串行处理所有事情,既无法并行加速,也难以独立调试某个阶段的问题。因此系统采用编排层与干活层分离的架构——编排器负责调度和协调,干活的 skill 各自只关心自己那一段的逻辑。

    整个 Wiki 系统由 7 个 skill 组成,编排架构如下:

                   wiki-orchestrator (编排层)
                              │
            ┌─────────┬───────┼───────┬─────────┬──────────┐
            ▼         ▼       ▼       ▼         ▼          ▼
       material   base    advanced  graph    health     query
        -prep   -gen     -gen      -builder  -check
                  (4 子模块)  (3+2 阶段)

    编排层(wiki-orchestrator)只做四件事:意图路由(识别用户在做哪个 Phase)、用户确认(域归属、看板归属、生成范围等关键决策点)、子 Agent 调度(spawn 并行或串行)、结果汇报(聚合各 skill 输出)。它不读原始材料、不写 Wiki 文件、不做 LLM 内容生成——职责严格收敛在"调度"这一层。

    干活层的拆分遵循高内聚、低耦合原则:

    • 高内聚——每个 skill 内部覆盖的所有子任务输入输出来源相同、执行模式相近,整体流程对所有对象类型一致,只在具体实现上按类型差异化(类似代码开发中的抽象接口和具体实现)。例如 wiki-material-prep 内部 5 类对象共用"读清单 → 调元数据接口 → 验证 → 三态分流"流程,wiki-base-generator 内部 4 种页面共用"扫描现状 → 批间串行批内并行生成 → 校验 → 落盘"流程,新增一类对象或页面只需补一个实现模块,流程框架不变。

    • 低耦合——skill 之间不直接调用,仅通过文件系统约定的目录交互(前一个 skill 把产出落到约定目录,后一个 skill 读这个目录),任何 skill 都可以独立运行。

    拆分粒度也由这条原则决定:拆得太细破坏内聚(如把基础生成的 4 种页面拆成 4 个独立 skill,相同的调度框架要重复实现 4 遍);拆得太粗也破坏内聚(如把基础生成和高阶生成合并,但两者输入、依赖、生成方式都不同,合并后内部逻辑异质化、调试困难)。

    基础 Wiki 和高阶 Wiki的拆分正是后一类粒度的边界,是干活层切分中最关键的一刀:

    维度

    基础 Wiki

    高阶 Wiki

    性质

    原子知识单元

    聚合知识单元

    类型

    表、接口、数据集、概念

    域、看板、指标、维度、index、overview

    输入来源

    raw/ready/ 中的源材料

    已落盘的基础 Wiki

    生成方式

    一对一映射(每个对象生成一页)

    多对一聚合(多对象按主题归并成一页)

    依赖关系

    不依赖其他 Wiki

    必须等基础 Wiki 全部落盘

    两者属于天然的两个阶段,分开建模才能让"原子生成"和"聚合归并"各自独立优化、独立调试。

    综合上述拆分原则,干活层的 6 个 skill 各自覆盖编译检索流水线的一个阶段:

    Skill

    覆盖阶段

    职责

    wiki-material-prep

    Phase 0 材料预处理

    维护清单、抓取 DDL 和任务代码、验证分流

    wiki-base-generator

    Phase 1 基础生成

    生成表、接口、数据集、概念四种基础页面

    wiki-advanced-generator

    Phase 1 高阶生成

    生成域、看板、指标、维度、index、overview

    wiki-graph-builder

    Phase 1 图构建

    扫描 frontmatter 和 Wikilink,沉淀关系图

    wiki-health-check

    Phase 2 健康检查

    执行结构、链接、格式等多项校验

    wiki-query

    运行时检索

    检索页面、查询血缘、关键词搜索

    每个 skill 只关心自己的输入输出契约,不感知其他 skill 的内部实现。

    以上拆分(编排/干活两层 + 干活层 6 个 skill)共同带来三个收益:

    • 可并行:LLM 调用是主要时间瓶颈,分离后凡是数据不依赖的步骤都可以 spawn 子 Agent 并行执行(如基础生成的批内并行、高阶生成的"域 + 看板 + 指标维度"三路并发),编译耗时显著下降。

    • 可独立调试:某个阶段出错时只需重跑对应的 skill,不必从头走完整流水线。每个 skill 内聚度高,输入输出边界清晰,问题定位成本低。

    • 可单独复用:任何 skill 都可以脱离编排器独立调用——比如只跑健康检查验证现有 Wiki、只跑 query 做检索,不必触发完整构建。

    知识编译流水线

    编译流水线分为三阶段——Phase 0 材料预处理、Phase 1 Wiki 生成(基础生成 + 高阶生成 + 图构建)、Phase 2 健康检查。每个阶段都有明确的输入、输出和处理逻辑,下面依次展开。

    ▐5.1 Phase 0:材料预处理

    Phase 0 负责把源材料从外部系统抓取下来,经过验证和分流,作为 Phase 1 编译的输入。

    流程分为五步:

    1. 用户提供 5 类对象清单(表、任务、看板、接口、文档)。

    2. LLM 解析清单内容并写入对应的 CSV 文件。

    3. 脚本根据清单批量调用元数据接口抓取 DDL、任务代码、看板配置、接口配置、文档原文。

    4. 脚本验证每个对象的材料完整性。

    5. 按结果三态分流到 raw/ready/、raw/pending/、raw/archive/。

    其中 LLM 仅在第二步介入(把自然语言输入转为结构化清单),其余环节都是确定性脚本。

    Phase 0 在设计上有三个关键考量:

    • 全脚本化执行:抓取、验证、分流是确定性逻辑,不依赖 LLM——避免了幻觉风险,结果可重放可复现,且不消耗 token。Phase 0 处理的是机械性高、判断性低的任务(抓 DDL、对账、移文件),脚本化是更合理的选择。

    • 脚本验证前置:材料抓取后并不直接进入 ready,必须先经过完整性校验(如表必须同时有 DDL 和任务代码、命名规范、内容非空),未通过的进入 pending 等待治理。质量门禁前置在入口,避免噪音材料污染后续编译。

    • 支持断点续传:抓取大批材料时网络异常或接口限流难以避免,断点续传可以从上次中断位置继续,不必重头抓所有对象——这是整体架构"事务可恢复性"在 Phase 0 的具体落点。

    完成后等待用户确认材料的分流决策,确认通过后进入 Phase 1 基础生成。

    ▐5.2 Phase 1 基础:基础 Wiki 生成

    Phase 1 基础阶段负责把 raw/ready/ 中的源材料编译为 4 种基础 Wiki 页面——表、接口、数据集、概念。

    流程分为三步:扫描现状(对比已有 Wiki、新增材料、sources 一致性,确定本次需要生成、修复、跳过的对象集合);按"批间串行、批内并行"的策略生成基础 Wiki 页面(含 frontmatter + 正文);所有页面生成完毕后跑一轮统一校验,未通过的标记重生成。基础 Wiki 落盘后再独立执行域候选判断,输出候选列表供用户确认,回填 domain 字段。

    基础 Wiki 生成阶段有四个关键设计:

    • 批间串行、批内并行:每批 5 个对象,批内 spawn 5 个独立子 Agent,每个子 Agent 只读自己那张表的源材料、独立生成。这种切分有两层价值——一是并发提速,5 路并行明显快于串行;二是上下文隔离,每个子 Agent 的 LLM 上下文只承载一个对象的信息,避免多对象拼接时 LLM 张冠李戴的幻觉。批的大小(5)是平衡 LLM 配额、错误恢复成本、并发收益的工程折中。

    • 生成完后统一校验:所有基础 Wiki 生成完毕后,由验证脚本统一校验产出页面——frontmatter 字段是否符合 Schema 约束(必填项齐全、枚举值合法、类型正确),正文表结构列出的字段是否真实存在于 DDL(防止 LLM 幻觉出不存在的列)。校验未通过的页面会被标记重生成。这是页面级的字段一致性校验,与 Phase 2 全局健康检查互为前后两道关卡。

    • 生成与判断分离:基础生成阶段 domain 等需要推断的字段一律留空,避免 LLM 在尚未掌握全局信息时做主观判断;所有基础页面落盘后再独立跑判断阶段,基于已写入的内容综合输出候选,由用户确认后回填——具体见 3.4。

    • 增量感知:扫描现状后只对真正发生变化的对象(新增材料、sources 不一致)触发生成,已有且一致的页面跳过。这是 Wiki 长期维护成本可控的前提。

    基础 Wiki 落盘后,进入高阶聚合阶段。

    ▐5.3 Phase 1 高阶:高阶 Wiki 生成

    Phase 1 高阶阶段把已落盘的基础 Wiki 按业务主题聚合,产出 6 种聚合页面:域、看板、指标、维度、index、overview。

    整个过程由一条 DAG 驱动——一阶段三路并行,二阶段串行汇聚:

    • 一阶段(三路并行):

      • 域页面:从基础 Wiki 的 domain 字段反查抽出域列表,按层级生成 domains/{parent}/{leaf}.md。

      • 看板页面:基于数据集 Wiki 生成,对每个看板的域归属生成候选由用户确认。

      • 指标与维度:脚本字段聚类 → 子 Agent DWD 分析 → 用户确认归并 → Wiki 生成 → 脚本一致性校验五个步骤。

    • 二阶段(串行汇聚):必须等一阶段就绪才能跑。

      • index.md:每个一级域并行写章节,再合并为全局索引。

      • overview.md:基于域页面 + 表 frontmatter 产出全景概览。

    这条 DAG 的蕴含两层设计意图:

    • 并发最大化:阶段三路无依赖的步骤齐头并进,二阶段有依赖的步骤等齐再跑,在依赖约束下尽量挖出并发收益。

    • 关键节点嵌入审核:看板的域归属、指标维度的聚类归并以及一致性校验都嵌在 DAG 节点中,由用户确认或脚本兜底,而不是事后补丁,把"机器无法独自判断"和"机器可机械验证"两类工作显式纳入流程。

    高阶页面之所以能这样组织,关键在于聚合靠 frontmatter 字段反查。域页面、指标页面的内容来自基础 Wiki 的 frontmatter 字段聚合(如域页面列出"我下面有哪些表"是反查所有 domain 字段指向自己的表),不需要重新解析正文。这正是 4.2 frontmatter 设计的直接收益——单页关系字段化让跨页聚合可以低成本完成。

    至此基础和高阶 Wiki 全部落盘,关系字段已就位,下一步进入图构建。

    ▐5.4 Phase 1 链接:图构建

    Phase 1 链接阶段产出全局关系图 graph.json,由节点和边两部分组成。节点对应每个 Wiki 页面(不存储冗余信息,节点详情按需从对应页面 frontmatter 读取),共 8 种类型:

    节点类型

    路径前缀

    table

    tables/{db_type}/

    domain

    domains/{parent}/

    concept

    concepts/{business|tech}/

    metric

    metrics/{business_process}/

    dimension

    dimensions/

    dashboard

    dashboards/

    dataset

    datasets/

    api

    apis/

    边是页面之间的关系,共 8 种正向边,按语义分四类:

    边类型

    含义

    方向

    来源字段

    has_upstream

    ODPS 离线血缘

    当前表 → 上游表

    upstream(task_type=odps)

    syncs_from

    同步任务血缘

    当前表 → 来源表

    upstream(task_type=sync)

    writes_from

    Flink 实时血缘

    当前表 → 来源表

    upstream(task_type=flink)

    belongs_to

    归属关系

    表/接口/看板/子域 → 父域

    domain / parent

    computed_by

    指标/维度来源

    指标/维度 → 表

    computed_by

    uses

    看板使用

    看板 → 数据集

    uses_datasets

    queries

    接口/数据集查询

    接口/数据集 → 表

    queries_tables

    wikilink

    兜底引用

    引用页 → 被引页

    正文 [[...]]

    图的构建过程:扫描所有 Wiki 页面目录,提取每个页面的 frontmatter,按字段映射到 8 种边类型——例如表的 upstream 字段产生血缘类边(具体类型由 task_type 决定),看板的 uses_datasets 字段产生 uses 边。整个过程由脚本完成,不依赖 LLM。

    图构建完成后会反哺 Wiki:基于血缘类正向边反向计算每张表的下游列表,回填到 frontmatter 的 downstream 字段。只读 Wiki 不读图的工具也能直接拿到下游信息,避免轻量消费场景强制依赖 graph.json。

    "只存正向边 + 反向按需 + 回填关键反向字段 + 文件存储"带来了三个收益:

    • 存储与一致性——反向边信息完全冗余于正向边,存两份必然带来双向同步的一致性负担。只存正向边将存储减半,一致性问题随之消失;运行时需要反向访问时按需构建索引,开销可控(O(E))。

    • 消费灵活性——图供需要全局遍历的场景使用(多跳血缘、影响范围分析),反哺到 frontmatter 的 downstream 供只看单页的轻量场景使用,两类消费方各取所需。

    • 轻量化——关系图以单个 JSON 文件(graph.json)存储,无需部署和维护图数据库,任何工具直接读取,可随代码仓库版本管理,适合当前规模的知识库。

    编译产出已完整,最后一步是健康检查兜底。

    ▐5.5 Phase 2:健康检查

    Phase 2 健康检查是编译流水线的最后一道质量门禁,对编译产物做全局对账,决定本次构建是否对外发布。

    健康检查覆盖结构和格式两类维度,共 6 项:

    检查项

    检查内容

    数量一致性

    DDL、Wiki 页面、graph.json 节点三方对账,确保对象数量对齐

    结构完整性

    按页面类型校验 frontmatter 字段集(必填项齐全、类型正确、枚举值合法)

    链接有效性

    Wikilink 断链检测、孤岛页面检测(无入边的页面)

    Domain 格式

    域字段是否符合层级正则(一级域/二级域/...)

    YAML 语法

    graph.json 和所有页面 frontmatter 的 YAML 语法合法性

    Graph 完整性

    节点路径合法、边类型在白名单、边两端节点存在

    任意一项检查未通过都视为本次编译失败,输出诊断报告到 log/wiki-health-check-{timestamp}.md,标记具体不通过的对象和原因,未通过的编译产物不对外发布。

    健康检查与流水线前序阶段构成两道校验关卡:5.2 的"生成完后统一校验"是页面级、生成时的字段一致性检查(如表结构列出的字段是否真实存在于 DDL),5.5 是全局、构建后的对账与契约检查(如 Wiki 总数与 DDL 数量、graph.json 的边是否都连接到合法节点)。两者互补——前者保证单页正确,后者保证整体一致,共同实现 3.4 提出的"正确性可度量"和 4.2 提出的"Schema 即契约"在流水线层面的兜底。

    健康检查通过后,本次编译产出对外发布,一次完整的 Wiki 编译流水线结束。

    知识检索

    检索是 Wiki 的最终消费场景,前面的构建和组织最终都要服务于它。前面已经从构建侧给出了"为检索而组织"的设计原则——聚合、渐进式披露、多路召回。从查询侧看,完整的检索栈分为三步:意图识别、多路召回、重排序输出。

    ▐6.1 意图识别

    任何一次查询请求进入检索前,先做意图识别,按查询特征分为三类:

    • 精确查询:用户给出明确实体名(表名、域名、指标名)。直接读取目标页面的详情和血缘即可,无需召回环节。

    • 关系查询:实体名 + 方向词(上游、下游、影响、归属)。直接走关系图遍历,沿对应方向边扩展。

    • 模糊搜索:关键词、业务概念、筛选条件。需要走多路召回 + 重排序的完整链路。

    模糊搜索之前强制做域推断:先读 index.md,根据用户关键词的语义匹配相关域(同时考虑生产方域和消费方域),将搜索范围从全库收敛到 2~3 个相关域。这一步不可跳过——它在召回阶段就把搜索空间大幅缩小,是后续召回质量的前提,也是 3.6 渐进式披露原则在检索侧的直接落地。

    ▐6.2 多路召回

    模糊搜索的核心是基于域、关键词、图的多路召回,分两阶段执行。

    阶段一:缩小范围并生成候选——两路并行。域召回:基于 index.md 推断出的相关域,读取对应的域页面,召回域下挂载的相关表,用业务主题做硬过滤。关键词召回:在 frontmatter 字段和正文上做加权关键词匹配,按字段重要性分配权重(标题、描述、域、上下游等结构化字段权重高于正文),输出按 score 排序的候选集;当用户提到具体字段名时退化为精确匹配。两路并行执行,一个走层级一个走文本,从不同维度切入相同的搜索空间。

    阶段二:图扩展——基于阶段一命中的候选表,沿关系图的血缘边向上下游扩展,把"用户搜了 ADS 表,但答案在它的 DWS 上游"这类跨节点场景兜进来。

    阶段一和阶段二的产出合并去重,输出 4~6 张候选表交给精排。这种两阶段的设计——先用层级和关键词从全库收敛到候选集,再用图扩展补全血缘相关知识——同时利用了 3.6 中树(聚合)和图(多路召回)的两类组织能力。

    ▐6.3 重排序输出

    重排序分粗排和精排两步。粗排由脚本完成:基于关键词命中权重和通用性指标计算 score,按分排名输出 4~6 张候选表;脚本不做语义判断,只用确定性规则做初筛。精排由 LLM 完成:对粗排输出的每张候选表逐一读取详情(frontmatter + 正文),判断它是否真正满足查询需求。

    精排有一条硬约束:LLM 必须对每张候选表都读详情,不允许在前几张匹配度高时提前停止。靠后的候选可能因为通用性、覆盖度更高而成为最终推荐,跳过详情读取就无法识别这种情况。

    精排基于三个维度:

    • 覆盖度:表的实际字段和数据是否覆盖用户需求。LLM 读取页面详情后判断,不依赖关键词命中位置。

    • 相关性:表的主题与用户搜索意图的语义贴合度。

    • 通用性:被大量下游消费的表,作为数仓中"汇聚消费方"的枢纽表。

    通用性单独成维的设计是为了对抗数仓中的重复建设——一张被广泛使用的表如果用户不知道,往往会另建一张高度相似的表,长期累积形成数据负债。把通用性显式纳入排序维度,让用户在检索时能感知到现有的公共依赖,资产复用率自然提升。

    排序逻辑分两层:覆盖度是硬门槛——不满足用户需求的表直接淘汰,无论其他维度多突出。在覆盖度合格的候选中,LLM 根据查询意图综合权衡相关性和通用性——查询意图明确具体时(如"我要查某个特定指标"),相关性优先;查询意图偏探索时(如"这个域有哪些常用表"),通用性优先。最终输出最推荐表 + 候选列表 + 血缘链路。

    整条检索链——意图识别按查询类型路由,多路召回利用树和图同时从层级和关系两个维度收敛候选,重排序由 LLM 在结构化候选上做最终判断——是前面"为检索而组织"在查询侧的具体落地,也是构建阶段所有结构化投入(Schema、关系图、域树)的最终消费场景。

    增量编译与持续 Lint

    知识库不是一次性建完就锁起来的——它每天都在变。新表上线、口径调整、任务代码迭代都会让源材料变化,如果每次变更都全量重建,LLM 成本和构建时间都不可接受。增量编译的目标是让构建成本只和变化量相关,而不是和总规模相关:未变化的部分跳过,变化的部分按依赖关系局部重跑。

    增量识别的关键是扫描现状对账。每次构建前先比对三方状态:

    • 源材料目录:新增、删除、内容变化。

    • 已有 Wiki 页面:已落盘的结构化页面集合。

    • Wiki 中记录的 sources 字段:页面引用的源材料路径。

    差异决定本次需要触发哪些阶段的子集执行——这部分逻辑已在 5.2 基础生成的"扫描现状"环节落实,增量编译沿用同一套对账机制。

    增量编译可以覆盖三类典型场景:

    • 新材料入库:新表或新接口加入清单。材料预处理拉取新增对象的源材料,基础生成只为新增对象产出 Wiki(已有页面不动),域判断只对新增对象做归属候选,最后图构建做一次全量重建(开销 O(E),相对生成阶段可忽略)。

    • 知识腐化更新:上游 DDL 或任务代码变更,对应 Wiki 已与源材料不一致。重新跑材料预处理和基础生成覆盖更新对应页面,再触发图构建重建并自动回填 downstream,最后跑健康检查确认整体一致性。

    • 结构性修复:某次构建留下少量校验失败的页面,或某条规则升级后存量页面不合规。直接调用对应阶段(基础生成 / 高阶生成 / 图构建)局部重跑相关页面,不必从材料预处理开始重走全程。

    Lint 是把健康检查从"构建后一次性兜底"扩展为"持续性质量巡检"。健康检查的 6 项规则(数量一致性、结构完整性、链接有效性、Domain 格式、YAML 语法、Graph 完整性)作为知识库的 Lint 规则集,每周或在重大变更后定期跑一次,发现断链、孤岛、格式退化、节点冗余等问题;不通过的项进入治理待办,由对应阶段触发增量重生成。Lint 让知识库的健康度从"构建时合格"变成"持续合格",与第三章 3.4 提出的"正确性可度量"形成构建期 + 运维期的双重保障。

    总结

    一句话:用 LLM 编译思维替代人工写 Wiki,把散落的源材料编译成结构化、有约束、可验证的知识资产。

    这套实践由几条相互支撑的设计决策构成:源材料用代码即真相做仲裁,解决多源冲突;生成阶段坚持生成与判断分离,让 LLM 不做主观推断;产出经过结构、语义、人工三层校验,使正确性可度量;所有页面遵循Schema 即契约,跨工具消费时按字段直接读取;页面之间的关系显式存储为图,业务主题聚合为树并支持渐进式披露,Agent 在有限上下文里也能高效消费;编排和干活分层协作,高内聚、低耦合,让流水线可并行、可调试、可单独复用。

    回到开篇——领域知识决定了 AI 在业务中能发挥多大价值,而它只能从内部积累,无法从外部获取。LLM Wiki 提供的是一套系统化的沉淀方法:把散落、矛盾、易腐化的领域知识编译为结构化、可验证的知识资产。这是 AI 时代最值得长期投入的基础设施。

    未来规划

    • 扩展知识来源:把任务清单、看板清单从预留转为正式落地,接入实时表和外部数据源。

    • 准确性保障:保障 Wiki 准确性、检索准确性、生码准确性,强化验证机制。

    • 一致性保障:知识库内部跨Wiki的一致性。

    • 检索性能优化:在关键词召回基础上引入向量检索作为补充,改进混合检索机制,实现检索效率提升。

    • 知识保鲜:建自动化的源材料变更检测和重新编译机制,上游 DDL、任务代码、文档发生变化时主动触发对应 Wiki 的增量更新,避免知识库滞后于真实业务系统。

    • 建立评测体系:建自动化评测 benchmark(查询准确率、召回率、答案满意度),每次构建后自动跑回归,让"准不准"有可量化的指标,形成持续改进闭环。

    跳转微信打开

    •  

    Skill 自进化:基于执行轨迹与评测反馈的多代优化实践

    原创 营销&交易技术 2026-11-13 15:09 浙江

    让 Skill 自己“卷”自己,越改越聪明。

    图片

    业务 Skill 的一次修复,往往从一个失败 Case 开始:看执行过程、找到遗漏的规则、修改 SKILL.md,再跑一遍评测。随着业务场景增加,这种方式会遇到两个问题:修好一个场景时可能破坏另一个场景;连续多次修改后,很难判断哪个版本更好,以及收益来自哪条规则。

    我们尝试把这个过程组织为可追溯的搜索闭环:用黄金评测集、Ground Truth 和执行轨迹生成反馈,让模型提出受控修改,再通过全量评测决定是否保留。模型负责提出候选,确定性程序负责边界校验、版本比较和状态维护,人负责业务边界与最终交付。

    本文结合业务 Skill 工作台的 Skill 自进化设计,依次介绍方法选择、全局流程、候选池、Module 划分和归因变异提示词。文中的算法与配置保留到可讨论、可实现的粒度,同时说明当前实现与完整设计之间的边界。

    图片

    方法选择:为什么采用 GEPA 的

    反思搜索思路

    我们选取四篇 Agent/Skill 自进化相关论文,结合已有黄金集、Trace 和 rubric 链路做横向对比。对比的重点是优化信号、编辑范围、候选验证和工程适配;各论文的实验收益不能直接当作本项目的业务收益。

    GEPA ✅

    SkillOpt

    EvoSkill

    Trace2Skill

    方法

    基于执行轨迹与自然语言反馈反思并提出候选,搜索和利用具有互补能力的版本;本项目进一步采用逐 Case 比较与全局候选池

    以受控的增删替换编辑更新 Skill,使用文本学习率预算、拒绝编辑记录和独立验证分数约束优化

    Executor、Proposer、Skill-Builder 三个角色分工:执行任务、诊断失败、生成或修改 Skill,再通过验证选择候选

    批量收集执行轨迹,分别分析失败与成功经验,提出局部补丁,再分层合并为一致的 Skill 更新

    优势

    轨迹反思与现有 Ground Truth、rubric、Trace 链路适配;可以搜索不同 Case 上的互补优势。本项目 MVP 先收敛到 SKILL.md

    改动受控,不容易把 SKILL.md 越改越长、越改越差

    角色职责清楚,支持生成结构化 Skill 文件夹及辅助脚本,修改可追溯

    批量分析与补丁合并便于利用大量已有轨迹,适合沉淀初版 Skill 或做批量增强;实际速度取决于并发与数据量

    劣势

    每个新版本都要在验证 case 上重新评测,耗时较长

    需要额外维护编辑预算、训练与验证组织、拒绝历史及慢更新机制;是否值得引入要结合本项目预算测量

    多角色编排和 Skill 文件夹生成增加工程复杂度;论文实验使用 Claude Code,但框架并不只限定该环境

    核心是批量轨迹分析与合并,并非本文的候选评分搜索循环;若要多代搜索,需要增加候选验证与选择编排

    选择 GEPA 思路,主要因为我们已经具备黄金评测集、标准答案、完整执行轨迹和结构化评分,可以复用这些资产建立反思与验证闭环。同时,候选池能够保留不同 Case 上的局部优势,避免搜索过早收敛到单一版本。

    需要区分论文方法与项目实现:本文的单 Module 修改、每个候选全量评测、直接父子入池规则和确定性贪心覆盖,是结合业务约束形成的 GEPA-style 工程设计,不全部等同于原论文的固定规则。

    技术设计:从一次修改到多代搜索

    ▐2.1 全局流程

    整体流程沿用 GEPA 的核心思想:以黄金评测集上的评测结果和执行轨迹为原始信号,先生成逐 Case 反思反馈,再由反思、归因并产生变异,通过多轮“选择—反馈生成—反思变异—全量评测—择优保留”持续搜索更优的 Skill 版本。进化期间冻结黄金集、Ground Truth、rubric 身份、模型和执行配置,让各版本尽可能在同一口径下比较。服务端动态数据与模型随机性仍需通过运行证据和复测披露,不能仅凭配置冻结就认为所有波动已经消失。

    整体流程分为以下步骤:

    1. 进化准备:确定本轮要优化的 Skill,冻结黄金评测集、评测标准、执行模型、工具与运行环境,并设置最大生成轮次与子候选评测预算,完成 Module 人工审核。基线评测与模型反思成本应另行记录。

    2. 初始版本全量评测:使用当前 Skill 并发运行全部黄金 case,记录每个 case 的执行轨迹和结构化评测结果,包括总分、逐维度得分、原子问题答案及判分证据,形成版本比较的基线。评测阶段本身不生成面向 Skill 优化的反思反馈。

    3. 选择父版本:从当前已经保留的版本中选择一个父版本,作为本轮继续探索的起点。父版本已有的全量评测产物直接复用,无需重复运行。

    4. 生成反思反馈:读取父版本的逐 case 执行轨迹和结构化评测结果,并结合黄金评测期望,生成供反思 LM 使用的逐 case 反思反馈。该反馈是自进化流程根据评测产物生成的派生数据,不是现有评测系统直接保存的字段。

    5. 反思与生成子版本:基于逐 case 反思反馈进行归因,生成一个新的子 Skill 版本。本步骤只负责提出一次定向变异。

    6. 有效性校验与隔离部署:确认子版本结构完整、能够被正确加载和执行,然后部署到隔离的评测环境,避免影响当前正式版本。

    7. 子版本全量评测:对新子版本并发运行全部黄金 case,得到与父版本口径完全一致的逐 case 分数、执行轨迹和结构化判分结果。评测完成后不立即额外生成反馈;该版本后续被选为父版本时,再进入反馈生成步骤。

    8. 父子入池判定:比较子版本与直接父版本的逐 Case 分数,不比较全量平均分。若父版本在所有 Case 上均不差于子版本,并且至少在一个 Case 上严格优于子版本,则父版本严格支配子版本,子版本不进入候选池;若子版本支配父版本,或二者互不支配,则子版本进入候选池。父子逐 Case 分数完全相同时,视为无有效提升,子版本不入池。无论是否入池,都记录本轮变异、父子关系、评测结果和判定原因,保证过程可追溯。

    9. 更新并继续迭代:子版本通过父子入池判定后,加入全局候选池。若预算尚未耗尽,则在下一轮开始时基于全局候选池重新计算逐 Case 领先候选的活动前沿,并从活跃前沿中选择新的父版本;否则结束搜索。候选即使已经入池,后续被其他候选严格支配时,也不会进入活跃前沿和父版本采样范围,但其版本及评测记录仍保留在候选池中。

    10. 最终版本确认与发布:搜索结束后,从全部已保留版本中选出黄金评测集平均得分最高的版本,完成规范检查并输出版本差异和进化报告。搜索结束先恢复评测空间种子版本,报告进入最终评审。经人工确认与规范检查后写回目标 SKILL.md,发布、提交和代码评审按独立流程执行。

    ▐2.2 候选池设计

    候选池采用“全局保存、动态选优”的设计:

    数据集合

    含义

    是否参与父代采样

    全局候选池

    种子版本及所有通过入池判定的子版本

    只有进入活动前沿后才参与

    活动前沿

    当前在不同 case 上具有领先能力的候选

    参与

    失败尝试集

    校验失败、评测失败或未通过入池判定的子版本

    不参与

    当前冠军

    全局候选池中全量平均分最高的候选

    仅用于最终选优

    其中,t 表示当前迭代轮次。活动前沿是从全局候选池计算得到的临时结果,用于探索而不直接代表上线资格。候选即使没有进入本轮活动前沿,也不会从全局候选池中删除。

    • 候选数据结构

    每个入池候选至少记录以下信息:

    字段

    含义

    candidate_id

    候选唯一标识

    parent_candidate_id

    直接父版本标识

    artifact_ref

    候选 SKILL.md 的位置;与冻结的完整 Skill 目录组合还原制品

    content_hash

    候选内容摘要,用于身份校验和去重

    case_scores

    全部黄金 case 的逐 case 分数

    mean_score

    全部黄金 case 的平均分

    evaluation_manifest_ref

    对应评测 manifest,由它定位 Trace、结构化判分和报告

    feedback_ref

    生成该子版本所使用的反思反馈

    diff_ref

    子版本相对父版本的修改内容

    admission

    入池结果、比较对象和判定原因

    deploy_receipt_ref

    部署回执,记录空间、Skill 版本及制品 hash

    target_module

    本轮修改的唯一目标 Module

    一次进化任务需要冻结黄金 Case、rubric、执行模型与执行配置,并记录 Judge 和服务端运行身份。候选身份要贯穿部署与真实执行证据。当前实现固定了 rubricId 与 contentMd5,但不能把它等同于所有在线依赖都已被冻结。

    • 入池规则

    子版本完成全量评测后,只与它的直接父版本比较,不与全局候选池中的其他版本做入池判定。这样既能解释一次变异的效果,也能保留互补能力;后续父代采样再由全局候选池的活动前沿决定。

    设:

    :黄金 case 总数;

    :黄金 case 的序号;

    :父版本;

    :子版本;

    :父版本在第 个 case 上的分数;

    :子版本在第 个 case 上的分数。

    父版本严格支配子版本的条件为:

    字符含义:

    字符

    含义

    ≻

    左侧候选严格支配右侧候选

    ∀

    对所有 case 都成立

    ∃

    至少存在一个 case

    ∈

    属于某个集合

    ≥

    大于或等于,即不差于

    >

    严格大于

    ∧

    左右两个条件同时成立

    {1,…,N}

    全部黄金 case 的序号集合

    实际连续分数比较使用 epsilon=1e-6:不差于允许 epsilon 容差,严格更优需超过 epsilon;全部差异在容差内视为同分。下表给出入池结果:

    父子关系

    处理结果

    父版本严格支配子版本

    子版本不入池

    子版本严格支配父版本

    子版本入池

    父子互不支配,各自有更优 case

    子版本入池

    父子所有 case 分数完全相同

    视为无有效提升,子版本不入池

    子版本内容与已有候选完全相同

    根据 content_hash 去重,不重复评测和入池

    因此,入池规则保留两类版本:整体优于父代的版本,以及虽然没有整体提升、但在部分 Case 上产生新优势的版本。后者可能包含局部回退,最终交付必须披露这些回退,不能把入池当成无回归保证。

    • 活动前沿计算

    每轮开始时,基于全局候选池 重新计算活动前沿。

    符号说明

    字符

    含义

    第


     轮开始时的全局候选池

    c

    全局候选池中的任意候选

    i

    某一个黄金 case

    候选 c 在 case i 上的分数

    case i 在全局候选池中的最高分

    case i 的领先候选集合

    候选 c 所领先的 case 集合

    第 轮的活动前沿

    Pt

    候选 c 的采样权重

    候选 c 被选为父代的概率

    第一步:找出每个 case 的最高分

    对于每个 case  ,在全局候选池中找到最高分:

    第二步:找出每个 case 的领先候选

    所有在 case   上达到最高分的候选组成集合  :

    允许多个候选并列第一。

    第三步:用确定性贪心覆盖收敛候选集合

    定义候选 c 所领先的 case 集合:

    候选没有领先任何 Case 时,不进入活动前沿。对于存在重叠覆盖的候选,需要定义确定性处理顺序,避免同样的分数矩阵产生不同结果:

    1. 初始化未覆盖集合为全部 Case。

    2. 选择覆盖最多未覆盖 Case 的候选。

    3. 覆盖数并列时,依次优先均分更高、最差 Case 分更高、创建更早和 ID 字典序更小的候选。

    4. 从未覆盖集合中移除已覆盖 Case,重复直到全部 Case 都被覆盖。

    这个过程保留了逐 Case 领先能力,避免冗余候选都参与采样。它是贪心覆盖,不保证候选数最少,也不等于完整 Pareto 非支配集。

    第四步:加权采样父代

    完成覆盖选择后,入选候选构成活动前沿  。候选的采样权重等于其领先的 case 数量:

    父代采样概率为:

    采样权重使用候选在全局池中的全部领先 Case 数,不只统计贪心选择时新覆盖的 Case。随机种子与随机步数保存到任务 manifest,便于恢复时复现选择。

    其中,表示活动前沿中的任意候选。一个候选领先的 case 越多,被选为下一轮父代的概率越高。

    • 计算示例

    假设全局候选池包含 A、B、C、D 四个候选,黄金评测集包含三个 case:

    候选

    Case 1

    Case 2

    Case 3

    平均分

    A

    1.0

    0.6

    0.3

    0.63

    B

    0.7

    1.0

    0.4

    0.70

    C

    1.0

    1.0

    0.5

    0.83

    D

    0.8

    0.7

    0.9

    0.80

    对于 Case 1:

    对于 Case 2:

    对于 Case 3:

    因此,每个候选领先的 case 为:

    候选

    领先的 case

    A

    Case 1

    B

    Case 2

    C

    Case 1、Case 2

    D

    Case 3

    A 领先的 Case 1 已经可以由 C 覆盖,B 领先的 Case 2 也可以由 C 覆盖,因此 A、B 本轮不进入活动前沿。最终活动前沿为:

    候选 C 领先两个 case,候选 D 领先一个 case:

    因此:

    D 的平均分虽然低于 C,但它在 Case 3 上具有独立优势,因此仍然保留继续进化的机会。

    • 数据维护

    • 全局候选池只追加,不修改或删除已入池候选;

    • 新候选入池后,更新逐 case 分数矩阵;

    • 每轮开始时,根据最新分数矩阵重新计算活动前沿;

    • 当前冠军从全局候选池重新计算,不限定在活动前沿中;

    • 执行轨迹、结构化判分结果和 Skill 快照只保存引用,避免重复存储。

    被父代占优的子版本不进入全局候选池,但保留一条失败尝试记录,包括父版本、内容摘要、修改差异、逐 case 分数、淘汰原因和评测产物引用。这些记录用于避免重复修改、分析退化原因和排查评测异常,但不会参与后续父代采样。运行状态还需保存预算计数、随机步数和待完成轮次;只保存候选列表不足以支持可靠恢复。

    • 最终版本选择

    活动前沿只用于选择下一轮父代。搜索结束后,最终版本仍从全局候选池中按照全量平均分选择。

    候选 c 的全量平均分为:

    最终版本为:

    其中,表示搜索结束时的全局候选池,arg max 表示使平均分取得最大值的候选。父代选择强调不同 Case 上的能力多样性,最终选优则选择整体平均表现最好的版本。

    实现对均分使用 epsilon 量化排序,再按最差 Case、通过 Case 数、修改行数和创建顺序等规则确定唯一结果。最终报告应统一修改量口径:当前代码统计相对直接父代的行数,而相对种子的累计差异更适合评估最终交付影响,这一口径尚需对齐。

    同一黄金集用于反思和选冠军时,均分提高首先说明搜索集上的改进。独立保留集应不进入反思与变异输入,用于最终验证泛化能力。

    ▐2.3 Skill Module的设计

    借鉴 GEPA 的模块化优化思想,我们将候选 SKILL.md 拆分为多个可独立优化的业务 Module,每轮只选择其中一个 Module 进行反思和变异,其余内容保持不变。

    • Module 划分方法对比

    整体作为单一 Module

    按文档固定章节划分

    按 Skill 内部业务能力划分✅

    划分方式

    整份 SKILL.md 作为一个 Module

    按输入、流程、约束、输出等章节划分

    每个可由一类用户意图独立触发、具有独立执行流程和输出规则的业务能力作为 Module,公共规则单独划分

    优点

    实现简单,不需要额外配置

    边界清晰,适合结构统一的 Skill

    与评测 case 和失败归因更容易对应,变异范围较完整

    缺点

    每次改动范围过大,容易修复一个场景却破坏其他场景

    依赖统一的章节结构;Skill 的章节组织并不完全一致,而且同一业务能力可能分散在多个章节中,通常仍需逐个 Skill 配置。

    需要为每个 Skill 建立一次 Module 配置

    • Module 结构

    一份 SKILL.md 按实际内容划分成下列 Module,不要求包含全部类型:

    Module 类型

    默认是否允许自动进化

    使用说明

    routing

    是

    路由遗漏或错误分流时修改

    capability.<name>

    是

    主要进化对象;评测 case 应尽量映射到一个具体 capability(具体业务能力)

    shared.response

    是

    输出时共用的规则/模板

    shared.boundaries

    是

    失败归因指向边界判断时修改

    shared.guardrails

    否

    权限、安全、合规和不可逆操作确认等硬性保护规则

    以 query-object-ranking 为例,它包含 TOP 排名和指定对象查询两个可以独立归因、独立修改的业务能力:

      routing
      capability.object_ranking
      capability.object_detail
      shared.response
      shared.boundaries

      Module

      对应 SKILL.md 内容

      职责

      典型失败

      routing

      frontmatter 的 description、触发条件和 Step 0

      识别排名查询或指定对象查询,并选择对应模式

      排名请求未触发,或对象查询被分到排名模式

      capability.object_ranking

      Step 1.2,以及 Step 2~Step 4 中 TOP 排名模式的规则和输出

      选择分析任务,查询并输出对象 TOP 排名

      多任务时未让用户选择,或排名结果输出错误

      capability.object_detail

      Step 1.1,以及 Step 2~Step 4 中单对象模式的规则和输出

      按名称或编号查询指定对象,并合并多个数据分组的数据

      单对象查询被输出成 TOP 榜单,或多个数据分组未合并

      shared.response

      两种模式共同遵守的 Markdown、表格和数值展示规则

      保证公共输出格式一致

      表格格式错误或公共字段遗漏

      shared.boundaries

      不适用场景、对象名称与类别混淆处理及共用异常规则

      区分对象查询与类别、分组、目标、归因等其他维度

      类别或分组查询错误进入本 Skill

      从能力划分看,“哪些对象的待处理记录最多”对应 capability.object_ranking;“查一下示例对象 A 的示例指标”对应 capability.object_detail。该 Skill 不包含权限、安全或不可逆操作,因此不需要强行增加 shared.guardrails。该示例用于说明业务边界;是否能启动自动进化,还需单独检查 Case 真值和评测就绪条件。

      • 不同类型 Skill 的划分建议

      Skill 类型

      建议划分方式

      单一处理路径

      一个 capability.runtime,必要时增加 shared.boundaries 和 shared.guardrails

      多处理路径

      每个可独立归因和修改的处理路径建立一个 capability.<name>

      包含公共输出规范

      能力 Module 之外增加 shared.response

      包含公共业务边界

      将适用条件、业务阈值、异常输入和降级规则划入可进化的 shared.boundaries

      包含权限或高风险操作

      将权限、安全、合规和不可逆操作确认划入只读的shared.guardrails

      以能力识别和分流为主

      单独建立可进化的 routing;修改 Skill 触发范围时须有路由评测 case 覆盖

      Module 数量不宜过多。只有当两部分内容对应不同能力或处理路径、能够独立归因,并且可以独立修改时,才应拆分为不同 Module。

      • Module 边界定义方式对比

      在 SKILL.md 中加分隔符

      外部 module_spec ✅

      每轮由模型动态识别

      实现⽅式

      直接在正⽂中标记Module起⽌位置

      在独⽴配置中记录 Module与 SKILL.md 内容范围的映射

      反思时由模型临时判断Module边界

       优点

      定位准确

      不修改现有 Skill,可进⾏⼈⼯审核和版本管理

       ⽆须预先配置

       缺点

      需要修改全部现有 Skill,并在业务⽂档中引⼊进化标记

      Skill 结构变化后需要同步更新配置

      边界不稳定,不同轮次可能识别出不同结果

      • Module 配置与使⽤约束

      module_spec 在 Skill ⾸次进⼊进化流程时⽣成,配置⽣成和使⽤规则如下:

      阶段

      处理规则

      ⾸次配置

      当前⼯具按标题和关键词⽣成草稿;⼈⼯按业务能⼒合并或拆分  span,并确认只读规则

      进化启动

      重新计算 SKILL.md 的内容摘要;若与 source_hash 不⼀致,则暂停进化并重新确认 Module 边界

      Module选择

      根据失败 case 的归因结果,选择最相关的可修改 Module,不按固定顺序轮询

      单轮变异

      反思模型读取完整⽗版本作为上下⽂,但默认每轮只修改⼀个⽬标 Module,其他内容保持不变

      变异校验

      检查实际差异是否全部位于⽬标 Module,并确认只读 Module 未发⽣变化

      复杂归因

      单 Case涉及多个 Module、指向只读规则或⽆法可靠定位时,交由⼈⼯确认,不⾃动执⾏跨 Module  修改

      Module变异完成后的⼦版本全量评测、⽗⼦⼊池判定及候选池更新,统⼀按照 2.1全局流程执⾏,本节不再重复说明。

      ▐2.4 归因变异提示词设计

      归因与变异使用两个独立提示词:归因提示词按 Case 执行,变异提示词在选定目标 Module 后执行。

      • 归因提示词输入

      输入项

      内容

      当前 Skill

      父候选对应的完整 SKILL.md 内容

      用户问题与 Ground Truth

      当前 Case 输入和按维度组织的可信标准答案,用于判断期望行为

      Module 配置

      module_spec,包括 Module ID、对应内容范围及是否允许修改

      执行轨迹

      Zelda 执行轨迹接口 返回的结构化 messages,包括用户输入、助手回复、工具调用和工具结果

      评测结果

      Zelda 统一评测链路产出的最终结构化结果,语义上对应 评分接口 的判分数据:总分、各维度分数、原子问题判定、评分依据和原因;不传无关 ID 与 debugInfo 等调试字段

      全部黄金 Case 都执行归因。失败 Case 用于定位问题,成功 Case 用于识别变异时需要保留的正确行为。统一评测系统负责产生 Trace 和评分,自进化流程负责把这些产物编译成反思反馈。

      归因输出需要表达分类、责任 Module、证据引用、失败原子问题、期望行为、需要保持的行为和置信度。只有可信 SKILL_ISSUE 驱动变异;RUBRIC_ISSUE、CASE_ISSUE、ENVIRONMENT_ISSUE 和 UNCERTAIN 分别进入指标、Case、环境处理或人工澄清。证据非空不等于证据真实,引用应能在对应执行记录中校验。

      选择目标 Module 时,当前实现聚合 (1 - case_score) × confidence。最高信号并列或责任范围无法收敛时暂停;零信号和低置信度的确定性门禁仍需补齐。

      • 变异提示词输入

      输入项

      内容

      当前 Skill

      父候选对应的完整 SKILL.md 内容

      用户问题与 Ground Truth

      当前 Case 输入和按维度组织的可信标准答案,用于判断期望行为

      Module 配置

      module_spec,用于确定各 Module 的内容范围和修改权限

      目标 Module

      根据归因结果选出的本轮唯一可修改 Module,以及该 Module 的当前内容

      执行轨迹

      全部黄金 Case 的 执行轨迹接口 结果,供模型核对实际执行行为

      评测结果

      全部黄金 Case 的 评分接口 最终结果,供模型同时识别失败问题和需要保留的成功行为

      归因反馈

      归因提示词生成的 Case 级问题原因、责任 Module、证据和期望行为

      历史变异

      目标 Module 最近被淘汰的修改内容及淘汰原因;没有历史记录时不传

      修改约束

      仅允许修改目标 Module,不得修改只读 Module、硬编码评测 Case 或虚构不存在的工具能力

      变异提示词只生成目标 Module 的替换内容,再由系统与父候选中的其他内容合并,形成完整子候选。模型不能修改只读 Module、写死评测答案或虚构工具能力;Trace、用户文本和工具输出作为不可信证据输入,不能变成新的执行指令。

      上表描述完整设计输入。当前实现传入父 Skill、Module、分数、归因摘要和简略失败记录,尚未完整传入全部原始 Trace、判分及历史 diff。已有评测引用、diff.patch 和 mutation.json 可以复用,后续主要补齐证据消费链路,避免新增第二套存储或评分流程。

      实践中的关键取舍

      这套设计保留了三组取舍:通过全量评测换取候选可比性,通过单 Module 修改换取边界可解释性,通过全局候选池保留局部优势而不立即只追逐均分。

      更完整的搜索系统也意味着额外成本:需要可信真值、首次 Module 审核、候选评测预算,以及对版本、异常和人工决策的状态管理。它适合业务边界较清楚、评测资产较完整、需要持续优化的 Skill;缺少可信真值或环境不稳定时,应先建设这些基础条件。

      Skill 自进化最终要让每次修改都能回答三个问题:依据是什么,范围在哪里,收益如何验证。黄金集与 Trace 提供依据,Module 收住范围,全量评测和独立保留集检验效果,状态与报告保留可追溯过程。人工在首次边界和最终交付中作出业务判断,模型在这个范围内探索更好的版本。

      跳转微信打开

      •  

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

      左文雯 张哲旸 2026-11-11 10:36 浙江

      把业务规则变成AI可读、可追溯的结构化知识。为AI SQL Coding提供精确输入。

      图片

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

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

      图片

      AI 生成 SQL 的三类典型错误

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

      ▐1.1 一个看似简单的需求

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

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

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

      ▐1.2 三类高频错误

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

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

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

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

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

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

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

      根因分析:AI 的知识缺口

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

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

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

      图片

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

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

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

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

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

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

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

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

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

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

      ▐3.2 本体与相邻概念的区别

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

      图片

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

      ▐3.3 本体的三层架构

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

      图片

      图片

      本体三层架构

      ▐3.4 本体包含的五类知识

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

      图片

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

      图片

      OntSQL Agent 架构

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

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

      ▐4.1 四种方案对比

      图片

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        ▐4.5 人工只在两处介入

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

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

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

        本体如何进入 AI 生成链路

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

        ▐5.1 本体资产构成

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

        图片

        本体资产

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

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

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

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

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

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

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

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

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

        • 相关的指标口径定义;

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

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

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

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

        图片

        召回结果

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

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

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

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

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

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

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

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

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

        图片

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

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

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

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

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

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

        效果验证:技术评测

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

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

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

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

        ▐6.2 五层递进检测

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

        图片

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

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

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

        ▐6.3 有无本体的实测对比

        图片

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

        效果验证:业务落地

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

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

        承接需求量

        需求开发效率

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

        AI行占比指标统计

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

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

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

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

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

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

        跳转微信打开

        •  

        数字员工:有关AI Native新流水线的思考

        原创 天猫技术 2026-11-09 18:18 北京

        别再造执行Agent了,先建好协同流水线。

        图片

        本文探讨了AI Native组织中“数字员工”作为新流水线的核心价值。作者指出,当前多数方案聚焦于让AI自主完成任务的“执行层”,而真正稀缺的是解决人与人、人与AI之间目标对齐和上下文串联的“协同层”。真正的数字员工并非执行具体任务的Agent或面向个人的数字分身,而是以业务单元为边界、随时在线的“PM”角色。它通过IM群、协作板及会议等入口主动感知信息,拉齐上下文并派发任务,沉淀属于组织的资产而非个人效率。短期红利虽在执行层,但长期胜负手在于协同层,构建这条将各角色串联起来的新流水线才是关键。

        图片

        写在前面:

        上篇留下的那个问题

        电动机替代蒸汽机的故事,作为AI转型的例子已经被讲了无数遍:工厂把蒸汽机换成电动机,效率三十年没起色,直到有人围绕电机把整条流水线重组了一遍,效率才真正起飞。那么问题来了:在AI Native的组织里,那条新的“流水线”到底是什么?

        在上一篇《重构协同:关于AI Native团队的思考》里,我给出过一个判断:AI Native最大的变化,也许就是把“串联者”从人换成了Agent;而对公司来说,两个核心命题之一,就是要把“人、Agent、知识底座三者协同”的工具建好。我讲了“为什么”,但没讲“那个协同工具具体长什么样”。

        这篇文章我想试着用我新的理解做个回答,我不敢说已经找到了答案,但我目前的判断是:“数字员工”,很可能就是那个协同工具,就是那条新的“流水线”。

        这里说“流水线”,并不是它字面上那套“固定工位、固定次序”的产线形象——恰恰相反,流水线关键不在那一个个工位,而在于把工位串起来、让任务能一道道流下去的那套“串联机制”。所以当我说数字员工是那条新的流水线时,指的正是串联这个内核,而串联的本质,则是对齐目标和上下文。

        我知道,一提“数字员工”,会觉得这个概念有点说烂了,脑子里也会浮现出公司的一堆内部产品——AgentForce(企业智能的数字员工)、CoTeam、QoderWake等等。但这里有一个基本问题一直没有讲清楚:一个数字员工到底该解决什么问题,它应该成为一个什么样的角色?这篇文章讲的,就是我个人对这个问题的一个更具象的理解。

        观点总结:数字员工不是又一个被说烂的概念,而是那条新流水线的候选形态;真正的问题在于,我们始终没把它该扮演的角色想清楚。

        协同层与执行层:

        我们更缺的那一半

        要把角色想清楚,得先做一个区分——这也是这篇文章最想讲清楚的一点。

        把串联者从人换成Agent,这件事的本质就是协同。所以,“数字员工”的核心目标,本就应该是解决协同的问题。我把这一层面叫做协同层;与它相对的,是执行层。两层解的是完全不同的两件事:

        • 协同层:解决“人与人、人与AI之间,如何对齐目标与上下文”——本质是要把隐式的、线上线下的上下文搬上来,并“确定目标”,最后串联任务,而“目标”是执行层Harness的前提条件。

        • 执行层:解决“AI如何自主地把一件事干完”,它的重要目标是通过Harness不断降低人工介入率。

        这个区分很重要。回头看现有很多“数字员工”方案,会发现它们大多聚焦在执行层:比如强调AgentTeam,让你去定义开发、测试、产品,或者TeamLeader这样一个个角色的数字员工,然后人还是和这些角色打交道。这些角色,看起来更像是“流水线上执行工位”,有的方案甚至认真地讨论起对数字员工的“绩效考核”。但在我看来,给一个个执行角色贴上传统职能标签,并非关键;我们真正缺的,是把这些角色串起来的“流水线”本身。

        这并不是说,执行层这一半不重要,而是它已是相对成熟——只是当下平台和方案选型极多,处于一种野蛮生长的状态。对企业内部而言,执行层更重要的命题,是收敛与统一:让沉淀下来的Harness工作流、技能、知识库能在组织范围内复用、产生复利。而协同层,则是我们目前还没补上的那一半,也是本文想重点谈的。

        观点总结:执行层方案已相对成熟、正待收敛;真正稀缺、也最该补的,是把角色串起来的那条协同层的流水线。

        什么才算“数字员工”

        顺着协同层和执行层的区分,我想较真一下“数字员工”这个叫法本身。

        人真正需要打交道的,是那个“协同者”身份的数字员工。至于它背后如何调度不同的Agent去干活,绝大多数人并不需要关心(只需要少数人关心)。所以:

        • 背后那些干活的执行角色,我们可以叫它们Agent,但不必叫“数字员工”。因为它们不必成为数字员工——不必各自拥有记忆,只需按需动态创建,任务执行完就可以销毁。

        • 只有那个协同者角色,才适合称“数字员工”。因为它要真的像一个员工那样干活。这就像真实的组织里,PM是那个稳定的对接人和责任人,而某个具体任务最终外包给了谁、用了什么工具,协作方其实并不需要知道。

        至于它具体做什么,不妨照着一个尽职的PM去想象:拉群、把对的人拉进来、追问澄清,盯着目标往前推、到点催办、把风险和卡点主动亮出来,再把诉求、决策和经验一路记录、沉淀下来。而最核心的一件,是拉齐上下文、并派活——拉齐成员之间、以及成员与执行Agent之间的上下文,最终把一份足够清晰的任务派下去。

        这里顺带还要区分一下——数字分身,我倾向于把它们看成两个东西。数字分身(或者个人助理),它面向的是个人,是个人的“分身”,代替的是个人的一部分工作,本质上仍然活在现有的那条流水线里;而数字员工,面向的是一个业务单元,是toB的,它沉淀下来的都是公司的资产,不属于任何个人。这个区分之所以重要,是因为它直接决定了“沉淀”归谁:分身沉淀的是个人的效率,人走了东西也跟着走;数字员工沉淀的是组织的资产,越用越厚,不随任何个人的流动而流失。

        观点总结:只有“协同者”那个角色才叫数字员工——背后即用即弃的执行Agent不算,面向个人的数字分身也不算;前者让个人更快,数字员工要做的是让组织重构。

        它是谁:一个业务单元维度、

        随时在线的“PM”,以及它怎么“感知”

        如果要给这个协同者一个更具象的定位,我的答案是:它很像一个业务单元维度、随时在线的“PM角色”。它必须懂当前这块业务,并且会基于目标、围绕主题,主动去推进事项,而不是你问一句它答一句的机器人。

        这里有个关键:它不只是接受一个任务然后去执行,而是需要尽可能多地渗透到员工真实的工作活动中(群里的讨论、会议的沟通、线下的即时交流……),为任务获取充分的上下文。所以,从技术实现上,它的关注点落在“感知”侧,而不是执行侧。工具是被动的,你不用它,它就待在那儿;而一个PM是主动的,它会追着目标、追着人、追着卡点往前走。这也正是协同层区别于执行层的地方:执行层追求的是“把交代的活干好”,协同层追求的是“没人交代,也知道该往哪儿推”。

        而一个PM要干好活,第一道坎就是如何“感知”——信息进不来,后面的对齐、推进、派活都无从谈起。所以真正要解决的问题是:怎么把那些原本散在人的协作过程里的上下文、那些藏在线下的隐性知识,自然而然地搬到一个共享的上下文空间里来。

        这个“共享的上下文空间”需要入口,可以分成线上和线下两类。

        线上目前有两种常见形态:

        • IM群(钉钉群):当下最合适的入口——传统上人协作的入口主要就是群,数字员工驻在群里,讨论和文档它都能“听”到、“收”到(类似Claude基于Slack那类思路)。

        • 围绕工作项的协作板:各平台自己做的web形态,围绕一个工作项,通过评论、at来对齐,比如Aone的CoCo(可参考开源的Multica)。

        而线下——会议,或即时的小范围沟通——则是应对复杂场景最常见、也最绕不开的方式:几乎没有哪个复杂需求,能只靠群聊就完成目标对齐。可也正因为它发生在线下,反而最难搬进共享空间,而且很多会议是急需提效的:现在只能靠钉钉AI听记事后补一份纪要,而听记缺上下文,记出来的常不尽如人意。更理想的形态,是数字人能像在场员工一样参与会议,随时可以cue它,或它主动发问,和它全双工实时沟通(有点像AI访谈那种虚拟的AI主持人)。我认为这会是未来一个重要方向——也许钉钉AI听记应当提供这种能力,且可定制、可注入上下文。

        这三种入口,是一条从“即时、同步”到“延迟、异步”的变化线:会议和当面沟通协同强度最高、最即时,IM群居中,协作板最异步、最能留痕慢推。协同强度越高,越适合啃那些复杂、需要高频对齐的场景;越异步,越适合轻量、可以慢慢推进的事。一个理想的数字员工,应该能覆盖这条线的每一段。

        关于入口层面,有个问题需要说明:群这种交互方式,对协同层很自然,但对执行层并不理想。拿Coding来说,很多人习惯实时看到CodeAgent的工作进展、代码变更——这种细粒度、强反馈的过程,塞进群聊里是别扭的。这也提醒我们,协同层和执行层的入口,不必、也不该是同一个东西,但它们背后应当要共享一个上下文空间。

        观点总结:数字员工的真正诉求,不是一个全能机器人,而是一个懂业务、会主动推进的“PM”;而做好PM的前提是感知——把隐性上下文搬进一个共享空间,IM群是当下最好的入口,web是补充,而会议则是非常重要、却仍待补齐的一环。

        承载它的平台:

        能“拎包入住”,也能自定义

        有了角色定位和感知入口,接下来的问题是:用什么平台把它承载起来?

        我认为,一个管理协同数字员工的平台,至少要满足这么几点:

        1. 轻量:基于一个业务单元,就能快速创建出一个。

        2. 能拎包入住:新建出来之后,它得自带足够的“串联角色”内置能力——开箱即用,而不是从零搭。

        3. 能自定义:在拎包入住的基础上,又能做足够的差异化定制。

        4. 能与执行层无缝衔接:协同层派活给执行层的Agent时,上下文要尽可能少损耗——数字员工费劲感知、拉齐来的上下文,不能在交接给执行Agent时摩擦掉。

        5. 跑在云端:它是一个随时在线、面向业务单元的角色,本就该跑在云端,而不是像很多个人AI工具那样,依附在某个人的电脑上、人一关机就没了。

        一句话,对一个业务单元来说,介入要足够简单、能复用成熟能力、允许差异化,还要和执行层顺滑打通。作为对照,目前我看到的一些数字员工平台,虽然在自定义能力上足够灵活,但申请和使用都有一定门槛,且不同数字员工之间还缺少可复用的模板——不太容易拎包入住,也不好在一定的组织范围内沉淀复用。

        观点总结:好平台的标准是“介入简单 + 复用成熟能力 + 允许差异化 + 与执行层无缝衔接 + 云端常在”。

        怎么组织:

        业务单元 → 协同层 → 执行层

        那么,一个数字员工该怎么组织?是做成一个大而全、全知全能的Agent实例吗?——很可能并不合适。它要真正懂一块业务、把上下文维持在能驾驭的范围内,就必须被框定在一个相对聚焦的边界里,也就是一个业务单元;上下文一旦铺得太宽,它既抓不住重点,也沉淀不出真正可复用的东西。所以我认为的数字员工架构,是分层的、且以业务单元为界:

        业务单元 →〔协同层〕数字员工 →〔执行层〕子Agent + 工作流(研发工作流、答疑工作流、工单处理工作流、经营工作流……)

        这个结构里有两个关键:协同层是相对通用的,但到今天为止,我还没见到一个做得比较完善的;而执行层的关键,是把那些已经成熟的工作流沉淀下来、并被复用,可当下这些工作流是非常分散的。

        这里顺带说明:无论业务AI Native还是研发AI Native,对协同层的诉求其实是一致的,差异只在执行层——研发、数据、运营、Skill各有各的工作流,本质是SOP的不同。所以两层沉淀的东西也不是一回事:协同层沉的是这块业务的上下文、知识和对齐后的目标,执行层沉的是把活干完的SOP。

        再具体到数字员工日常是怎么干活的:它在一个业务单元内,围绕一个一个主题去工作。一个主题,对应到多个协作入口(多个群、私聊、会议等,或者叫频道),同时每个主题又对应到多个不同的需求,每个需求再对应到多个工作流。

        举例来说:

        • 业务单元:比如“天猫国补”业务单元。它有自己固定的一批成员、一套业务知识、一组常用技能——数字员工就绑定在这一个单元上,它只管这块(至于业务单元的边界该怎么划,上篇提过,是另一个重要而困难的话题,这里不展开)。

        • 主题:比如“国补交易表达”这样一件要持续推进的事。数字员工的工作,就是围绕一个个主题展开的。

        • 协作入口(频道):为这个主题拉起的一个或多个钉钉群、若干私聊,后续可能还有相关会议。人和数字员工,就在这些入口里协作。

        • 工作项:一个主题之下,一个个具体的需求,比如“国补交易下单要支持支付优惠前置表达一期”、“二期”、“购物车国补表达bug修复”等等。

        • 工作流:每个需求按它的类型,走一条对应的、已经沉淀好的流程(Agent驱动的动态工作流)——研发需求走研发交付工作流,工单来了走工单处理工作流,取数场景走取数工作流。

        而协同层做的,是数字员工在群里/会议里澄清需求、对齐口径、拉齐上下文、按工作项产出需求(目标)、派活、跟进;执行层做的,是背后的子Agent把派下来的活按工作流自主干完(比如出技术方案、编写代码、修改、自测、部署、验证、提CR)。

        最后还有一个绕不开的命题:身份和权限。数字员工要替人调用工具、动系统——改代码、跑部署、提CR……它到底该拥有一套独立的身份与权限,还是继承委托人的权限来执行?在群协同这种场景下,又该如何切分?这背后关系到安全、审计和责任边界,是另一个大的话题,这里不展开。

        观点总结:数字员工不该是全知全能的,而应按业务单元划分、在聚焦的边界内工作,以主题为单位组织,沉淀的是组织资产,而不是某个人的效率。

        也许现在我们感受并不强烈

        必须承认一点:数字员工在协同上的作用,今天对绝大多数人来说,不一定能接受并感受到它的价值。

        这很正常。在现有的组织和业务形态下,它的价值在短期内本来就不容易体现出来——因为那个“厂房”还远没有改造好。这背后不只是一次技术升级,还牵扯到业务和组织的适配、习惯的改变。比如对研发来说,可能大部分情况下都是拿到已有的PRD,独自就能去做交付(已被分工和分配),那么你所需要的,往往只是执行层的工具,让数字员工通过协同层再绕一遍,反而会让你觉得别扭。

        还有一层更微妙的错觉:一个员工可能会把自己的“数字分身”打造得很好,个人效率蹭蹭往上涨——这没有问题,但也要小心不要因此被困住,因为那是一种实实在在的“爽感”,要记住,个人效率高 ≠ 组织效率高,应把个人的经验沉淀到团队去。分身优化的是你自己那一段,而组织的瓶颈,往往在人和人、段和段之间的协同上,那恰恰是分身够不到、而数字员工要去补的地方。

        而当下大家最容易有体感的,是执行层的变化——这一层从实践层面看,正渐渐趋于成熟。只是眼下工具五花八门、选择繁多,未来面临的真问题,还是如何收敛(以便沉淀、复用)。换句话说,短期的红利在执行层,长期的胜负手在协同层。

        观点总结:短期的效率红利在执行层,长期的胜负手在协同层;个人的“爽感”不等于组织的效率,感受不到,不等于不重要。

        结尾:回到那条新流水线

        说回开头那个问题:AI Native组织里那条新的流水线到底是什么?我目前的答案是——围绕“Agent来串联”这个新前提,重新组织起来的协同方式;而数字员工,是我现在能看到的、那条流水线最具象的形态。

        这方面,天猫技术也在尝试自己的数字员工实践NC(恩熙同学),在协同场景下的权限问题上也有自己特色的实践,本文不展开,感兴趣可以去看“天猫数字员工”系列文章。

        当然,实践离目标还很远,我也不敢说这就是终局的答案。但方向是清楚的:与其忙着造更多会干活的AI角色,不如去补上那条把它们串起来的协同层流水线——把目标定义和上下文对齐前置到源头,这件事只会越来越重要。

        团队介绍

        本文作者书牧,来自淘天集团-天猫技术团队。天猫技术是阿里巴巴旗下专注于电商场景的综合技术团队,既支撑天猫电商业务的持续增长,也在探索如何用 AI、大数据与交互技术重塑行业交易、品牌营销与消费者体验,致力于成为全球领先的品质购物平台背后的技术引擎。团队长期开放AI研发工程师、AI评测工程师、AI算法工程师的岗位,欢迎将简历投递至 jade.liuyy@taobao.com。

        跳转微信打开

        •  

        淘宝MNN团队开源0.3B手机模型,iPhone 18 Pro上离线跑出350 token/s

        Meta技术 2026-11-06 11:33 浙江

        方寸之间,智能可及

        图片

        把大模型运行在手机上,已经有了不少探索。

        从1B、4B到27B量级的稠密模型,再到总参数约30B、激活参数约3B的MoE模型,不同规模与架构正在拓展端侧部署的可能性。

        但对手机应用开发者来说,成功加载模型、完成一次对话,只是起点。

        对于淘宝、闲鱼这类日常高频使用的应用,大模型必须与其自带业务共享算力、内存和带宽。同时,还得在持续调用与多任务并发下,兼顾响应时延、功耗和温升。

        MNN团队将这一设计方向称为“手机应用原生大模型”。他们发布了MNN-Pocket-0.3B,面向手机应用的任务需求与资源预算,在有限算力、内存和能耗下,兼顾任务能力、响应速度与持续运行体验。

        图片

        手机应用原生大模型背景介绍

        围绕淘宝等综合型手机应用,团队将“手机应用原生大模型”落实为四个维度的设计目标:

        • 速度上,在指定设备与上下文配置下,解码吞吐超过200token/s。这一目标参考高速云端模型服务的生成吞吐,力求在本地提供流畅的生成体验。

        • 内存上,在指定测试条件下,峰值内存低于300MB。即使手机拥有8~16GB内存,也需要由系统与多个应用共享。以约500MB的模型模块预算为例,将推理峰值控制在300MB以下,可以为上下文增长和集成开销保留余量。

        • 功耗上,在典型推理负载(输入512~1024token、输出128token)下,单次推理增量能耗目标不超过参考手机电池能量的万分之一,即100次推理耗能不超过电池能总量的1%,控制高频调用的续航开销。

        • 能力上,以在指定业务场景上达到8B级模型的效果为目标,兼顾中英文理解、世界知识与数学、代码推理能力,重点强化指令遵循,并为长上下文与多步骤任务保留扩展空间。

        这些目标还需要在持续调用中共同接受检验:在满足任务要求的同时,控制功耗与温升,保持整机流畅,才能融入应用的日常使用。

        MNN-Pocket-0.3B正是这一设计方向的具体实践。MNN团队从零设计并训练了这个约3亿参数、重点支持中文与英文的轻量语言模型,将模型结构、词表、训练数据、预训练与后训练方法,以及量化和推理引擎纳入协同优化,为淘宝业务与开源社区开发者提供一个具备任务理解能力、响应迅速、易于适配和集成的模型底座。

        手机应用原生大模型象限:MNN-Pocket-0.3B兼顾速度、内存与能力(注:峰值内存不仅取决于总参数量,还受词表规模、量化参数及加载缓冲影响,详细指标与测试设置见技术报告。)

        0.3B参数,如何做到轻量与高速?

        先看MNN-Pocket-0.3B在iPhone 18 Pro上的真机表现。模型通过MNN推理引擎完全离线运行,平均解码(Decode)速度约为350token/s。录屏同步展示输入处理(Prefill)、逐Token生成(Decode)的速度与峰值内存占用,直观呈现模型的响应效率与资源开销。

        部署体积与运行内存:MNN-Pocket-0.3B的INT4 MNN部署文件体积仅为173MB,包含模型权重、分词器、计算图和推理配置。在iPad Pro M5、Metal后端、512token测试配置下,模型加载与推理期间的峰值Metal驻留内存相对加载前基线增加228MB。同一测试中,Qwen3-0.6B的部署文件体积为340MB,峰值内存增量为427MB。相比之下,MNN-Pocket-0.3B的部署体积减少约49%,峰值内存增量减少约47%。对于手机应用原生大模型,较小的部署体积能够降低模型下载与更新成本,较低的运行内存则为页面、图片、视频等业务模块保留更多空间,降低应用集成的资源负担。

        端侧大模型在iPad Pro(M5)上的内存占用与部署体积(上下文长度为512token)

        跨平台推理速度:团队在Apple与Android设备上,使用Metal、OpenCL和CPU后端评估推理吞吐。测试采用MNN 3.6.2、INT4量化及统一运行设置,每组配置预热一次、测量五次,取吞吐中位数,Prefill与Decode分别测量。在iPad Pro M5/Metal、512token测试配置下,MNN-Pocket-0.3B的Prefill吞吐达到8,721token/s,Decode吞吐达到466token/s,约为同条件下Qwen3-0.6B(286token/s)的1.63倍。在Snapdragon 8 Gen 5的CPU后端,Decode吞吐达到251token/s。

        不同平台上端侧大模型的推理速度(上下文长度为512token,单位:token/s)

        Prefill影响输入处理耗时,Decode影响后续生成速度。上述结果基于报告规定的量化、上下文与测量条件,实际表现会随设备、后端及输入输出长度变化,完整配置可参考技术报告第5节。

        这些结果来自三个层面的协同:参数规模与结构控制整体开销,词表设计减少存储与输出计算,推理引擎提高硬件执行效率。

        ▐从手机应用的资源预算确定模型结构

        面向手机应用原生大模型,团队将峰值内存低于300MB、解码吞吐高于200token/s作为架构选型目标,在资源预算内尽可能保留模型容量。围绕这一目标,团队构建了覆盖约50M至1.3B参数的稠密(Dense)模型配置,在iPad Pro M5、统一推理设置下进行测试。约300M是该组实验中同时满足两项约束的最大候选规模。

        确定规模后,团队进一步在相近参数预算内,联合调整模型深度、隐藏层宽度、前馈网络与注意力配置。从16层增加到28层带来了能力提升;继续增加到36层,评测均分没有进一步提高,解码吞吐却从355token/s降至323token/s。这里的吞吐用于架构选型对比,与前述最终部署版本的测试配置不同。

        最终,MNN-Pocket-0.3B采用28层结构,结合分组查询注意力(GQA)等配置,在模型能力、运行内存与推理效率之间取得平衡。

        MNN-Pocket文本模型架构和参数量选型

        ▐精简词表,降低存储与输出计算开销

        对于0.3B模型,词嵌入与输出层会占用相当一部分参数。更大的词表通常有助于压缩文本长度,也会增加存储、访存和输出投影开销,因此需要结合目标语言与任务设计。

        面向中文互联网手机应用,MNN-Pocket-0.3B将中文与英文作为重点支持语言,降低对其他语言分词效率的优先级。基于Qwen3分词器,团队将词表从约151K精简至64K,词条数量缩减约57%,减少词嵌入与输出层的参数和存储需求,并降低逐Token生成时的输出投影开销。

        裁剪过程中,团队使用覆盖中英文、代码、数学和指令格式的语料筛选词条,同时保留特殊Token、字节回退Token与必要的BPE合并依赖。通过兼顾词表规模和编码效率,模型能够保留常用表达的高效编码,避免过度裁剪造成序列变长,抵消部署收益。

        ▐模型与引擎协同,加速端侧推理

        MNN-Pocket-0.3B的端侧效率,来自模型设计与推理引擎的协同。MNN在CPU侧针对Arm点积与矩阵指令定制低比特内核,在GPU侧根据不同架构优化缓存访问、计算分块和线程配置,并提供面向高通Hexagon的专用后端。同时,为Prefill、Decode选择合适的执行路径,通过QKV、FFN算子融合与GPU命令复用,减少访存和调度开销。在常规自回归解码之外,MNN还支持投机解码,并针对8-draft配置实现专用GPU内核,优化多Token的并行计算。

        团队在搭载骁龙8 Gen 5的设备上,分别评估MNN-Pocket-0.3B在CPU、GPU和NPU上的推理性能,并与llama.cpp对比。在4bit量化下测试MNN的性能Prefill性能是llama.cpp的1.51~2.90倍,Decode性能是llama.cpp的1.43~1.82倍,MNN性能具有明显优势。

        在能耗方面,团队还在一加13(骁龙8至尊版)上,使用MNN对MNN-Pocket-0.3B的4-bit模型进行了功耗测试。在CPU4线程、输入1024和输出128基准负载下,通过采集电池电流与电压,并扣除闲置基准耗电,三轮测试折算的平均增量能耗约为2.7J/轮。以该手机电池容量6000mAh计算,执行100次同等负载任务累计增量能耗约占电池总电量的0.3%。

        MNN-LLM通过统一的模型转换与推理接口,降低跨芯片、跨操作系统的集成成本。MNN已积累16K GitHub Star,MNN-LLM支持200+款大模型,相关模型累计下载超过百万次,为MNN-Pocket-0.3B进入实际应用提供了工程基础。

        部署效率决定了模型进入手机应用的成本。接下来要验证的,是它能否在有限参数下准确理解输入,并按要求完成任务。

        0.3B参数,任务表现同样出色

        手机应用原生大模型的能力,需要体现在业务流程能够使用的结果上。评论抽取要求忠实复现原文,标签判断需要限定在候选集合内,结构化输出则必须遵守字段与格式。内容遗漏、无依据补充或类别越界,都可能影响后续处理。

        因此,MNN-Pocket-0.3B在建设中英文理解、数学推理与代码能力的同时,重点强化指令遵循与受约束输出,为不同业务任务的适配提供基础。

        模型的能力表现:在技术报告采用的评测设置下,MNN-Pocket-0.3B的英文IFEval得分为73.20,团队构建的中文指令遵循IFEval-zh得分为74.59,在所比较模型中均取得最高分。在覆盖中英文知识、推理、数学、代码与指令遵循的11项评测中,模型平均得分达到50.00,高于报告列出的同规模模型,以及MiniCPM4-0.5B、Qwen3-0.6B等更大规模的对比模型。其中,中文数学MGSM-zh得分为51.20,代码生成HumanEval得分为53.66。这些结果为应用适配提供了基础能力参考,具体业务仍需通过任务数据和验收标准验证。知识密集型任务与复杂推理,也仍是模型需要继续提升的方向。

        MNN-Pocket-0.3B与其他基线模型在11项基准测试上的精度指标对比

        在固定参数规模下,团队通过多阶段预训练建立基础、SFT迭代补足短板、多教师蒸馏整合能力,再通过量化感知训练保留部署效果。

        MNN-Pocket-0.3B完整训练流程

        ▐多阶段预训练:让数据更适合小模型学习

        小模型对数据质量与配比更为敏感。MNN-Pocket-0.3B将预训练数据按领域、文本形式、知识密度、难度和质量五个维度进行标注与分级,为不同训练阶段制定更精细的配方。

        数据是否值得学?在清洗、去重的基础上,分别评估质量与知识密度:质量关注内容的准确性、连贯性与完整性,知识密度关注有效信息含量及冗余程度。两者各划分为低、中、高三级,分别对应Q1–Q3、D1–D3,区分“内容干净”和“信息充实”,提高筛选与配比的精度。

        数据是否适合学?将难度划分为H1–H3三级,结合领域与文本形式,控制不同复杂度样本的分布。同时,对问答、表格和列表进行结构化整理,在部分数学与代码样本中补充概念、推理步骤或解释,增强可学习性。

        数据应该何时学?将上述维度组合成数据分桶,通过候选配方试验与实际混合训练,联合调整各阶段的采样比例。例如,提高数学数据占比时,也同步考虑其中的质量、知识密度和难度构成,让领域配比与模型当前的学习阶段相匹配。

        基于这套分级体系,MNN-Pocket-0.3B完成约4.1Ttoken、四阶段预训练:建立语言与知识基础,强化中文、数学与代码,通过高质量数据退火巩固能力,最后将上下文支持扩展至32K。

        MNN-Pocket-0.3B前三个预训练阶段,更精细的数据分级提高学习效率

        ▐SFT Loop Engine:围绕能力短板自主迭代训练

        在预训练基础上,团队构建了约316万条样本的SFT数据配方,覆盖知识问答、数学、编程、中文任务与开放式生成,将基础能力转化为按指令完成任务的能力。

        为提高迭代效率,团队开发了SFT Loop Engine,通过Agent编排训练、评测与数据改进,形成闭环:

        训练→评测→失败归因→分配数据配额→合成与筛查→再训练。

        流程将失败回答映射到细粒度任务类别,结合历史训练数据分布,确定需要补充的类别、语言与样本数量。合成环节不直接读取原始评测题,并执行去重和泄漏检查,再将筛选后的数据用于下一轮训练。

        这一机制让训练改进对应到具体问题,同时通过回归评测检查新增数据带来的收益与其他能力的变化。对于需要覆盖多种业务任务的手机应用原生大模型,这有助于持续补足短板、维护能力平衡。

        MNN-Pocket-0.3B模型SFT Loop Engine流程图

        ▐MOPD:把多领域能力整合进同一个模型

        完成SFT后,团队进一步解决有限容量下的多领域能力协调问题。数学、代码、知识和指令遵循各有优化目标,混合训练需要处理目标之间的相互影响,顺序训练也可能造成已有能力退步。

        MNN-Pocket-0.3B采用多教师On-Policy蒸馏(MOPD),构建四条经过领域强化学习优化的教师路线,按样本所属领域选择教师,共同监督一个学生模型。

        其中,On-Policy的关键是由学生先生成。教师读取学生实际产生的上下文,并在这些位置提供Token分布监督,使训练覆盖学生自身容易遇到的生成状态。团队采用分布匹配目标,为小模型提供更密集的学习信号,提升训练稳定性。

        经过MOPD,模型在11项评测上的平均得分从35.79提升至50.00,其中10项提升、1项持平。中文数学、中文指令遵循和数学推理等任务取得了较明显的改善。

        多教师承担训练阶段的能力指导,部署时只保留一个0.3B学生模型,使能力提升无需增加端侧教师模型的存储与推理开销。

        ▐QAT:让训练效果保留到部署版本

        在手机应用中最终使用的低精度模型,同样需要接受能力检验。团队将量化纳入后训练流程,通过Self-OPD与量化感知训练(QAT),让W4A16学生在自身生成的上下文上,对齐冻结的BF16模型,缓解量化带来的能力损失。

        在同一组11项评测中,INT4版本平均得分达到49.59,较BF16版本的50.00下降0.41分。这使前一章展示的部署效率与本章的任务能力,最终能够在同一个INT4版本上交付。

        MNN-Pocket-0.3B模型MOPD和QAT流程图

        从基础训练到低精度部署,MNN-Pocket-0.3B的目标始终是形成可供应用使用的能力。接下来,通过不同阶段的模型开放与具体任务验证,让研究者和开发者能够继续适配、部署和检验。

        0.3B模型开放多阶段权重,

        从任务微调走向应用实战

        手机应用原生大模型的价值,还需要通过任务适配与应用集成来验证。为此,MNN-Pocket-0.3B提供从预训练、后训练到端侧部署的多个版本,让研究者与开发者能够选择合适的起点,继续训练、评测和构建应用。

        从研究到部署,MNN团队开源不同阶段的模型入口:

        模型版本

        主要用途

        MNN-Pocket-0.3B-Base

        继续预训练、领域适配与基础能力研究

        MNN-Pocket-0.3B-SFT

        后训练研究、强化学习、蒸馏与消融实验

        MNN-Pocket-0.3B

        通用指令调用与业务任务适配

        MNN-Pocket-0.3B-MNN

        W4A16 QAT 端侧部署版本,配合MNN 推理引擎 的低比特算子与硬件后端优化,在特定设备上解码吞吐可达 466 token/s

        MNN-Pocket-0.3B-DFlash2

        DFlash2 投机解码草稿模型,配合 MNN 推理引擎 的块级生成与验证实现,在特定任务下解码吞吐可达常规自回归解码的2.06倍

        MNN-Pocket-0.3B-Dec

        通过决策头完成候选选择类任务

        对于学生和研究者,Base与SFT检查点分别提供了基础训练与后训练的实验入口,便于探索数据配方、强化学习和蒸馏方法。0.3B的参数规模有助于降低单次微调与评测开销,支持更高效的多轮实验。

        对于应用开发者,最终指令模型可用于业务适配,MNN版本提供对应推理生态的部署资产。此外,Dec版本面向分类与候选选择任务,通过决策头在一次前向计算中完成候选打分;DFlash2草稿模型则面向生成加速,一次提出8个候选Token,由目标模型统一验证,减少逐Token生成的串行开销。

        围绕业务适配与交互体验,团队进一步选择了电商评论观点挖掘和全端侧语音对话两条链路,检验模型在具体任务与完整应用中的表现。

        ▐垂类任务适配:0.3B模型的电商评论理解能力

        “很好,遮瑕功能差一些”——一句简短评论,同时包含整体正向评价和对具体功效的负向评价。模型需要识别两者的对应关系,并区分明确表达与隐含信息。在天池电商评论观点挖掘任务中,输出由属性词、观点词、类别、情感极性四个字段组成。属性词与观点词必须来自原文,类别与情感必须限定在预定义集合内,未明确表达的字段按规则置空。一条评论中的多个观点,也需要完整抽取。

        团队使用天池任务提供的3,229条评论,对各模型进行相同配方的LoRA微调,再提交平台对隐藏测试标签评分。评测要求四元组的四个字段全部匹配,才计为正确,因此同时考察原文抽取、细粒度分类与格式遵循能力。实验中,MNN-Pocket-0.3B的F1达到80.15,高于同一设置下的Qwen3-0.6B(77.47)和Qwen3-1.7B(78.59)。以不到后者五分之一的参数规模,取得了高出1.56个百分点的任务成绩。

        MNN-Pocket-0.3B模型在电商评论理解上的能力验证

        这一结果验证了模型在该任务中的微调适配能力:通过领域数据与LoRA训练,0.3B模型能够将通用理解和指令遵循能力,转化为符合业务要求的结构化输出,为手机应用内的文本分析任务提供轻量实现路径。

        ▐全端侧语音对话:把速度与能力放进完整交互

        语音交互进一步检验了模型在完整应用链路中的响应效率与协作能力。团队搭建了全端侧流式语音系统,串联语音识别、MNN-Pocket文本生成与语音合成,并集成语音活动检测、语义断句和打断控制,所有神经网络模块均通过MNN在设备本地运行。系统采用流式处理缩短等待时间:语音转为文本后,MNN-Pocket开始生成回答,文本增量分段送入TTS,随后逐段播放,无需等待完整回答生成。用户再次开口时,系统停止当前生成、合成与播放,进入新一轮交互。详细流程可参考技术报告第7.2节。

        在报告的暖机测试条件下,系统实测首音频时延P50分别为:

        • iPad Pro M5:600ms;

        • Snapdragon 8 Gen 5设备:935ms;

        • iPhone 13 Pro:1,055ms。

        在统一ASR前端与评测设置下,采用MNN-Pocket的系统在九项VoiceBench任务上的总分达到45.44,为报告所比较语言底座中的最高分,展示了模型在语音输入条件下的综合任务能力。

        MNN-Pocket-0.3B模型结合语音对话场景的能力验证

        这条链路验证了MNN-Pocket作为语言处理底座,与语音感知、合成及交互控制协同构建端侧应用的可行性。完整系统包含额外的ASR、TTS等模块,其整体存储与内存需求需结合具体应用单独评估。

        让真实应用继续定义模型的下一步

        手机应用原生大模型的价值,最终要在真实业务、真实设备与日常交互中体现。

        MNN-Pocket-0.3B围绕应用需求,将模型结构、数据与训练方法、量化和推理引擎协同设计,在0.3B参数规模下兼顾任务能力、响应速度与部署成本,为应用开发提供可训练、可适配、可集成的模型底座。

        接下来,团队将持续推进端侧模型研发,围绕淘宝等业务中的需求理解、搜索推荐与智能交互,提升模型可靠性、设备覆盖与端到端效率,并探索AI眼镜等设备上的应用。

        通过开放不同阶段的模型与部署版本,团队期待与研究者和开发者一起,让模型在更多具体任务中得到验证与改进,让智能自然融入日常应用。

        GitHub:https://github.com/alibaba/mnn
        Hugging Face:https://huggingface.co/taobao-mnn/MNN-Pocket-0.3B
        ModelScope:https://modelscope.cn/models/MNN/MNN-Pocket-0.3B
        TechnicalReport:https://modelscope.cn/models/MNN/MNN-Pocket-0.3B/resolve/master/MNN-Pocket-0.3B-Technical-Report.pdf

        团队介绍

        本文作者来自淘天集团-Meta技术团队,该团队在端侧智能、端云协同、商品三维重建、真人三维重建、3D引擎、企业级软件AI研发等方面有着深厚的技术积累,先后发布端侧推理引擎MNN、商品三维重建工具Object Drawer、Taobao3D大模型、3D真人数字人TaoAvatar、端云协同系统Walle等。团队在OSDI、MLSys、CVPR、ICCV、NeurIPS、TPAMI等顶级学术会议和期刊上发表多篇论文。欢迎对3D大模型、端侧引擎和端侧大模型、渲染引擎、AI研发等感兴趣的优秀人才加入,一起技术创新和应用探索。

        跳转微信打开

        •  

        天猫国际 AI 智能建场 Agent 工程实践:从一句话到可投放的会场页面

        原创 天猫技术团队 2026-11-04 11:07 浙江

        一句指令,AI 自动搭出可投放会场。

        图片

        本文介绍了天猫国际 AI 智能建场 Agent 的工程实践,旨在将运营人员的一句自然语言需求转化为可投放的会场页面。系统并非简单让大模型生成 JSON ,而是构建了以 ReAct 驱动决策、确定性机制约束边界的 Agent Harness 架构。通过状态机管控执行权限,利用字段级生产计划与业务坐标精准定位操作,并借助 MetaQ 异步回调处理耗时任务,确保长流程可控、可恢复。同时,项目沉淀了流式执行、AG-UI 事件协议及工具治理等通用基建,不仅支撑智能建场落地,也为 AI 设计等其他复杂 Agent 场景提供了可复用的底层能力。

        图片

        摘要

        “帮我搭一个七夕轻奢箱包会场。”

        对于运营,这是一个自然、完整的业务目标;对于系统,它却远不是一份可以直接执行的指令。主题和品类之外,商品数量、选品条件、模块结构、素材尺寸、文案要求都可能缺失。系统还要跨越 U+ 圈品、图片生成、文案生成、页面装配与人工修改等多个环节,其中既有秒级同步能力,也有通过 MetaQ 回调完成的分钟级异步任务。 

        我们最终将智能建场设计为一个由 ReAct 驱动、由确定性机制约束的生产 Agent:模型负责理解目标、选择工具和根据 Observation 继续决策;状态机、生产计划、字段坐标和任务账本负责限制模型可以做什么、结果写到哪里以及失败后如何恢复;前端通过 SSE/AG-UI 同时消费文本、工具事件和业务卡片;异步圈品则在原对话结束后通过回调继续更新任务事实。 

        在落地智能建场的同时,项目沉淀了流式执行、AG-UI 事件、会话任务模型、工具执行与日志、异步任务续跑、Trace 和场景扩展点等基础设施。这些能力并不绑定“会场”语义,可继续承接 AI 设计、视频生成以及其他需要多轮交互和长任务编排的新场景。

        业务背景:一句需求背后

        是一条生产流水线

        传统会场生产需要依次完成营销目标理解、模板与模块选择、商品圈选、图片与文案制作、页面配置、预览修改和投放发布。它并不是一条只能向前的固定流水线:商品不符合预期时要调整条件,图片风格不匹配时要重新生成,页面预览不协调时要局部修改模块。

          运营目标
            → 模板与模块
            → 商品圈选
            → 图片 / 文案生产
            → 页面装配
            → 预览与修改
            → 投放

          AI 能够降低理解和生产成本,但也引入三类新的工程问题。 

          第一,自然语言不等于生产参数。“七夕轻奢箱包”没有说明价格、品牌、商品分层和坑位数量。模型如果自动补齐,会替用户做不可见的业务决策;如果系统逐项追问,AI 又会退化成效率更低的表单。 

          第二,模型决策不等于业务事实。模型可以说“圈品已完成”,工具也可以返回 success=true,但 U+ 可能只是接受了任务。真正的 datasetId 需要等待异步回调;商品数不会在生产回调中额外查询,投放结果则要等用户点击“我要投放”后才能产生。

          第三,一次连接覆盖不了完整生命周期。圈品可能持续数分钟,期间用户可能刷新页面、关闭 SSE 或修改同一字段。系统必须脱离聊天上下文保存任务状态,并能判断迟到的回调是否仍然有效。 

          因此,智能建场的目标不是“让模型输出页面”,而是: 

          把不完整的用户目标转化为可确认的生产计划,让每次工具调用都有明确边界,让跨请求结果能够恢复,并让最终页面的每个字段都可解释。

          整体设计:ReAct 决策,

          确定性系统托底

          ▐  3.1 一次建场任务如何流动

          完整链路可以概括为:

            用户输入自然语言
              → 恢复 Session / Task
              → 模板缺口审计与澄清
              → 用户确认终值或 AI 生成指令
              → 形成字段级 ProductionPlan
              → ReAct 选择圈品 / 生图 / 生文工具
              → 同步结果写入页面,异步结果登记账本
              → 前端预览并提出局部修改
              → 重新生产受影响字段
              → 用户确认完成

            这里有两条并行但不能混淆的链路:

            • 推理链路:模型根据用户目标、任务状态和工具 Observation 决定下一步;

            • 事实链路:Task 保存页面终值、待生成字段和异步终态,决定系统实际上完成了什么。 

              对话是入口,Task 才是业务事实。

              ▐  3.2 为什么采用 ReAct

              固定 Workflow 适合输入完整、路径稳定的任务,但会场生产的执行顺序取决于模板和用户选择:有的模板只需要生图,有的同时需要生图、生文和圈品;用户还可能在预览后只修改其中一个字段。如果预先为所有组合编排固定节点,流程会随着模板和场景快速膨胀。

              ReAct 适合处理这种动态决策:

                Reason:理解当前缺口与任务状态
                Action:选择并调用一个或多个工具
                Observation:读取工具结果或受理状态
                Reason:判断继续生产、请求确认还是结束本轮

                但我们没有让 ReAct 自由控制业务。模型只负责“下一步想做什么”,确定性系统负责“当前是否允许做”“参数是否合法”“结果写到哪里”。

                ▐  3.3 ReAct 与状态机如何分工

                两者职责可以用一句话区分:

                  ReAct 决定下一步做什么;状态机决定当前阶段允许做什么。

                  任务状态与工具白名单对应:

                  核心状态转移为:

                    INIT + CLARIFY_COMPLETE → RUNNING
                    RUNNING+ MATERIAL_GENERATED → WAITING_CONFIRM
                    WAITING_CONFIRM + MODIFICATION_CONFIRMED → RUNNING
                    WAITING_CONFIRM + PUBLISH_CONFIRMED → COMPLETED

                    状态门控是运行时权限,不是写在 Prompt 里的建议。即使模型判断发生漂移,也无法在需求未确认时提前圈品,或者在任务完成后继续写入。

                    ▐  3.4 模型与确定性机制的边界

                    模型适合承担: 

                    • 理解自然语言目标;

                    • 生成摘要和预填建议;

                    • 选择当前需要调用的工具;

                    • 把自然语言修改翻译为候选原子操作; 

                    • 根据工具 Observation 解释当前进展。

                     代码必须承担:

                    • 模板必填缺口审计;

                    • 任务状态迁移与工具权限;

                    •  字段坐标、下标和 Schema 校验; 

                    • 用户确认值落盘; 

                    • 工具结果写入和生产账本维护;

                    • 并发锁、CAS、fence 和异步恢复。 

                    这条边界让模型保持灵活,也让真实副作用处于业务允许的范围内。这条边界让模型保持灵活,也让真实副作用处于业务允许的范围内。换句话说,ReAct 并不直接控制业务系统,而是运行在 Agent Harness 内:模型决定想做什么,Harness 决定当前能否做、可以操作哪里,以及结果能否成为业务事实。

                    Agent Harness:把模型

                    装进可生产运行的工程外壳

                    智能建场并没有被实现成一条只会调用模型和工具的业务链路。我们把模型视为可替换的推理内核,在它之外建设 Agent Harness:由 Harness 统一管理操作人身份、Session/Task 生命周期、状态与工具权限、真实副作用、流式交互、异步续跑以及运行证据。模型提供理解和决策能力,Harness 决定这些能力能否安全进入生产。

                      start
                        └─ app:Controller、Executor、HSF Provider、业务编排
                            └─ infrastructure:Spring AI、工具实现、MetaQ、Tair、外部 SDK
                                └─ domain:任务模型、状态机、Ability、Gateway 抽象
                                    └─ common:AG-UI 协议、常量、异常与工具类
                      infrastructure → client:对外 API 契约与 DTO

                      ▐  4.1 请求、身份与流式生命周期

                      一次 Agent Run 不是匿名调用模型,而是在明确的操作人、业务场景、Session 和 Task 边界内运行。AbstractStreamingChatExecutor 统一完成“解析登录身份 → 创建或恢复 Session → 获取 Session Lock → 创建或加载 Task → 恢复消息与业务事实 → 执行 Agent → 持久化结果并释放资源”;BaseStreamingExecutor 负责 SSE 传输与生命周期。公共能力包括: 

                      • 创建和管理 SseEmitter;

                      • 900 秒连接超时与 15 秒心跳;

                      • 客户端断连、超时和异常后的 Flux 取消;

                      • 并行事件发送锁; 身份解析、会话锁和资源释放;

                      • Reactor 线程切换后的 Trace 上下文恢复。 

                      生产请求从登录上下文解析 operatorId/operatorName,Session 与 Task 查询继续携带 operatorId 校验资源归属;这属于身份解析与数据归属隔离,而不是完整 RBAC。场景 Executor 只需实现“如何重建上下文、应用输入和调用场景 Agent”,AI 设计等新场景可以直接复用这套运行壳。

                      ▐  4.2 AG-UI 事件基座

                      通用协议已经覆盖:

                        RUN_STARTED / RUN_FINISHED / RUN_ERROR
                        TEXT_MESSAGE_START / CONTENT /END
                        REASONING_MESSAGE_START / CONTENT /END
                        TOOL_CALL_START /END
                        CUSTOM

                        基础事件负责描述运行、文本和工具生命周期;场景只需定义自己的 CUSTOM 卡片。例如智能建场定义 clarification、modificationProposal 和 venueResult,AI 设计可以扩展设计方案卡、素材选择卡和画布结果卡,而无需重新设计整套流式协议。这样前端不会根据“我已经完成”之类的模型文本猜状态,而是根据工具事件、Task 结果和业务卡片驱动交互。

                        ▐  4.3 Session、Task 与状态机:管理长流程业务生命周期

                        Harness 用四类持久化对象承接一次 Agent 的完整生命周期。对话上下文可以重新构造,但 Task 中的业务事实不能依赖模型记忆:

                        状态机在这套生命周期中不是流程展示,而是运行权限系统:TaskStatus 决定动态工具白名单,ProductionPlan 决定可操作字段,CAS 保证旧请求不能覆盖新阶段。当前实现提供 operatorId 归属隔离和环境隔离,不将其泛化为尚未建设的角色权限平台。

                        ▐  4.4 Tool Runtime:让工具成为受治理的生产权限

                        AbstractStreamingAgentGateway 与 StreamingToolCallHook 共同构成 Tool Runtime:先按状态过滤工具并包装 ToolCallback,再完成坐标预检、Run 级原子防重、TOOLCALLSTART/END、工具计数、dependency.log 与 toolcalllog 留痕;执行完成后,在 Task 锁内委托 ToolResultPostProcessor 写入业务事实,最后进行模型表述与真实轨迹的一致性审计。Prompt 约束模型的行为倾向,Tool Runtime 约束真实执行权限。 失败且未产生副作用时,Runtime 可以撤销轮内坐标并允许有限重试;同一工具连续失败达到阈值后本轮熔断。只读或幂等工具可以在审计命中时安全重放,圈品、生图等生产型副作用工具不能因为模型声称“已完成”而自动补执行。 智能建场只需提供圈品、生图、生文和修改提案等场景工具,以及 VenueToolResultProcessor 和业务卡片映射;ToolContext 直接携带模板、当前结果、账本、圈品记录与 ProductionPlan,避免让 LLM 搬运大 JSON。AI 设计可以复用同一个 Runtime,把图片、图层或设计方案写入自己的结果模型。工具因此不是模型随意调用的函数列表,而是 Harness 管理的业务动作与生产权限。

                        ▐  4.5 异步运行时、运行证据与场景复用

                        Harness 将“一次 Agent Run”与“完整业务任务”解耦。同步 Run 只登记外部任务已经受理,Tair 保存回调上下文,SSE 可以结束;MetaQ 到达后重新加载 Task,在 Task Lock 内修改事实,并通过 createBizId fence 判断结果是否仍代表当前用户意图。它不仅适用于 U+ 圈品,也可以承接异步生图、视频生成和批量设计。 运行证据同样属于 Harness:AgentRunLog 记录 Run、TTFT、Token、工具次数、熔断与审计;toolcalllog 记录真实工具输入输出;dependency.log 聚合 LLM、TOOL、HTTP、HSF、TAIR、METAQ 等依赖耗时和错误;Trace 串联 HTTP、Reactor、工具线程与回调线程。一个新场景主要需要扩展:

                        可直接复用:

                        因此,这套工程的定位不只是“智能建场后端”,而是以智能建场为首个生产场景沉淀的一套 Agent Harness。模型决定能力上限,Harness 通过身份、会话、状态、工具、副作用、异步恢复和观测能力,守住生产运行的可信下限。

                        工具设计:把底层接口

                        转化为 Agent 可用的业务动作

                        ▐  5.1 为什么不能直接暴露底层接口

                        底层服务通常围绕系统能力设计:创建圈品任务、查询预览商品、调用生图接口。模型需要的却是围绕业务目标设计的动作,例如“为指定模块坑位圈选商品”。因此场景工具不会直接暴露底层接口,而是以业务语义接入 Harness 的 Tool Runtime;Runtime 再统一处理状态权限、坐标校验、调用留痕、副作用和结果后处理。 因此,工具设计遵循三个原则: 

                        1. 一个工具表达一个模型可理解的业务意图;

                        2.  参数只保留完成该意图所需的最小信息;

                        3.  外部调用编排、协议转换和结果校验封装在工具内部。

                        ▐  5.2 五个核心工具如何协作

                          analyzeRequirements
                            识别模板缺口并生成澄清卡
                          selectProducts
                            将用户确认的条件提交给 U+,返回异步受理结果
                          generateImage
                            结合生成指令、x-format 和 x-reference 生成图片
                          generateCopy
                            结合用户意图与 ai_description 生成文案
                          proposeModification
                            将自然语言修改翻译为待确认的原子操作

                          这些工具并不直接组成固定流水线,而是由 ReAct 根据 Task 状态、ProductionPlan 和上一轮 Observation 动态选择。

                          ▐  5.3 工具参数如何收敛到业务坐标

                          所有生产型工具都需要携带统一坐标:

                            moduleUuid + moduleName + slot + key + index
                            • moduleName 定位模块类型;

                            • moduleUuid 区分同名模块实例;

                            • slot 定位 Schema 资源位;

                            • key 定位字段;

                            • index 定位数组中的具体一组。

                            模型不是自由编造坐标,而是从 ProductionPlan 中选择。工具侧再次校验该坐标是否属于模板和本轮计划,工具后处理也按相同坐标写入结果。

                            ▐  5.4 工具结果同时服务三类消费者

                            工具结果不是只给模型读的一段文本,它同时服务: 

                            • ReAct:作为 Observation 判断下一步; 

                            • Task:由后处理器写入终值或过程状态; 

                            • 前端:通过工具事件和 venueResult 展示真实进度。 

                            例如 selectProducts 返回 createBizId 后:模型观察到“已受理”,Task 把坐标置为 GENERATING,前端显示“正在圈品”。三者共享同一个事实,但呈现方式不同。

                            ▐  5.5 按副作用设计错误和重试

                            工具被分为三类: 

                            • 只读/提案工具:如 analyzeRequirements、proposeModification,可在安全条件下重放;

                            • 同步生产工具:如生图、生文,失败且未产生副作用时可有限重试; 

                            • 异步副作用工具:如圈品,受理后不能因等待或本地异常机械重提。 

                            错误协议需要表达:发生了什么、是否已经产生副作用、能否重试、需要用户修改什么。统一返回“调用失败”会诱发模型盲目重试。

                            需求进入系统:

                            从一句话到字段级生产计划

                            ▐  6.1 先审计模板,再询问用户

                            前端首次请求携带 templateId、templateSchema 和类型化 content:

                              {
                                "sessionId": null,
                                "taskId": null,
                                "templateId": "template-id",
                                "templateSchema": "{...}",
                                "content": [
                                  {
                                    "type": "text",
                                    "text": "帮我搭一个七夕轻奢箱包会场"
                                  }
                                ]
                              }

                              系统不会把整个模板交给模型后让它自由判断缺失项,而是先根据模板必填模块、need_clarify 字段和当前 renderResult 做确定性裁剪。LLM 只负责理解用户表达、生成摘要和提供预填建议。 这解决了两个问题:一是必填字段不会因为模型漏判而消失;二是模型服务失败时仍可退化为一张空白澄清卡,不让完整链路中断。

                              ▐  6.2 澄清卡是输入协议,不只是交互组件

                              澄清卡下发内容包含需求摘要、缺失字段、已识别字段和预填值。其中 missingFields 与模板 Schema 同构,前端无需再次回查模板即可渲染表单。 用户提交时使用 value + fillMode 双树:

                                {
                                  "type": "clarification",
                                  "values": [
                                    {
                                      "moduleName": "alimod-tmg-act-feeds-v1",
                                      "value": {
                                        "tabFeedsList": [
                                          {
                                            "tabName": "轻奢箱包",
                                            "displayId": "选择轻奢箱包类目商品"
                                          }
                                        ]
                                      },
                                      "fillMode": {
                                        "tabFeedsList": [
                                          {"displayId": "ai"}
                                        ]
                                      }
                                    }
                                  ]
                                }
                                • manual 或缺省:同坐标值是终值,直接写入 renderResult;

                                • ai:同坐标值是生成指令,登记到 pendingGenerations。

                                用户确认值不再交给外层 LLM 二次解释。对圈品尤其重要:tabName 只负责展示,用户没有填写的价格、爆品、商品分层不能被静默加入真实条件。卡片所见即工具所执行。

                                ▐  6.3 从确认结果生成 ProductionPlan

                                确认完成后,系统审计还缺哪些可自动生产的字段,并生成 ProductionPlan。每一项计划包含:

                                  字段坐标
                                  operationType       image / text / product
                                  imageSize           从 x-format 解析
                                  referenceImageUrls  从 x-reference 获取
                                  description         用户确认的生成指令
                                  aiDescription       模板固有生产约束
                                  optional            是否允许自动生成
                                  description 和 aiDescription 刻意分离:前者代表用户这一轮想要什么,后者代表模板长期要求的尺寸、字数和风格边界。用户填写新指令不能覆盖模板约束。

                                  当账本中存在待生产项时,只为 PENDING 项生成计划;账本整体为空时才允许根据 Schema 构造全量计划。若账本中只有 GENERATING 或 FAILED,不能回退到全量扫描,否则会再次生成正在执行或已经失败的字段。

                                  素材生产:

                                  ReAct 如何协调圈品、生图与生文

                                  任务进入 RUNNING 后,模型获得 ProductionPlan、当前 renderResult、账本状态和允许使用的工具。ReAct 根据字段类型选择工具,可以串行执行存在依赖的动作,也可以并行执行互不依赖的素材。

                                  ▐  7.1 生图:用户意图与模板约束共同生效

                                  generateImage 使用用户确认的生成指令作为内容目标,从 Schema 的 x-format 获取图片尺寸,从 x-reference 获取参考图。工具把这些信息转换成下游设计服务需要的参数,并在结果中带回图片 URL 和完整字段坐标。 结果后处理不依赖模型复述,而是直接:

                                  校验坐标
                                    → 定位 renderResult 中的模块和字段
                                    → 写入图片 URL
                                    → 从 pendingGenerations 销账
                                    → 保存最新 Task

                                  因此,即使多个生图工具并行结束,结果也能写入各自位置。

                                  ▐  7.2 生文:内容要求与生产约束正交

                                  generateCopy 将用户生成指令和 Schema ai_description 分开传给 Prompt。例如用户要求“写一条轻奢感七夕文案”,模板仍可要求“8~12 字、不得换行”。两类信息共同约束结果,而不是相互覆盖。 成功文案按坐标写入 renderResult,并移除相应待生成项。工具结果中的纯文本不会再次 JSON 序列化,避免页面出现额外引号。

                                  ▐  7.3 选品:同步阶段只接受任务,不伪造终值

                                  selectProducts 校验目标坐标后,将用户可见的条件提交给 U+。同步阶段只返回受理状态、createBizId 和选品上下文,并不向 renderResult 写入 displayId。

                                  后处理器把账本项置为:

                                    {
                                    "status":"GENERATING",
                                    "createBizId":"biz-xxx",
                                    "errorMsg":null,
                                    "datasetId":null
                                    }

                                    这一设计明确区分: 

                                      工具调用成功 ≠ 圈品业务完成 ≠ 页面终值已写入

                                      ReAct 得到的 Observation 是“任务已经受理”,不应在同一轮重新提交;前端看到的状态是“正在圈品”,而不是“圈品成功”。

                                      ▐  7.4 结果汇聚为唯一页面事实

                                      Task.resultJson 中三类数据各司其职:

                                      “正在生成”这类中间态不会写进页面终值。后端从账本聚合 moduleStates:模块内任一字段在途则为 GENERATING;无在途但存在失败项则为 FAILED。前端因此无需理解字段级编排,也能正确显示模块状态。

                                      异步圈品:如何跨越一次

                                      ReAct 和 SSE 生命周期

                                      ▐  8.1 为什么不能让 Agent 原地等待

                                      U+ 圈品耗时可能达到分钟级。让 ReAct 在线程内轮询,会长期占用连接,并在超时后留下“不知道外部是否已经执行”的不确定状态;若模型因此自动重试,还可能创建多个真实圈品任务。 因此,异步圈品采用两段式执行。

                                      ▐  8.2 第一段:同步受理

                                        Agent 调用 selectProducts
                                          → 标准化用户确认的圈品条件
                                          → U+ 返回 createBizId
                                          → 回填上下文写入 Tair
                                          → 账本坐标置 GENERATING
                                          → 本轮 SSE 可以正常结束

                                        Tair 中保存回调继续执行所需的 Task、字段坐标和选品上下文。回调不依赖原来的模型上下文或 SSE 连接。

                                        ▐  8.3 第二段:MetaQ 回调续跑

                                          U+ MetaQ 回调
                                            → 根据 createBizId 读取上下文
                                            → 获取 Task 级锁
                                            → 在 pendingGenerations 中查找受理号
                                            → 回填业务终值
                                            → 移除对应账本项
                                            → 写入 selectionRecords
                                            → 保存 Task 并释放锁

                                          生产回调先校验 sessionId 与 datasetId:缺失时把账本和 selectionRecords 标为 FAILED;成功时直接使用回调 datasetId 清账并写入 COMPLETED 记录。回调侧只更新业务事实,不直接驱动任务状态机,任务阶段仍由正常对话编排推进。

                                          ▐  8.4 fence 如何处理迟到回调

                                          用户可能在圈品等待期间修改同一字段。此时新操作调用 resetToPending,清空旧 createBizId 并登记新的生成指令。旧回调到达后无法在账本中命中受理号,被判定为已被新操作取代并丢弃。

                                          这是一种面向业务坐标的 fence:不要求外部回调严格有序,只要求结果写入前仍然代表当前用户意图。

                                          ▐  8.5 前端轮询与刷新恢复

                                          前端收到 moduleStates=GENERATING 后,整模块显示“正在圈品”占位,并按 10~30 秒查询:

                                            GET/venueast/json/result?sessionId=123&operatorId=xxx
                                            moduleStates 清空后停止轮询。即使用户刷新页面,也可以从 Task 恢复 renderResult、在途状态和圈品明细;连接不再是任务的事实来源。

                                            结果交付:前端如何

                                            看到真实生产进度

                                            ▐  9.1 一次 SSE 运行

                                            主入口为:

                                              POST /venueast/chat/stream
                                              Content-Type: application/json
                                              Accept: text/event-stream

                                              SSE 连接超时 900 秒,每 15 秒发送心跳。客户端断连、超时、异常和正常完成都会取消上游 Flux、停止心跳并释放会话锁。

                                              一次运行以 RUN_STARTED 开始,以 RUN_FINISHED 或 RUN_ERROR 结束。文本和 Reasoning 使用独立 messageId 聚合,工具事件按 toolCallId 配对。

                                                RUN_STARTED
                                                  → TEXT / REASONING 增量
                                                  → TOOL_CALL_START ... TOOL_CALL_END
                                                  → CUSTOM 业务卡片
                                                  → TEXT_MESSAGE_END
                                                  → RUN_FINISHED

                                                同名工具可以并行执行,前端不能按 toolName 配对,否则两个 generateImage 的开始与结束可能错位。

                                                ▐  9.2 三类信息必须分开

                                                前端需要区分: 

                                                1. 模型说明:自然语言解释,帮助用户理解; 

                                                2. 工具事件:表示工具函数开始和结束; 

                                                3. 业务卡片:表示用户可操作或页面可消费的结构化事实。 

                                                三个核心 Custom Event 为:

                                                • clarification:澄清卡;

                                                • modificationProposal:修改确认卡;

                                                • venueResult:会场结果。

                                                • venueResult 示例:

                                                  {
                                                    "type":"CUSTOM",
                                                    "name":"venueResult",
                                                    "value":{
                                                      "taskId":456,
                                                      "taskStatus":"WAITING_CONFIRM",
                                                      "renderResult":[],
                                                      "pendingGenerations":[],
                                                      "moduleStates":[],
                                                      "selectionRecords":[]
                                                    }
                                                  }

                                                  前端以 renderResult 渲染终值,以 moduleStates 决定模块占位和轮询,以 selectionRecords 展示标准化条件、tab 名称、圈品链接、datasetId、后续创建的 displayId 和失败原因。

                                                  ▐  9.3 运行结束不等于异步任务结束

                                                  RUN_FINISHED 表示本轮 Agent 调用结束,前端需要保存最新的 sessionId/taskId/currentStep,但不能因此停止仍在执行的圈品轮询。是否继续轮询由 moduleStates 决定。

                                                  这个语义拆分让同步对话和异步生产能够共享一个界面,同时避免用模型文本猜测真实状态。

                                                  人机协同:局部修改,

                                                  而不是重新生成整页

                                                  用户看到预览后,常见诉求不是“全部重做”,而是“把第二个模块的主图换成更轻奢的风格”或“删除第三个商品分组”。这要求系统理解自然语言,同时保护已经确认的其他结果。

                                                  ▐  10.1 ReAct 先生成提案,不直接修改

                                                  在 WAITING_CONFIRM 状态,模型通过 proposeModification 将自然语言翻译为三类原子操作:

                                                    APPEND_ITEM   向数组资源位追加若干组
                                                    UPDATE_FIELD  更新字段终值或登记新的生成指令
                                                    REMOVE_ITEM   删除指定数组项

                                                    修改提案同时携带 moduleUuid、字段坐标、当前值、建议值、字段标题和 Schema 定义。后端先校验模块实例、数组下标和操作冲突,再通过 modificationProposal 卡片交给用户确认。

                                                    ▐  10.2 确认后的操作不再由模型解释

                                                    前端把用户确认或微调后的 operations 以 modification 内容部件回传。应用层按确定性顺序执行:

                                                      APPEND_ITEM → UPDATE_FIELD → REMOVE_ITEM

                                                      manual 修改直接写入 renderResult;ai 修改重置对应账本项为 PENDING。系统只为受影响坐标生成新的 ProductionPlan,已经确认的其他商品、图片和文案保持不变。

                                                      ▐  10.3 不确定时不猜测

                                                      当用户说“换一下那张图”但无法唯一定位模块,或者操作存在下标越界、同一资源位互斥修改时,服务端把原因放入 rejected,要求用户确认目标。生产系统宁可多一次确认,也不让模型猜测修改真实页面。

                                                      Harness 可靠性治理:

                                                      约束 ReAct 的不确定性

                                                      ReAct 提供动态决策能力,也会带来重复规划、参数漂移和语言结果与真实执行不一致等风险。可靠性治理的目标不是限制模型思考,而是防止一次模型抖动演变成业务事故。

                                                      ▐11.1 重复调用需要识别业务坐标

                                                      同一轮可能合法地为多个模块调用 generateImage,因此防重不能只看工具名。真正的业务键是:

                                                        toolName + moduleUuid + moduleName + slot + key + index

                                                        以 Run 级 Concurrent Set 对生产坐标做原子 check-and-add,并由 StreamingToolCallHook 在执行前统一预检。治理分为三层: 

                                                        • 执行层:同坐标在途或已成功时,不再次产生副作用;

                                                        •  观测层:重复决策仍写入 tool_call_log,记录参数与拦截原因; 

                                                        • 交互层:没有真实执行的拦截,不显示成一张“已执行工具”卡。 

                                                        首次执行在未产生有效结果时会撤销 Run 内坐标登记,允许有限重试;同一工具连续失败 2 次后在本轮熔断,防止模型换措辞无限调用。跨轮则由 pendingGenerations 的 GENERATING 状态将已受理坐标排除出 ProductionPlan。异步圈品已经受理后不释放坐标,避免在 U+ 重复创建任务。

                                                        ▐  11.2 三类并发使用不同机制

                                                        系统同时面对:同一会话的多轮请求、同一轮的并行工具、工具线程与 MetaQ 回调。对应机制为: 

                                                        • Session 分布式锁:同一 sessionId 只允许一轮对话;冲突时返回 SESSION_BUSY;

                                                        • Task 级锁:串行化工具后处理与异步回调对同一 resultJson 的读改写;

                                                        •  CAS 状态迁移:只有旧状态符合预期才推进,避免旧请求覆盖新阶段; 

                                                        • SSE 发送锁:防止并行工具事件破坏帧顺序;

                                                        •  createBizId fence:阻止过期回调覆盖用户新操作。

                                                        锁解决并发执行,CAS 解决状态迁移,fence 解决跨时间结果有效性,它们不能互相替代。

                                                        ▐  11.3 失败不是一个布尔值

                                                        错误协议需要告诉 ReAct:是否已经产生副作用、能否重试、需要修改什么输入,而不是只返回“失败”。

                                                        ▐  11.4 模型表述与业务事实需要审计

                                                        模型可能在 WAITINGCONFIRM 状态声称“已经生成修改确认卡”,但本轮实际没有调用 proposeModification。最新实现把一致性审计收敛到 AbstractStreamingAgentGateway:会场子类只声明判定策略;命中“宣称已执行但轨迹缺失”时,框架通过包装后的 ToolCallback 自动重放 proposeModification,使 TOOLCALL 事件、日志、结果捕获和卡片分发仍走原链路,重放失败则补发纠偏文本。

                                                        只读工具可以在明确条件下重放,有副作用的生产工具不能因为模型说“已完成”而补执行。判断依据永远来自 Tool Trace 和 Task,而不是自然语言。

                                                        ▐  11.5 可观测性连接完整因果链

                                                        一次任务需要串联:

                                                          sessionId → taskId → runId → toolCallId
                                                          └→ createBizId → datasetId → displayId

                                                          消息时间线记录用户和助手看到的事件,tool_call_log 记录模型实际调用,dependency.log 记录 TOOL、LLM、MetaQ 等外部依赖的耗时与错误类型,AgentRunLog 记录一次 Run 的 TTFT、token usage、工具次数、终态和是否触发熔断;

                                                          EagleEye/Sunfire Trace 连接 HTTP 请求、Reactor 调度线程、工具线程与回调线程。故障定位最终需要回答:参数来自哪里、工具是否真实执行、是否被防重或熔断、是否产生副作用、结果写入哪个坐标、回调为何命中或被丢弃。

                                                          完整案例:七夕轻奢箱包会场

                                                          下面用一个案例串起前述设计。

                                                          ▐  12.1 用户目标与模板缺口

                                                          用户输入: 

                                                          帮我搭一个七夕轻奢箱包会场。

                                                          模板中的商品模块包含 tabName 和 displayId,素材模块还包含图片和文案字段。系统首先审计模板,识别哪些字段需要用户确认,哪些字段允许自动生成。 

                                                          对于商品模块,可确认内容为:

                                                            tabName = 轻奢箱包
                                                            selectiondescription= 选择轻奢箱包类目商品
                                                            价格 / 爆品 / 商品分层 = 空

                                                            “七夕”可以帮助生成页面氛围和素材,但不会被暗中扩展为用户未确认的商品指标。澄清卡展示的选品描述,就是后续工具实际使用的描述。

                                                            ▐  12.2 用户确认与计划生成

                                                            用户提交澄清卡后:

                                                              tabName(manual)
                                                                → 写入 renderResult
                                                              displayId 描述(ai)
                                                                → 写入 pendingGenerations
                                                              图片 / 文案生成指令(ai)
                                                                → 写入各自字段账本

                                                              完整性审计通过后,Task 从 INIT 进入 RUNNING。ProductionPlan 为每个待生产字段生成坐标、工具类型与约束。

                                                              ▐  12.3 ReAct 执行生产

                                                              模型根据计划调用:

                                                                selectProducts → 商品模块 displayId 坐标
                                                                generateImage  → 主图坐标
                                                                generateCopy   → 标题或利益点坐标

                                                                生图和生文返回后立即按坐标写入页面;圈品返回 createBizId 后,商品模块进入 GENERATING。本轮 Agent 可以完成,前端仍继续展示圈品占位。

                                                                ▐  12.4 异步回填与页面恢复

                                                                MetaQ 回调到达后,Listener 根据 createBizId 命中账本,在 Task 锁内直接采用回调 datasetId、销账并保存 selectionRecords。前端下一次轮询看到 moduleStates 清空,恢复商品模块并展示圈品规则链接与 datasetId。displayId 等到用户点击“我要投放”后再创建和回填。

                                                                如果用户刷新页面,所有信息仍由 Task 恢复,不依赖上一条 SSE 连接。

                                                                ▐  12.5 局部修改与再次生产

                                                                用户提出:“第二个模块图片换成更轻奢、留白更多的风格。” 

                                                                proposeModification 生成目标模块图片字段的 UPDATE_FIELD 提案。用户确认后,该字段重新登记为 PENDING,Task 返回 RUNNING;新一轮只调用一次 generateImage,其他商品和文案保持不变。 

                                                                如果用户在圈品回调前修改选品条件,旧受理号被清理;旧回调到达时无法命中账本,不会覆盖新条件。

                                                                ▐  12.6 案例背后的工程含义

                                                                这条链路体现的不是某一个 Prompt 技巧,而是多种机制共同工作:

                                                                  澄清协议保证输入可见
                                                                  状态机约束执行阶段
                                                                  ProductionPlan 约束工具范围
                                                                  字段坐标保证结果位置
                                                                  任务账本表达生产过程
                                                                  MetaQ + fence 处理异步结果
                                                                  AG-UI 让前端消费真实状态

                                                                  任何一环只依赖模型自觉,都会把不确定性传递到真实业务。

                                                                  效果与评测:

                                                                  如何判断会场真的搭好了

                                                                  ▐  13.1 单节点能力评测

                                                                  ▐  13.2 Tool Trace 轨迹评测

                                                                  最终页面相似,不代表执行过程同样可靠。轨迹评测需要检查:

                                                                  • 是否在正确状态调用允许的工具; 

                                                                  • 工具参数是否来自用户确认或可信 Task; 

                                                                  • 是否添加了用户未提供的圈品条件;

                                                                  •  是否对同一坐标重复调用;

                                                                  •  异步受理后是否错误重提; 

                                                                  • 结果是否写入正确字段;

                                                                  •  需要人工确认时是否越权继续执行

                                                                  总结与后续规划

                                                                  ▐  14.1 总结

                                                                  智能建场实践形成了几个核心判断:

                                                                  1. ReAct 负责动态决策,状态机负责业务边界。 两者结合才能同时获得灵活性和可控性。

                                                                  2. 工具是业务动作和生产权限,不是底层接口列表。 参数、结果和错误都要围绕模型决策设计。 

                                                                  3. 用户确认必须进入确定性通道。 澄清卡和修改卡是协议边界,而不是 UI 装饰。

                                                                  4. Task 才是业务事实。 页面终值、生产过程和异步结果必须结构化持久化。 

                                                                  5. 前端协议属于 Agent 能力。 没有事件、卡片和恢复机制,长流程 Agent 无法形成稳定体验。

                                                                  6. 通用基建决定场景扩展成本。 流式执行、事件协议、工具框架、会话任务、异步回调和观测能力可以继续支撑 AI 设计及其他生产场景。

                                                                  7. 数据效果观测体系搭建。投放后的会场数据(业务使用情况、投放会场A+数据)要有迹可循。 

                                                                  进一步看,模型决定 Agent 的能力上限,Harness 则通过身份、会话、状态、工具、副作用、异步恢复和运行证据守住生产可信下限。

                                                                  ▐  14.2 后续规划

                                                                  • 知识库沉淀与智能复用:目前已接入A+离线表,可获取每个会场的PV、UV等核心数据,据此沉淀优秀会场、选品策略、素材风格和人工修改记录知识库,为智能建场更智能提供知识基础,同时为后续自迭代提供支撑

                                                                  •  场景纵深扩展: 

                                                                    • 投放后的会场接入智能巡检功能,以此判断会场利益点透出、feeds流、版头等内容是否正常渲染 

                                                                    • 新增更多类型的导购页面模板和素材(指南会场优化、魔切模块、商家模块等),覆盖更多运营场景下的页面搭建与投放需求 方舟会场能力共建,推动方舟侧基于国际诉求定制对应智能搭建模块和功能 

                                                                  • 操作自闭环:

                                                                    •  当前确认投放后还是会经过斑马进行发布,后续支持一站式完成投放,无需再跳转斑马 

                                                                    • 支持会场复制新建/投放后修改 

                                                                  • 内容化素材生成 

                                                                    • 结合运营主题与商品信息(标题、卖点、价格权益等),自动生成具有营销感的宣传文案建议及配套模块样式 

                                                                    • 支持按活动氛围调整文案风格,运营可直接采用或在建议基础上微调,减少重复撰写成本 

                                                                  AI 智能建场的价值,不是把人工后台换成聊天窗口,而是把自然语言目标工程化为一条可确认、可执行、可恢复、可评估的生产链路。

                                                                  模型负责理解和规划,协议负责协作,状态机负责边界,工具负责执行,Task 与事件负责将长流程沉淀为可信的业务事实。 

                                                                  团队介绍

                                                                  本文作者宸雾、入风,来自淘天集团-天猫国际技术团队。团队聚焦跨境进口电商场景,负责覆盖"人、货、关、仓、税、汇、服"全链路的技术业务,包括进口特色导购与内容种草、跨境交易与支付结算、商品经营与营销定价、全球直采与保税仓/海外仓供应链履约、BC/CC 清关与合规风控等,持续建设面向跨境进口场景的高并发、强合规与高稳定性能力。同时,团队探索 Agent 如 AI 客服与导购、AI 商品运营、AI 商家运营、AI 关务、AI 供应链在业务中的规模化应用,推动进口全链路运营效率与履约体验的智能化升级,为中国消费者提供更丰富、更可靠的全球好物消费体验。

                                                                  跳转微信打开

                                                                  •  

                                                                  让 AI 看得见、判得准、改得对—— D2C 从设计稿到三端真机达标的自动化实践

                                                                  原创 用户&内容技术 2026-11-02 11:47 浙江

                                                                  给 AI 装上眼睛,让设计稿自动变真机代码。

                                                                  图片

                                                                  本文介绍了 D2C(设计稿到代码)在移动端自动化落地的实践方案。针对 AI 生码后无法感知真机渲染效果、难以自我验收的痛点,团队构建了一套端上 UI Harness 体系,通过 Loop Engineering 让 AI 实现“生码-编译-三端真机验证-自动修复”的全流程闭环。核心思路是重新划分程序与 AI 的边界:将确定性流程下沉至 CLI 骨架执行,AI 仅保留少量推理决策点;同时结合像素 diff、DOM 树对比等多层信号融合技术为 AI 装上“眼睛”,并辅以交叉验证与独立门禁防止假交付。该方案已打通 DX、Weex、Muise 三条链路,用户只需提交设计稿即可全自动完成达标交付,并沉淀了五条可迁移的 Agent 工程化方法论。

                                                                  图片

                                                                  开场 · 一个现实的问题

                                                                  先抛一个问题:

                                                                  AI 已经能一句话生一张UI卡片代码,但你敢直接把 AI 生出来的代码提测上线吗?

                                                                  大概率不敢,因为你大概率经历过这样的场景:AI 信心满满地报告"卡片已完成",你推到真机一看——布局错位了、badge 圆角被截了、价格符号 ¥ 和数字没对齐、 一端上正常但另一端上文字截断了。

                                                                  AI 不知道自己写错了。它没有眼睛,看不到真机上渲染出来到底是什么样。

                                                                  背景 · AI 生码之后,谁来验收?

                                                                  AI 会写代码,这在 2026 年已经不是新闻。真正的问题是:AI 写完之后,谁来验收?

                                                                  行业正在形成一个共识:Agent = Harness + LLM —— 光有模型能力远远不够,Agent 能不能可靠工作,取决于外面套的那层工程脚手架(Harness)。而这层脚手架的质量,可以拆成三件事:

                                                                  质量 = 输入约束 × 生成约束 × 验证闭环

                                                                  • 输入约束:给 AI 看什么上下文(读懂项目代码、拿到设计稿数据、了解业务规则)

                                                                  • 生成约束:让 AI 按什么规范写(编码规范、组件复用、目录约定)

                                                                  • 验证闭环:AI 写完之后,自己知道对不对、能自己迭代修复

                                                                  前两项,业界已经有相对成熟的方案。但第三项 —— 验证闭环 —— 在移动端是断的。

                                                                  Web 端早就闭合了这个环:Playwright 跑截图、Chrome DevTools 拿日志、Headless Browser 做回归 —— AI 生完码,自己跑一遍就知道对不对。但移动端呢? AI 写完一个 DX 卡片或 Weex 组件,它看不到真机上渲染成什么样、判不了对和错、更不会自己迭代优化。

                                                                  具体到 D2C(Design to Code)场景,断裂带体现为三个具体问题:

                                                                  • 问题一 · AI 生完码就"闭眼交卷"  拿不到真机截图、判不了视觉还原度、不会自己迭代修复。常常"看起来 OK"就交付 —— 结果 badge 圆角被截了、暗黑模式颜色错了、鸿蒙上文字截断了。AI 自己完全不知道。

                                                                  • 问题二 · 三端渲染差异靠人肉  iOS、Android、鸿蒙 的字体栅格化、单位换算(px / dp)、暗黑模式行为各不相同 —— 同一份代码在三端上渲染出来是三个样子,上线前必须人工三端都验一遍,AI一个验证不了。

                                                                  • 问题三 · 端上 UI 技术栈碎片化  团队业务同时跑着 多套渲染框架,每接一条链路,都要从零造一遍验证工具 —— 工作量比较大。

                                                                  这些都不是模型能力问题,是 Harness 工程问题 —— 验证闭环这一环,在移动端比较缺失。

                                                                  所以我们决定做一件事:建一个 D2C Harness 打通三端真机验证闭环 —— 让 AI 自己看到真机、自己判断对不对、自己改到达标。把移动端的验证断裂带,像 Web 端一样闭合起来。

                                                                  AI 生码不难,难的是让 AI 自己知道自己写对了 —— 这就是验证闭环。

                                                                  结果

                                                                  过去一段时间,我们做了一件事:把 D2C 从"设计稿生完码就结束",升级到"从设计稿出发,AI 一路自己走完生码、编译、三端真机验证,直到视觉还原达标"。

                                                                  用户使用方式:内部研发平台创建Issue ,贴设计稿链接 和代码仓库,剩下的 AI 自动完成 —— 生码、编译、三端真机截图、diff 对比、迭代修复、代码提交 —— 全程不需要人。   

                                                                  ▐  3.1 真机交互体验

                                                                  ▐3.2 UI优化页面

                                                                  设计思考 · 不只是生码工具,

                                                                  而是一套端上 UI 的 Harness 体系

                                                                  如果 D2C 只是一个生码工具,那 AI 生完码就结束了,剩下的编译、预览、验证、修复全靠人——断裂带还是断的。

                                                                  我们要做的不是"更好的生码工具",而是一套面向端上 UI 的 Harness 体系——把 AI 生码之后的所有环节都工程化地闭合起来:

                                                                  环节

                                                                  AI 自由发挥能做到吗

                                                                  Harness 做什么

                                                                  编译

                                                                  能写代码,但编译报错了不一定能自己修

                                                                  编译门禁 + 自动重试 + 结构化错误反馈

                                                                  真机预览

                                                                  看不到真机

                                                                  三端云真机自动推送 + 组件级截图

                                                                  视觉验证

                                                                  说不清"像不像"

                                                                  像素级 diff + 热力图 + 90 分硬门槛

                                                                  修复迭代

                                                                  不知道哪里错、改完不知道有没有改好

                                                                  AI 看 diff → 改码 → 再验 → 回退保护

                                                                  交付

                                                                  可能提前宣称"完成了"

                                                                  门禁校验 + 自动 CR + 交付报告

                                                                  ▐4.1 传统 D2C vs 我们的 D2C

                                                                  维度

                                                                  过去的做法

                                                                  我们的做法

                                                                  输入要求

                                                                  切好的设计稿 · 图层命名规范

                                                                  给人看的 PRD + 设计稿链接

                                                                  验证方式

                                                                  H5 模拟预览

                                                                  三端真机截图 + 像素级 diff

                                                                  还原度判断

                                                                  人肉看"差不多就行"

                                                                  硬门槛 · 不达标自动迭代

                                                                  修复方式

                                                                  人工修改 → 重新生成

                                                                  AI 看 diff 热力图 → 改码 → 重新验证

                                                                  交付物

                                                                  一份代码

                                                                  代码 + 三端截图 + diff 报告 + CR

                                                                  运行方式

                                                                  人坐在 IDE 前操作

                                                                  Issue 驱动 · 全自动 Agent

                                                                  ▐4.2 让 AI 少做事 · 结果反而更可靠

                                                                  我们踩过一个坑:一开始,我们把所有步骤写进一份近千行的 SKILL 说明书,让 AI 照着一步步执行。逻辑很自然——步骤写得越细,AI 应该做得越好,对吧?

                                                                  结果恰恰相反:

                                                                  • 漏步骤率 ~30%:明确写了"按 1→2→3→…→9 执行",AI 实际跑的是 1→2→4→7→9

                                                                  • 幻觉式完成:AI 自信地输出"步骤 3 已完成",但实际从未调用对应工具

                                                                  • 2 小时白干:其中 40 分钟卡在"等截图超时"——这种事根本不需要 AI 判断,一个 if file.exists() 就够了

                                                                  根因只有一句话:把确定性流程塞进了概率性 prompt。

                                                                  我们回头分析那份 SKILL,发现 大部分的内容是流程编排——分支切换、编译重试、URL 管理、截图轮询——这些操作的容都是可以固化为程序代码的。但我们把它们交给了一个本质上是"大概率会照做"的概率系统。

                                                                  CLI化改造

                                                                  改造的本质是让AI不那么听话也能得到正确结果

                                                                  我们做了什么 —— 把原 74 个决策点里的 66 个确定性步骤从 SKILL 说明书下沉到 CLI 命令 · 状态持久化到磁盘(上下文压缩、中断、重启都不影响) 。分清 AI 与程序的边界 —— 确定性流程固化到程序,AI 只做真正需要推理的事。

                                                                  AI 做(容错空间大 · 需要推理)

                                                                  下沉到 CLI(零容错空间 · 要求 100%)

                                                                  流程调度 · 基于 CLI stdout 的 hint 决定下一步走哪个命令(verify / iteration / done / finalize)

                                                                  环境检测 · 分支切换 · AST 拉取

                                                                  分析设计稿 AST 结构 · 推理布局方案

                                                                  编译 · 重试计数 · 多层门禁

                                                                  按 checklist 审查代码

                                                                  预览截图 · diff 打分 · 回滚判定

                                                                  看截图判断视觉 bug

                                                                  状态持久化 · 报告生成 · CR 提交

                                                                  编辑 TSX/CSS 修复

                                                                  通过 stdout hint 引导 AI 下一步 · 流程调度不靠 AI 记忆

                                                                  AI 漏步骤 / 假交付怎么办? —— 两层机制拦截:

                                                                  • 每步执行前 — CLI 前置校验 state , AI 若跳过 verify 直接跑 done CLI 立即 exit 3 + stdout 打 "必须先跑 verify" ,漏步骤根本执行不下去。

                                                                  • AI 声称"完成"时 — Stop Hook 最终校验交付契约(pxdiff 达标 / real_bugs=0 / MR 已建 / CDN URL 等等) 不满足则反注入指令让 AI 继续跑 ,假交付根本 stop 不了。

                                                                  流程调度靠 AI · 校验靠 CLI 前置 + Stop Hook 兜底 —— 不寄希望于 AI 自觉把"AI 会不会漏"变成"CLI 会不会放行"。

                                                                  具体链路实现 · 让 AI 写对

                                                                  三条链路大体流程是类似的,这里就用D2Weex 为例具体介绍下。

                                                                  ▐5.1 D2Weex整体架构一览

                                                                  一次 D2Weex 生码任务:9 个阶段 —— 从 AST(把设计稿解析成结构化数据)分析、到生码、到编译、到三端真机预览、到视觉迭代修复、到走查闭环 —— 其中大部分步骤由 CLI 骨架自动完成 · AI 只在少数需要推理的决策点介入。

                                                                  下面挑三个最能体现"让 AI 写对"这条主线的能力展开讲。

                                                                  ▐5.2 代码架构 · AI 生的代码就是分层的

                                                                  解决什么问题

                                                                  如果 AI 生的代码是一个大文件 · UI / 数据 / 业务逻辑全混在一起 · 那接下来:

                                                                  • 想改一处 UI · 得在一堆逻辑代码里翻

                                                                  • 想加个数据接口 · 得动到 UI 组件

                                                                  • 想加个业务逻辑 · UI 层也得跟着改

                                                                  一次生码不难 · 难的是生完之后还能持续迭代维护。所以我们从生码那一刻就给 AI 定了架构约束:代码必须分层、必须组件化。

                                                                  我们做了什么

                                                                  Step 1 · 页面自动组件拆分

                                                                  复杂页面不是一个大文件。AI 先分析设计稿 AST · 识别出可独立的单元(卡片、区块、模块) · 把一个页面拆成多个组件:

                                                                  • 拆分候选评分 · AI 判断哪些单元该独立成组件

                                                                  • 每个组件都是一个独立目录 · 可以单独预览、单独维护

                                                                  • 页面组件 = 若干子组件的组合

                                                                  Step 2 · 三层目录结构 · 数据 / UI / 业务逻辑分离

                                                                  每个组件都遵循严格的三层目录:

                                                                  层

                                                                  内容

                                                                  约束

                                                                  contract/

                                                                  数据类型定义 + Mock 数据

                                                                  数据契约 · Mock 不进生产包 · 构建时自动剔除

                                                                  ui/

                                                                  纯 UI 组件(TSX + CSS Module)

                                                                  只消费 Props · 不调服务、不访问网络、不调导航

                                                                  logic/

                                                                  业务逻辑(AI 留空)

                                                                  开发填充真实数据获取逻辑

                                                                  为什么这么分

                                                                  • UI 组件是"纯"的 —— 独立可预览 · 不依赖后端

                                                                  • Mock 和 UI 分离 —— preview 用 mock 数据 · 上线用真实数据 · 切换零代价

                                                                  • 逻辑层留空 · 支持并行开发 —— 业务开发写 logic/ 时 · UI 层不用动 · 两条线并行

                                                                  • Mock 不进生产包 —— 构建时自动剔除 · 零冗余

                                                                  代码架构解决的是"AI 写得可维护" —— 通过 SKILL 规则 + rulePath 让 AI 每次生出来的代码结构统一。

                                                                  同时交付门禁会check 修改的文件是否符合预期,不满足要求禁止提交不允许任务完成,打回修复。

                                                                  ▐5.3 视觉修复 · 多层信号融合

                                                                  解决什么问题

                                                                  Diff 只有一个分数不够 —— AI 会"看走眼"。举个真实案例:

                                                                  一张订单卡片 · badge 圆角被截 —— badge "3" 圆角上半被白卡背景截切了。 AI 看到的 diff 只扣了 0.5 分(被截像素面积极小) · 心理锚定"分数高应该 OK" · 自评"96% 还原"、修了错的地方(marginLeft 微调) · 真结构 bug 一路漏诊到最终交付。

                                                                  单靠像素 diff 分不清"渲染抖动"和"真 bug" · 单靠 AI 看图会被缩略图和分数误导。

                                                                  我们做了什么

                                                                  四层信号融合 · 每层回答一个不同的问题。关键点是 L2 —— 光有 diff 分数不够 · AI 还得知道实际渲染成什么样才能对症下药。所以我们不仅从设计稿拿到期望值(Pixelator AST) · 还从真机拿到 实际渲染的 DOM 树 —— 两者双向对比 · 定位到具体是哪个字段差了(位置?尺寸?颜色?字号?)    

                                                                  层

                                                                  回答什么

                                                                  具体做法

                                                                  L1 · 整图相似度

                                                                  WHERE — 哪里有像素差异

                                                                  像素 diff · 组件级截图

                                                                  L2 · 结构对比 · 期望 vs 实际

                                                                  WHAT SHOULD BE vs WHAT IS — 应该长什么样 vs 真机上实际长什么样

                                                                  Pixelator AST(期望值) + weex-devtools DOM 树(真机实际值) · 逐字段对比

                                                                  L3 · 像素采样验证

                                                                  IS IT REALLY — 是算法瑕疵还是真 bug

                                                                  局部像素抽样与颜色距离测算

                                                                  L4 · Vision LLM 语义复核

                                                                  IS IT ACCEPTABLE — 从语义层面判断是不是真 bug

                                                                  Vision LLM(Gemini 多模态) 判定:algorithm_artifact / real_bug / mixed

                                                                  同时 · 交付门禁的 7 项检查中 6 项有独立交叉验证 —— CLI 检测到 badge 被截、AI 却在门禁里填"badge 完整"?必须提供反驳理由说明为什么 CLI 判断有误。没有反驳 · 直接拒绝交付。

                                                                  具体表现

                                                                  • 视觉检测准确度:60-70% → 91%+

                                                                  • 单个 badge 漏诊率:~50% → ~10%

                                                                  • 交付门禁防绕过覆盖:0/7 → 6/7

                                                                  ▐5.4 真机实时预览 · 让效果人人可体验

                                                                  解决什么问题

                                                                  Agent 自动生完了代码 · 也有了三端截图和 diff 报告 —— 但光看截图不够。

                                                                  业务场景大多数带交互:点击进详情、滑动切 tab、加购弹动画、暗黑模式切换、异常态回退 —— 这些必须真机上跑才能体验。而传统链路是:研发拿到代码 → 打包 → 装机 → 打开对应页面 —— 每一步都得开发在真机边上操作。产品、运营、设计想看效果只能"喊人"。

                                                                  我们做了什么

                                                                  Agent 生完码 → 自动推真机 → 自动屏投到浏览器 —— 分享一个链接 · 任何人随时随地都能看到实时效果:

                                                                  • 产品看效果:不用找开发装机 · 浏览器打开链接直接看

                                                                  • 设计走查:不用回办公室摸真机 · 手机/电脑打开就能看

                                                                  • 复现问题:不用截图 + 文字描述 —— 直接把浏览器链接甩过去 · "自己看"

                                                                  具体表现

                                                                  • 交互场景可验收:不只是静态截图 · 完整交互动线都能真机上体验

                                                                  • 无门槛访问:浏览器打开链接即可 · 不需要装 debug 手淘、不需要连真机、不需要 IDE

                                                                  • 实时反馈:Agent 改一次码 → 浏览器页面自动刷新 · 秒级看到最新效果

                                                                  • 开发角度:对于开发可能习惯在自己手机上看到或者操作,我们在issue 评论里面也准备了预览二维码,扫码可以一键预览到手机上确认。

                                                                  ▐5.5 走查即自动修复

                                                                  同时这里也想说清楚一点,不是所有的视觉稿我们生码的时候都需要人工参与,实践的过程中,我们也有一些页面或者卡片AI直接完成,设计师走查一遍过的。我们目标还是追求AI自动闭环,现阶段的确还有一些问题没能彻底解决,在这前提下更好的辅助AI 快速完成修复。

                                                                  解决什么问题

                                                                  四层视觉门禁把准确度做到 91%+,但剩下的 5-10% 里藏着最难的问题。

                                                                  实际跑下来我们发现,这些残留问题不是一种形态,而是三类完全不同的场景混在一起。机器一视同仁去修,有的修不动、有的修错方向、有的根本不该修。

                                                                  实测数据也印证了这一点:AI 自修复在 3轮内 ROI 最高,3 轮以上必然要转人工——要么源头就是错的,要么是算法极限,要么是端上渲染必然差异。

                                                                  三类典型场景:

                                                                  场景

                                                                  表现

                                                                  为什么必须人介入

                                                                  ① 源头问题 · 设计稿不规范 + 生码折损

                                                                  设计稿有调试残留 / 图层堆叠 / 分组语义错误;生码转换时 badge 被截、元素丢失、成组方向错

                                                                  AI 按错误的源结构反复修,分数原地打转。人一眼看出"应该长这样",指一下,Agent 直接改最终代码,绕过源头问题

                                                                  ② 算法极限 · 人眼看不出的假偏差

                                                                  字体像素级差异、5px 内偏移、抗锯齿边缘扣分——人眼几乎看不出区别,分数已到 91%+

                                                                  改了也拿不到高分,还可能引入新 bug。人判定"这是精度问题不是 bug",直接放行

                                                                  ③ 端上必然差异 · diff 前提本身不成立

                                                                  客户端行高 ≥1.2(设计稿可 =1)、三端字体 baseline 不同、mock 数据 vs 真机业务数据不一致、刘海屏安全区

                                                                  设计稿 vs 真机的像素比对前提失效,AI 靠 diff 循环越修越糟。只能靠人的场景判断打破死循环——"这段文字改 1.2 倍行高",Agent 拿到提示直接微调

                                                                  走查页的价值:把"3 轮后转人工"这个动作,从"现实中不标准化的流程(设计师钉钉上反馈一些信息,然后整体给到AI),压缩成一次浏览器里拖框标注、分钟级修复。

                                                                  我们做了什么

                                                                  一张流程图看清整个闭环(下图 6 步 · 对应本节 3 句话:01-03 → 人的输入结构化;04 → Agent 上下文精准;05-06 → 闭环全自动):

                                                                  核心 3 句话:

                                                                  • 人的输入结构化:用户屏投手淘 · 在浏览器 走查页拖框标注(位置 + 一句问题描述) · 结果结构化写入 Agent 上下文 —— 不是自然语言 bug 单

                                                                  • Agent 上下文精准:标注已经指定"改哪个组件的哪个属性" · Agent 直接改 —— 不用重读全组件代码

                                                                  • 闭环全自动:标注 → Agent rerun → 修 TSX/CSS → 回写结果 → 页面实时刷新 —— 用户在同一个页面完成全流程 · 不切工具

                                                                  具体表现

                                                                  • 主观项也能收敛:从"pxdiff 91% + Vision LLM 通过" 补齐到 "用户真机看着满意"

                                                                  • 人机协作范式升级:从"人在 Agent 外提 bug" 到 "人的判断变成 Agent 的一个决策节点"

                                                                  这就是"走查即自动修复" —— 前面绝大多数问题靠机器自动化 · 最后一公里让人的判断结构化嵌入 Agent 决策循环 · 让整体的 ROI 更高。

                                                                  方法论沉淀 · 让 AI Agent 变可靠的 5 条原则

                                                                  前面讲的是 D2C 场景,但这套东西不只对 D2C 有用 —— 过去半年做的过程中,我们沉淀出了 5 条可迁移的方法论 · 任何 AI Agent 工作流都能用。

                                                                  • 方法论 1 · 分清楚哪些交给 AI · 哪些交给程序

                                                                  流程编排是"每步每次必须正确"的任务 → 用代码做智能判断是"大部分时候正确就够"的任务 → 用 AI 做

                                                                  如果你把两者混在一个 prompt 里 · 会发生什么?确定性被拖成概率性 · 概率性被要求确定性 · 互相拖累。

                                                                  判断标准:如果一个步骤"AI 做对和做错的结果完全不同" —— 比如分支切换、状态持久化、编译门禁 —— 它就是确定性步骤必须代码化。

                                                                  • 方法论 2 · AI 决策点最小化

                                                                  不是"AI 做得越多越好" · 而是"AI 用得越少 · 效果越好"。

                                                                  为什么? 假设每步 AI 遵守率 95% · 74 步全流程正确率 = 0.95^74 ≈ 2%;缩到 8 步 · 全流程正确率 = 0.95^8 ≈ 66%。这不是模型能力问题 · 是数学事实。

                                                                  实践:每次想让 AI 多做一件事之前 · 先问一句"这件事能不能用代码做?"能就不该让 AI 做。

                                                                  我们的 AI 决策点从 74 降到 8 · 漏步骤率从 ~30% 降到 <5% —— 同一个模型 ,只是让它少做 89% 的事。

                                                                  • 方法论 3 · 动态数据比静态指令更有效

                                                                  CLI 运行时输出的结构化数据(基于当前任务的实际检测结果) · 比 SKILL 说明书里的静态规则更能驱动 AI 行动。

                                                                  对比一下:

                                                                  • 静态指令:"请检查 badge 是否被截切" → AI 可能忽略

                                                                  • 动态数据:"badge 截切置信度 85% · 证据:外侧像素 RGB=(255,87,34) 接近 badge 主色" → AI 必须回应

                                                                  前者是建议 , 后者是事实,事实驱动行动。

                                                                  对应到实践:视觉迭代前 , CLI 自动生成一份"诊断草表" —— 里面全是基于当前模板检测出来的具体证据 ,不是通用规则。AI 拿到这份草表 ,只能按证据回应 ,不能视而不见。

                                                                  • 方法论 4 · 交叉验证堵住 AI 的主观绕过

                                                                  AI 可以在任何自然语言字段里填任何值。唯一能验证的方式是:代码有独立的检测手段 · 填写结果与检测结果矛盾时直接拒绝。

                                                                  前面的方法论解决"AI 少做事" + "做对事" · 但没法防 AI 提前宣称完成。

                                                                  比如 · 交付门禁里 AI 填"badge 完整" —— 你怎么知道它是真看见 badge 完整了 · 还是随手打了个 true 让流程通过?

                                                                  我们的做法:CLI 有独立的像素检测。CLI 说"badge 被截 · 置信度 85%" · AI 却填"完整"?两者矛盾 —— 必须给出书面反驳理由说明为什么 CLI 判断有误,没反驳直接拒绝交付。

                                                                  同样的思路可以推广:每一条 AI 可能"随手打勾"的字段 · 都应该有一个独立于 AI 的检测程序做交叉。覆盖率越高、能"随手绕过"的空间越小。

                                                                  我们把这套交叉验证的通用契约沉淀成了 7 条硬约束(内部叫 Evidence Integrity R1-R7) —— 每一条都对应过一次真实翻车 —— 但这些具体规则不是关键 · "AI 填的每一个字段都要有代码验证"这个思路才是关键。

                                                                  • 方法论 5 · AI 决策之外要有独立看门人

                                                                  AI 说"我完成了" · 不能由 AI 自己决定。要有一个运行在 AI 决策循环之外的独立校验 · 不满足就拒绝退出。

                                                                  前四条方法论都是"让 AI 做对更多的事" ,但 AI 依然可能在最后一刻跳过校验直接宣称完成。这时候需要一个 AI 无法绕过的机制。

                                                                  我们用了 plugin 的 Stop Hook —— 简单说 · 就是在 AI 会话即将结束的时候 ·,系统会调一个外部程序做校验:通过就放行 ,不通过就把 AI 拒回去继续工作。

                                                                  • Fail-open:hook 本身出错就放行(绝不让防护机制拖垮工具链)

                                                                  • 只拦当前工作流:不影响其他 Claude Code 使用

                                                                  • 超时自动过期:防止僵尸 hook 永远拦截

                                                                  关键:这个机制不在 AI 的决策链路里。AI 说"完成了"不代表真完成 —— 得由外部的代码说了算。

                                                                  5 条方法论一句话总结:把"必须每次都对"的事交给代码 · 把"大部分时候对就够"的事留给 AI · 用工程化手段交叉验证 AI 的输出。这不是让 AI 更聪明 —— 是重新划分代码和 AI 的职责边界。

                                                                  未来 · 让 AI 自己走完

                                                                  • 持续打磨:从"能用"到"好用",稳定性和性能是长期投入 —— 拉高交付成功率 、缩短端到端耗时 、覆盖更多业务边界场景 ,让 Agent 在复杂场景下也能自己收敛

                                                                  • 人人可用:让产品、设计、运营也能直接用 issue 触发生码并最终上线 ,而不只是研发的工具

                                                                  • 能力标准化:让 D2C 从"独立生码链路" → 进化为"可插拔进任何项目 AI 生码流程"的能力

                                                                  结尾

                                                                  AI 生码不难 · 难的是让 AI 自己知道对不对。

                                                                  我们没有造更聪明的 AI ,做的是三件事:

                                                                  • 分清 AI 与程序的边界: 确定性流程固化到 CLI 里 · 概率性判断留给 AI · 各司其职

                                                                  • 给 AI 装上眼睛:三端真机截图 + 多层信号融合(像素 diff、结构对比、Vision LLM) · AI 有了自己的"眼睛"

                                                                  • 让 AI 自己迭代修复 :看到 diff、改码、重新验证 达标才停 不再是"生完就完"

                                                                        AI 从设计稿到三端真机达标 ,中间的每一步都能自己感知、自己判断、自己修 —— 这就是我们在做的事情。

                                                                  团队介绍

                                                                  本文作者修易,来自淘天集团-用户&内容技术团队,该团队服务于淘宝基础用户产品,是淘宝最重要的业务线之一。首页、信息流推荐、消息、搜索、我淘、用增、互动、内容等亿级用户规模产品,为我们带来大量业务/技术挑战及机会。团队在保证业务的同时,以先进的跨端框架和研发模式不断完善自己,打造最极致的体验和工程技术,保障多端设备的适配和稳定运行,并探索端智能等创新机会,通过技术高效驱动业务的良性发展。持续探索以 AI 为底座构建从需求到上线的端到端自动化与产品化能力,使亿级规模的交付更快、更稳、更可控。

                                                                  跳转微信打开

                                                                  •  

                                                                  从 AI Friendly 架构到可复制的 AI 迁移能力 - 淘宝直播搜推在线架构升级实践

                                                                  原创 直播技术团队 2026-10-30 10:37 浙江

                                                                  如何用 AI 破解 362 万行代码的维护难题?

                                                                  图片

                                                                  淘宝直播推荐系统早期为追求策略快速上线,形成了多框架、多分支并存的架构,导致工程团队面临数百万行代码的沉重维护负担。为此,团队自研了轻量级执行框架,通过统一物料承载公共能力、声明式编排表达场景差异、受约束的流程语义以及结构化执行诊断,彻底重构了应用生产方式。在此基础上,团队先通过人工迁移建立验收基线,再将经验沉淀为 Skill 引导 AI 参与复杂历史应用的迁移与验证。这一实践不仅实现了性能的平稳过渡,更证明了“AI Friendly”的核心在于为 AI 提供有限、显式且可验证的工程空间,从而将一次性迁移经验转化为可复制的自动化能力。

                                                                  图片

                                                                  摘要

                                                                  淘宝直播推荐应用支持直播多个核心流量场景。早期,为了让算法策略快速进入实验,算法团队直接开发和维护对应场景应用的 Java UDF、图配置及代码分支。这种方式缩短了单次试验路径,但随着维护责任逐步转交到规模更小的工程团队,历史上形成的多框架、多分支和多套诊断方式开始成为持续迭代的主要成本。

                                                                  复杂度不仅来自代码规模,更来自多个版本的独立演进。同一项公共能力可能存在于不同分支和部署版本中,一次修改需要分别理解上下文、评估影响、发布和验证。即使最初源自同一份实现,各版本在长期演进后也可能形成不同的行为,难以直接合并或替换。

                                                                  针对这些问题,我们逐步建立统一的应用开发与迁移方式:用可复用组件承载公共能力,用声明式编排表达场景差异(即通过配置描述组件组合、参数连接和执行关系,由框架统一解释和执行),用明确的流程语义降低理解成本,并通过结构化执行记录支持诊断与验证。在这一基础上,我们先通过人工迁移建立旧系统的行为基线和验收标准,再将迁移知识、操作步骤、工具及验收规则组织为可复用的 Skill,让 AI 参与历史应用的分析、转换和修复,并通过确定性校验工具与新旧链路对比检查迁移质量。

                                                                  本文将介绍这套应用编排框架的设计取舍、三项核心机制,以及从人工迁移到 Skill 复用的演进过程,并讨论它们如何为 AI 参与工程任务提供基础。我们用 AI Friendly 描述这样一组架构属性:任务上下文可以局部理解,组件契约和依赖关系显式可见,能力可以检索与组合,生成结果能够接受工具检查。

                                                                  一个仍能运行、

                                                                  却难以持续维护的系统

                                                                  ▐2.1 早期生产方式为何合理

                                                                  淘宝直播搜推应用形成于算法策略快速发展的阶段。早期工程资源相对有限,需要支持算法团队持续开展策略实验。为了缩短策略从想法到实验的路径,算法同学直接编写 Java UDF、维护图配置并完成实验上线。

                                                                  在当时的约束下,这是一种务实选择:策略设计与工程实现之间沟通链路短,独立方案和代码分支能够隔离单次变化,有限的工程资源可以优先保障业务快速试验。

                                                                  问题出现在业务进入多场景长期维护阶段之后。部分实验分支和场景分支长期保留,逐渐成为独立的开发、部署和维护单元;不同场景又分别使用不同框架。早期用于缩短单次实验路径的局部最优,开始转化为跨场景维护时的整体成本。

                                                                  随着维护职责从较大范围的分散承担转向规模更精简的工程团队集中承接,如何以有限的人力持续维护多场景应用,成为架构演进需要解决的重要问题。过去分散在不同参与者、代码分支和执行框架中的知识,需要逐步沉淀为可复用的组件、统一的流程和验证方法,以减少重复理解、修改与排障的成本。

                                                                  不过这并不意味着早期选择错误,而是原有生产方式所依赖的组织规模、团队分工和资产生命周期已经发生变化。

                                                                  从策略快速试验期到多场景长期维护期的生产方式变化

                                                                  ▐2.2 复杂度不在图的数量,而在复制后的独立演进

                                                                  梳理线上实际运行版本后,我们发现,同一套流程和能力被复制到不同方案与代码分支中,随后因场景需求、参数配置和兼容逻辑的变化而独立演进。因此,同名逻辑图可能已具有不同的行为,代码分支的最新提交也未必对应线上部署版本。

                                                                  一次公共能力升级或故障修复,需要先确认各运行版本的行为与差异,再评估影响、修改代码,并分别完成发布和回归验证。降低维护成本,需要减少公共能力的重复实现,让必要的场景差异得到明确表达和统一验证。

                                                                  ▐2.3 三类问题共同推高长期成本

                                                                  第一类问题是分支副本化与多框架并存。

                                                                  长期分支分别维护 Java 实现和图配置,公共能力无法沿一个主干持续演进。新场景习惯复制完整分支,而不是复用公共能力后只表达差异。多框架并存又要求维护人员在不同框架的组件模型、参数规则、执行机制和排障路径之间来回切换。

                                                                  第二类问题是执行模型缺少稳定语义和统一生命周期。

                                                                  自由图擅长表达节点之间的连接,却不一定能突出业务阶段、主执行路径和职责边界。串行、并行、条件执行和数据依赖混合在拓扑中,阅读者需要沿连接关系逐个查看节点及其代码,才能还原真实流程。每张图又是独立定义,请求初始化、公共校验、监控上报和资源清理等横切能力只能逐图接入。

                                                                  线上接口拓扑图样例1

                                                                  线上接口拓扑图样例2

                                                                  如上图所示,不同业务的执行拓扑形态各异,缺少统一的阶段划分和组织方式,读者需要逐一追溯节点及其依赖关系,才能还原业务流程与执行顺序。

                                                                  第三类问题是执行诊断和监控能力不足且分散。

                                                                  历史应用缺少与实际执行树对应的完整节点记录。线上出现异常时,现有日志通常无法直接回答:请求执行过哪些节点、最早在哪个节点失败、异常原因是什么、耗时是否超限。不同场景还分别设计日志字段、指标和排查入口,同类问题难以复用同一套查询模板和排查经验。

                                                                  三类问题叠加后,维护成本会随分支、图和场景持续增加,无法随着公共能力和历史经验的积累逐步摊薄。增加人员只能缓解局部排期,新成员仍然需要重复学习不同分支、框架和场景上下文。

                                                                  因此,真正需要解决的不是某个类写得太长、某张图不够直观,而是原有应用生产方式已经无法被当前团队持续承接。

                                                                  我们决定重构的不是代码,

                                                                  而是生产方式

                                                                  ▐3.1 为什么局部措施不够

                                                                  面对历史系统,最容易想到的方案包括增加人员、局部重构、替换旧框架、补充监控工具,或者直接让 AI 分析和改写代码。这些措施都有价值,但只能改善局部问题。

                                                                  AI 尤其不能直接接管一个依赖人脑解释的系统。模型可以阅读大量代码,但如果真实行为同时分散在代码分支、图配置、实验参数、动态开关和外部调用中,它首先面对的不是“如何写新代码”,而是“哪一份事实才代表线上”。如果流程和参数缺少稳定契约,AI 生成得越快,错误也可能扩散得越快。

                                                                  我们最终把目标重新定义为:建立一套能够支撑多场景长期维护的统一生产方式,让公共能力能够复用,让场景差异能够显式表达,让流程具备稳定语义,让执行结果能够被统一验证。

                                                                  ▐3.2 从三类痛点推导运行框架能力

                                                                  新的运行框架需要同时提供三组能力。

                                                                  第一,统一应用和物料模型,并声明式表达差异。稳定能力由细粒度节点承载,场景差异主要通过流程组合、节点选择、参数、条件和配置表达,减少为隔离差异而复制完整代码分支的必要性。

                                                                  第二,顺序优先、显式并行,并提供统一生命周期。流程应该可以自上而下阅读;串行、并行等待和异步旁路需要显式表达;请求前置和请求结束逻辑可以集中维护,不再逐图复制。

                                                                  第三,统一产生结构化执行信息,并提供标准上报扩展。日志、监控和排查工具应当消费同一份执行事实,而不是要求每个业务节点自行定义诊断字段。

                                                                  除了能力本身,我们还给底座设置了三项约束:轻量、易上手、扩展优先。框架只保留统一模型和执行语义所必需的机制,成熟的配置管理和中间件能力继续复用,平台差异和业务差异通过适配层与扩展点承载。

                                                                  ▐3.3 为什么选择自研

                                                                  现有图执行框架各有侧重,在领域组件复用、通用图执行和运行诊断等方面提供了不同能力。结合多场景应用的长期维护需求,我们希望进一步统一应用模型、场景差异表达、流程语义、公共生命周期和结构化执行信息,并通过配套平台支持组件发现、可视化编排、版本关联和发布治理。

                                                                  为此,我们选择建设由执行框架和编排管理平台组成的应用编排与运行体系:框架负责定义组件契约、执行流程和生成诊断信息;平台负责组件管理、流程编排及相关管理操作。两者围绕统一的应用模型协同,连接应用的设计、配置、执行与诊断过程。

                                                                  如在现有框架上实现这些目标,仍需要建设新的核心抽象和配套平台能力,同时适配底层模型及其演进节奏。考虑到这些建设投入,我们选择自主维护这一层应用模型及配套工具,根据实际需求持续演进。

                                                                  总体架构设计

                                                                  这套体系由轻量执行框架与配套编排管理平台组成。它将原本散落在代码与图配置中的业务能力整理为可复用组件,并通过受约束的流程结构组织这些组件。执行框架保持与应用具体宿主平台解耦,负责流程执行、依赖协调和结构化诊断信息生成;编排管理平台负责组件发现、流程编排、版本关联和发布治理。

                                                                  整体可以分为四层:

                                                                  1. 物料层:用 AtomicNode、ChainNode (组成Chain)等统一接口承载细粒度能力;

                                                                  2. 编排层:用 Plan、Stage、ExecutorGroup 描述业务流程及串并行关系;

                                                                  3. 运行时层:负责条件判断、参数传递、并发调度、超时及异常处理;

                                                                  4. 诊断与适配层:生成 ExecuteRemark 执行树,并通过扩展点接入日志、监控和宿主环境。

                                                                  这种分层刻意把“稳定能力”和“场景差异”拆开:稳定能力进入物料代码,流程结构、节点依赖、条件和物料配置进入编排。公共能力可以在一个主干中持续演进,不同场景仍能通过声明式配置保持必要差异。

                                                                  Emeya 总体架构与各层职责

                                                                  ▐4.1 AI Friendly 不是“AI 更容易写代码”

                                                                  如果把 AI Friendly 理解为“模型能够快速生成代码”,这个说法并不准确。因为代码生成效果会受到模型版本、提示词和样例数量影响,它只能说明模型能力,不足以证明架构本身适合 AI 长期参与。

                                                                  我们更关注的是:面对一个真实工程任务,AI 能否只读取与任务相关的局部上下文,能否在有限且稳定的工程语法内做选择,能否通过显式契约理解数据流,生成结果能否被确定性工具检查,运行后能否留下足以定位问题的证据。

                                                                  按照这个标准,AI Friendly 不是一项独立功能,而是总体设计产生的工程属性:

                                                                  这里需要区分运行底座和外围控制能力。固定流程层级、统一物料、参数契约和 ExecuteRemark 属于 Emeya 核心模型;DSL、Builder、metadata、解析器和校验器是围绕这套模型建设的 AI 控制层。新体系没有替 AI 保证结果正确,它提供的是一组稳定接口,使外部工具能够理解、生成、检查和重跑。

                                                                  后续三个核心设计共同支撑了新体系的 AI Friendly 特性:统一物料降低单次任务需要读取的上下文,受约束流程减少需要临场推理的结构选择,结构化执行信息为验证和修复提供证据。

                                                                  核心设计一:

                                                                  统一物料与声明式差异

                                                                  ▐5.1 从粗粒度 UDF 转向职责稳定的物料

                                                                  历史节点中,一个类可能同时完成 RPC 请求构造、远程调用、结果解析和业务处理。粗粒度节点能够快速交付单个需求,却很难被其他场景直接复用;一旦部分逻辑存在差异,最简单的处理方式往往是复制类或复制分支。

                                                                  新体系将业务流程拆分为职责更清晰的物料。AtomicNode 承载独立业务计算,ChainNode 承载参数构造、服务调用和结果解析等链式能力。节点通过明确的输入、输出和配置契约参与编排,不再依赖阅读完整调用链才能知道数据从哪里来、向哪里去。

                                                                  细粒度不是越小越好。节点粒度需要同时满足三个条件:职责可以被一句话说明;输入输出可以稳定声明;能力存在独立测试或跨场景复用价值。纯粹为了拆分类而制造大量无意义节点,只会把代码复杂度转移到编排层。

                                                                  ▐5.2 稳定能力进入代码,场景差异进入编排

                                                                  我们希望用一套代码和一个主干能够承载多个场景,但这不等于强行消灭差异。真正需要消除的是“用一套代码副本表达局部差异”的方式。

                                                                  在新体系中,稳定的业务能力由节点代码承载,差异主要通过以下声明表达:

                                                                  • 选择哪些节点;

                                                                  • 节点按照什么顺序组合;

                                                                  • 参数如何连接;

                                                                  • 什么条件下执行;

                                                                  • 超时时间多长;

                                                                  • 并行策略是什么;

                                                                  • 场景专属配置取什么值。

                                                                  这样,公共能力升级时可以沿主干一次修改,场景差异仍保留在可阅读、可比较的编排中。新增场景也不再默认复制完整分支,而是先检索已有物料,判断能否直接复用或组合复用,只为真实能力缺口新增代码。

                                                                  统一框架本身不会自动回收历史分支。主干开发约束、实验结束后的合并回收、长尾分支治理仍然需要由工程制度保证。新体系提供的是让这些治理动作可以发生的技术基础,而不是用框架替代治理责任。

                                                                  从粗粒度 UDF 分支副本到细粒度物料与声明式编排

                                                                  核心设计二:

                                                                  受约束的流程语义与统一生命周期

                                                                  ▐6.1 为什么不继续使用自由图作为主要表达

                                                                  自由图的优势是表达能力强,天然适合描述复杂依赖和并发关系。但表达自由也意味着阅读方式不稳定:同一类业务流程可能被不同开发者画成完全不同的拓扑,主链路和旁路任务混在一起,阅读者需要不断沿边回溯依赖。

                                                                  我们做了一个明确取舍:牺牲一部分自由图的表达上限,换取稳定的阅读范式和可评审的并行边界。开发者按业务阶段阅读流程,运行时则根据并行属性和参数依赖调度任务。顺序表达不等于所有任务串行执行,框架仍然保留并发执行能力。

                                                                  流程配置按照 Plan → Stage → ExecutorGroup → Node 的层级自上而下组织。Plan、Stage 保持顺序执行;需要并发时,由 ExecutorGroup 显式标记执行方式:

                                                                  Plan示例

                                                                  ▐6.2 参数依赖既是运行契约,也是可验证事实

                                                                  节点通过显式参数契约传递数据。每个节点声明输入、输出及其类型,上游输出与下游输入通过统一的参数标识(Key)建立连接。运行时可以据此协调依赖等待,工具也可以在执行前检查输入是否有生产者、类型与配置是否一致,以及数据依赖是否与执行顺序冲突。

                                                                  以一个简化示例说明:节点 A 输出resultA,节点 B 将其声明为输入,二者便建立了明确的数据依赖。如果节点 B 引用了不存在的参数,或输入类型与上游输出不匹配,工具就可以在执行前指出问题;运行时则依据依赖关系,在所需输出就绪后继续执行下游节点。

                                                                  通过这种方式,参数关系从隐藏在 Map、上下文对象和方法调用中的约定,转变为可以枚举和检查的显式契约。开发者能够直接查看数据的来源与去向,AI 可以依据契约理解和生成连接关系,工具则能够对这些关系进行静态校验。

                                                                  ▐6.3 把公共前后置流程变成一等能力

                                                                  历史应用中,请求初始化、公共上下文准备、监控上报和资源清理往往散落在不同图中。每接入一项公共能力,都需要逐图新增和配置节点。

                                                                  新体系允许定义固定的全局前置 Plan 和全局后置 Plan,业务流程执行时由框架统一拼接。公共能力可以集中维护、统一装配,不再依赖每个场景重复配置。

                                                                  统一生命周期的价值不只是少写几份配置,它建立了公共治理的控制点:团队可以明确哪些逻辑必须在所有请求前执行,哪些诊断和清理动作必须在请求结束时发生。

                                                                  业务 Plan 与全局前置、后置 Plan 的统一生命周期

                                                                  核心设计三:

                                                                  让每次执行留下结构化证据

                                                                  ▐7.1 日志不是附属能力,而是执行模型的一部分

                                                                  如果日志完全由业务节点自行决定,不同场景最终会形成不同的字段、格式和查询方式。即使所有节点都“有日志”,维护人员仍然无法用同一套方法还原请求执行过程。

                                                                  新体系将诊断信息设计为执行模型的一部分。每次任务执行都会生成与实际任务树对应的 ExecuteRemark。Plan、Stage、ExecutorGroup、AtomicNode、Chain 和 ChainNode 等执行层级都会记录名称、状态、耗时、异常和扩展信息,最终形成一棵与真实执行过程一致的 Remark 树。

                                                                  这棵树提供了一份统一原料:日志系统可以把它展开为结构化日志,监控系统可以聚合节点成功率和耗时,链路平台可以还原执行拓扑,排查工具也可以定位第一个失败节点。不同场景采用同一套模型后,查询模板和排查知识才具备复用基础。

                                                                  Chain ExecuteRemark 样例

                                                                    {
                                                                      "async": 1,
                                                                      "cost": 4,
                                                                      "endTime": 1788262507769756,
                                                                      "isProcessorBlocking": 1,
                                                                      "isProcessorParallel": 0,
                                                                      "name": "示例Chain",
                                                                      "processorName": "SerialProcessor",
                                                                      "startTime": 1788262507764919,
                                                                      "success": 1,
                                                                      "taskType": "Chain",
                                                                      "subRemarks": [
                                                                        {
                                                                          "async": 0,
                                                                          "cost": 0,
                                                                          "endTime": 1788262507764957,
                                                                          "name": "示例参数构造",
                                                                          "processorName": "SelfRunTaskProcessor",
                                                                          "startTime": 1788262507764928,
                                                                          "success": 1,
                                                                          "taskType": "ChainNode"
                                                                        },
                                                                        {
                                                                          "async": 0,
                                                                          "cost": 4,
                                                                          "endTime": 1788262507769684,
                                                                          "name": "示例调用器",
                                                                          "processorName": "SelfRunTaskProcessor",
                                                                          "startTime": 1788262507765016,
                                                                          "success": 1,
                                                                          "taskType": "ChainNode"
                                                                        },
                                                                        {
                                                                          "async": 0,
                                                                          "cost": 0,
                                                                          "endTime": 1788262507769722,
                                                                          "name": "示例结果解析",
                                                                          "processorName": "SelfRunTaskProcessor",
                                                                          "startTime": 1788262507769714,
                                                                          "success": 1,
                                                                          "taskType": "ChainNode"
                                                                        }
                                                                      ]
                                                                    }

                                                                    ▐7.2 框架负责产生证据,应用负责接入技术体系

                                                                    新框架不负责日志存储、指标聚合、监控大盘和告警实现,它提供两个标准处理钩子:节点或执行单元完成后,可以处理对应层级的 ExecuteRemark;接口完成后,可以处理整条请求的 ExecuteRemark。

                                                                    应用通过这些出口统一接入现有日志采集、耗时统计、采样存储和监控上报。钩子的执行异常会被记录并隔离,不改变原业务执行结果,避免诊断链路反向影响主业务。

                                                                    从人工迁移到 AI 迁移

                                                                    新体系建立了目标生产方式,但历史应用不会因此自动迁移。真实行为仍然分散在 Java UDF、图配置和实验参数中。

                                                                    迁移需要先还原旧应用事实,再按照新模型重建节点和流程,最后证明新旧链路行为等价。

                                                                    我们没有从“写一个迁移 Skill”开始,而是经历了三个阶段:人工迁移建立基线、AI 迁移并打磨 Skill、直接复用 Skill 迁移新场景。

                                                                    从人工迁移到 Skill 复用的三阶段演进

                                                                    ▐8.1 第一阶段:人工迁移建立事实与验收基线

                                                                    考虑到图结构简单、输出较为稳定、迁移和验证成本可控,我们选择主播关注页作为人工迁移到新体系的首个真实业务场景。我们人工完成旧图、Java UDF、节点职责和数据依赖的还原,识别实验配置、动态条件和公共前后置行为,再将旧逻辑映射为新体系下的物料和编排配置。

                                                                    人工迁移的目标不是证明人比 AI 更可靠,而是建立三类基线:哪些旧行为必须保留,旧框架概念应当如何映射到新体系,以及什么证据可以证明迁移正确。

                                                                    主播关注页迁移整体投入约20人日,留下了第一批可复用资产:旧框架到新框架的概念映射、节点拆分与参数迁移规则、典型实现和编排样例、新旧链路对比方法,以及适合交给工具处理的重复任务清单。

                                                                    没有这一步,后续 AI 迁移面对的只是一组散乱代码和抽象目标,生成结果即使看起来合理,也缺少事实和验收依据。

                                                                    ▐8.2 第二阶段:让 AI 迁移,同时把失败沉淀为能力

                                                                    直播频道页成为第一个完整的 AI 迁移场景。我们将人工迁移形成的框架知识、迁移步骤和样例写入 Skill,让 AI 参与旧应用分析、目标拓扑设计、代码和配置生成、静态对账及差异修复。

                                                                    此时的 Skill 不是一个预先设计完成的提示词,而是在真实迁移中逐步形成的工程能力。迁移暴露的错误被分成两类处理:

                                                                    • 需要理解业务含义和历史语义的问题,补充知识、规则和样例;

                                                                    • 可以确定性判断的问题,优先沉淀为解析器、生成器和校验脚本。

                                                                    例如,AI 难以稳定还原旧图依赖,就增加图解析、血缘提取和依赖报告;复杂 Plan 手写容易出错,就使用脚本生成;生成结果难以走读,就把 Plan 反解为 Markdown;Java 参数、Spring Bean 和配置容易漂移,就增加跨产物契约对账。

                                                                    每发现一种可重复错误,都不只是修复当前代码,而是判断怎样让下一次迁移更早发现、自动定位并能够重跑。Skill 因此从操作说明逐渐变成知识、规程、工具和验收标准的组合。

                                                                    ▐8.3 第三阶段:直接复用 Skill 迁移新场景

                                                                    在后续迁移场景中,我们不再边迁移边从头建设 Skill,而是直接执行已经沉淀的标准流程:

                                                                    1. 读取旧应用和目标接口;

                                                                    2. 还原节点、依赖与配置事实;

                                                                    3. 生成迁移任务和依赖阶段;

                                                                    4. 按拓扑迁移节点;

                                                                    5. 生成代码、Bean 和 Plan;

                                                                    6. 执行确定性校验;

                                                                    7. 根据报告修复并重跑;

                                                                    8. 由人工审核业务语义和迁移结果。

                                                                    复用 Skill 后,单场景整体迁移周期缩短到约 3 天。人工工作主要收敛为驱动 AI 工具执行任务、审核迁移结果、确认新旧差异,以及决定灰度、放量和回滚。

                                                                    这次变化比“AI 写了多少代码”更重要:迁移经验先从人脑进入文档,再从文档进入工具,最后由 Skill 把知识、任务、工具和验收标准组织成可重复执行的过程。

                                                                    复杂历史应用如何拆解为可执行迁移任务

                                                                    ▐9.1 输入不是一个代码仓,而是一组运行事实

                                                                    历史应用的真实行为不只存在于 Java 代码中。一次迁移至少需要同时处理:

                                                                    • 旧框架的图或流程配置;

                                                                    • Java UDF 和 Spring Bean;

                                                                    • 输入输出及共享上下文;

                                                                    • 实验参数、动态配置和条件开关;

                                                                    • 外部服务调用和异常处理。

                                                                    如果只让 Agent 阅读仓库并直接改写,它很容易把代码引用关系误当成完整业务依赖,遗漏配置、实验和运行时注入形成的隐式行为。

                                                                    因此,迁移第一步不是写代码,而是建立结构化事实基线:形成节点清单,记录节点类型、职责、输入输出、配置、外部依赖和异常策略;再从图连接、参数读写和隐式引用中生成依赖图。

                                                                    ▐9.2 按依赖关系划分 Stage,而不是平均切任务

                                                                    依赖图生成后,迁移任务按照拓扑划分 Stage:上游依赖先迁移,无依赖或同层节点可以并行,下游只有在前置产物通过检查后才能开始。

                                                                    主 Agent 负责维护全局事实、目标拓扑、公共约束和阶段状态;规模化执行任务负责迁移边界清晰的节点;确定性脚本负责图解析、任务生成、Plan 构建、参数闭环和跨产物校验。

                                                                    这种分工解决三个问题:

                                                                    • 上下文规模:把长任务拆成边界清晰的节点任务,避免上下文持续膨胀;

                                                                    • 并行安全:由依赖关系决定哪些任务可以并行,避免下游先于上游迁移;

                                                                    • 结果可靠:结构、配置和契约判断交给脚本,不依赖模型每次临场推理都得到相同结果。

                                                                    AI 擅长理解、转换和处理局部差异,脚本擅长稳定解析、生成和校验。迁移过程不是二选一,而是让二者分别承担适合自己的工作。

                                                                    AI迁移过程

                                                                    如何证明迁移前后行为等价

                                                                    迁移完成不能以“代码编译通过”或“接口返回成功”为标准。搜推在线链路依赖持续变化的召回、特征和打分服务,同一个请求在相近时刻执行两次,也可能因为实时数据、实验配置、缓存或服务状态不同而得到不同结果。

                                                                    因此,分别请求新旧链路并比较最终响应,无法判断差异来自迁移逻辑还是两次请求获得了不同的外部数据。前面阶段的微小差异还会沿召回、打分、重排和结果组装不断放大,只比较最终结果也难以定位最早的偏差。

                                                                    因此,我们建立了三层验证。

                                                                    ▐10.1 第一层:静态结构与契约校验

                                                                    静态检查用于回答新应用是否结构自洽,包括:节点是否完整、Bean 实现是否一致、输入参数是否都有生产者、输出是否被正确消费、Plan 是否引用有效物料、配置类型和默认值是否一致。

                                                                    这类问题可以确定性判断,应尽量在部署前由脚本发现。静态检查能够证明结构和契约闭合,但不能证明业务语义天然正确。

                                                                    ▐10.2 第二层:固定外部输入,分阶段比较新旧链路

                                                                    为了隔离实时外部数据变化,我们采用“录制旧链路、回放给新链路”的方式:旧链路真实调用召回和打分服务时记录请求与结果,新链路在对应调用点使用同一份数据。这样,新旧链路的关键外部输入保持一致,剩余差异才更可能来自迁移逻辑。

                                                                    比较也不是只看最终响应,而是按照召回、特征处理、打分、重排和结果组装逐层进行。发现差异后,先定位第一个出现偏差的阶段,再判断它属于预期配置差异、顺序无关差异、实时字段差异,还是需要修复的逻辑错误。

                                                                    录制回放验证过程

                                                                    ▐10.3 第三层:预发、灰度与生产观察

                                                                    Mock 可以隔离外部不确定性,但也可能掩盖真实集成问题。因此,静态检查和mock对比通过后,仍需要经过预发真实调用、分批灰度和生产观察。

                                                                    灰度阶段同时观察技术和业务指标:接口成功率、RT 分布、节点异常和超时、核心业务指标和策略指标。AI 和工具可以整理证据、聚合差异并给出修复候选,但灰度放量和回滚始终由人工授权。

                                                                    迁移稳定性的目标不是证明 AI 永远不会出错,而是让错误尽可能早地暴露,能够定位到责任阶段,修复后可以重跑,并且每次生产决定都有证据和责任人。

                                                                    结果

                                                                    ▐11.1 已迁移场景的运行表现

                                                                    新体系已在部分真实场景上线接流,并使用一套代码和一个主干承载所有已迁移场景。当前记录的四个场景中,迁移后的平均 RT、P99 RT 和 P999 RT 均未出现劣化:

                                                                    表中数值表示“迁移后 RT - 迁移前 RT”,负数代表耗时下降。这组结果可以支持的结论是:在已经统计的场景中,新体系没有引入可见性能劣化,部分场景的长尾 RT 有所改善。

                                                                    性能改善主要来自迁移过程中重新梳理执行关系,将部分不合理的串行操作调整为并行执行,而不是新框架性能更优。

                                                                    ▐11.2 迁移方式已经发生变化

                                                                    三个迁移阶段的人工投入或周期呈下降趋势:主播关注页人工迁移约 20 人日,直播频道页在 AI 参与并同步建设 Skill 的阶段约 10 人日,后续复用 Skill 缩短到单场景约 3 天。

                                                                    这组数字来自不同规模和复杂度的场景,不能直接当作严格效率实验。它更适合说明研发重心的变化:人工从逐项理解、设计和编码,逐渐转向业务约束补充、架构取舍、差异判断和生产授权;AI 承担批量分析、结构转换、代码及配置生成和重复修复;确定性工具承担事实解析、生成和校验。

                                                                    复盘:比“让 AI 写代码”

                                                                    更重要的四个判断

                                                                    第一,历史系统迁移必须先建立人工事实基线。

                                                                    如果不知道旧系统哪些行为必须保留、概念如何映射、什么证据代表正确,AI 只能生成“看起来合理”的代码。人工迁移不是需要尽快绕过的低效步骤,而是后续自动化的事实和验收基础。

                                                                    第二,先降低系统的解释成本,再扩大 AI 的执行范围。

                                                                    AI 可以读取复杂代码,但稳定交付不能建立在每次都重新理解全部历史上下文上。统一物料、显式参数、受约束流程和结构化执行信息,本质上是在把人脑中的隐式知识变成机器也能使用的工程契约。

                                                                    第三,确定性问题不要长期留给模型推理。

                                                                    图依赖、参数闭环、Bean 注册和 Plan 结构都可以由程序稳定判断。真实迁移中,每遇到一种可重复错误,都应该判断能否沉淀为解析器、生成器或校验器。模型负责处理语义和差异,工具负责保证重复动作的稳定性。

                                                                    第四,生成、验证和生产授权必须保持职责分离。

                                                                    AI 可以生成代码、归纳日志和提出修复建议,但不能同时定义通过标准并批准自己的结果。业务语义、例外判断、灰度放量和回滚仍然需要明确的人工责任。可信迁移不是追求无人参与,而是让人工判断集中在真正需要负责的环节。

                                                                    结语

                                                                    新架构体系的价值不只在于把一种图结构替换成另一种流程结构,也不只在于帮助 AI 更容易生成代码。它真正改变的是历史应用的生产基础:公共能力有统一物料,场景差异有显式编排,执行流程有稳定语义,每次运行有结构化证据。这些结构降低了 AI 理解、生成和验证的成本,真实迁移又把一次性经验逐步沉淀为可复用的 Skill 与工具,它们共同构成了现阶段对 AI Friendly 的支撑。

                                                                    这次实践给我们的最终判断是:面对复杂历史系统,AI 迁移的起点不是更长的提示词,也不是更激进的自动生成,而是先把系统改造成可理解、可约束、可验证的形态。

                                                                    工程基础决定了 AI 能够安全走多远,也为未来 AI 理解需求、完成开发提供了支撑,让生成结果更可控、交付质量更稳定。

                                                                    团队介绍

                                                                    本文作者凉一,来自淘天集团-直播搜推工程团队。团队聚焦直播搜索、推荐与智能交互场景,负责商品、直播及直播看点的数据与索引建设,召回、粗排、精排等在线工程链路,以及面向消费者的直播 Agent 研发,持续提升系统性能、稳定性与业务迭代效率。同时,团队探索 Agent 在直播业务中的应用,推动算法能力与业务需求高效落地,为用户提供更精准、流畅、智能的直播内容发现与消费体验。

                                                                    跳转微信打开

                                                                    •  

                                                                    Taobao3D 拓扑生成算法开源!让高保真 3D 更轻量

                                                                    原创 Meta 技术团队 2026-10-28 10:20 浙江

                                                                    淘宝Taobao3D大模型,轻量化高保真建模赋能电商3D购物

                                                                    图片

                                                                    Taobao3D 是阿里巴巴淘宝 Meta 技术团队研发的 3D 大模型技术,旨在降低高质量 3D 商品的生产成本,推动电商 3D 商品的规模化供给。该技术支持商品的高保真 3D 建模,以及在手机、XR 设备等多终端上的实时渲染与交互,让用户能够更直观地了解商品细节,获得更具沉浸感的购物体验。

                                                                    相比传统电商以图片和视频为主的商品表达方式,3D商品在展示形式与交互体验上更具优势。借助3D展示、AR试摆、3D广告等应用场景,3D商品能够帮助用户在线上更直观、真实地感知商品,助力提升转化率、延长停留时长并降低退货率。

                                                                    在实际落地中,手淘对3D模型的资产体积、渲染性能与还原度提出了严格要求:为保障流畅的用户体验,3D模型需实现秒级加载,资产体积小于5 MB,渲染帧率高于40 fps;同时,还需准确还原商品的材质类型、纹理细节,确保视觉效果与实物保持高度一致。

                                                                    然而,现有的3D重建与生成方案往往面临两大挑战:一是网格拓扑杂乱、面数多、模型体积大,且减面过程中几何细节损失严重;二是材质解耦困难、纹理细节易丢失,导致商品还原度不足。针对上述痛点,淘天集团Meta技术团队推出了两项行业领先的最新研究成果:3D原生网格生成模型TaoFlowForge与3D原生材质大模型TaoTex。前者聚焦轻量化、拓扑干净的网格生成,在精简网格的同时尽可能保留几何细节;后者着力突破材质精确解耦与纹理高频细节(文字&logo)还原难题。两者协同,实现分钟级3D资产建模,在保持高还原度的同时,将资产体积控制在5 MB以内,支持手淘等应用场景的秒级加载。

                                                                    图片

                                                                    相关技术报告&代码同步开源

                                                                    论文标题:TaoFlowForge: Progressive Native Mesh Generation via Cascaded Flow Matching

                                                                    论文链接:https://arxiv.org/pdf/2609.37139

                                                                    开源链接:https://github.com/alibaba/Taobao3D

                                                                    论文标题:TaoTex: Boosting Texture Detail Fidelity For Native 3d Material Generation

                                                                    论文链接:https://arxiv.org/pdf/2609.34934

                                                                    项目链接:https://xchaowu.github.io/papers/taotex/index.html

                                                                    TaoFlowForge:基于级联流匹配的

                                                                    渐进式原生网格生成

                                                                    自回归拓扑网格生成方法难以做到高效可控的复杂拓扑结构生成,当前公开的扩散模型生成方法也面临生成的整体结构不稳定、依赖繁重的后处理等问题。针对这一研究现状,淘天Meta技术团队提出了TaoFlowForge:一个面向原生生产级3D网格生成的基础模型。该模型采用三阶段渐进式原生网格生成方案,能够生成轻量、可编辑且拓扑干净的网格。我们已在技术报告中公开全部算法细节,并同步开放代码与模型权重,后续将持续迭代模型并发布更新。

                                                                    TaoFlowForge生成的Mesh网格效果展示

                                                                    ▐现有原生网格生成方法的瓶颈

                                                                    不同于基于连续场的隐式表示,原生网格生成直接操作顶点与面片(V,F)。现有方法主要可以分成两大主流技术路线:

                                                                    第一种是自回归方法,参考大语言模型(LLM)的做法,将三维网格编码为一维长序列,在推理时逐token生成。该方法在前期探索阶段取得了良好的效果,但是瓶颈也逐渐显现:强行降维会导致空间信息不可逆丢失,模型只能“死记硬背”空间结构;且随着面数增加,面临“序列爆炸”带来的推理高耗时和高不稳定性。

                                                                    第二种是最近受到广泛关注的扩散模型方法,这类方法的扩散过程在原生三维空间进行,保留了三维结构信息,但往往在顶点生成的稳定性上仍有不足,整体结构容易出现偏差;同时未将面片的法线朝向预测考虑进去,离不开繁琐的后处理过程。

                                                                    ▐顶点与拓扑分离的结构设计

                                                                    TaoFlowForge方法流程图

                                                                    针对现有方法存在的问题,淘天Meta技术团队提出了TaoFlowForge生成模型。在生成范式上,TaoFlowForge采用扩散模型直接进行原生网格建模。TaoFlowForge将整个生成过程分成三个阶段,前两个阶段定义为“顶点流”,专注于生成高精度、不失真的几何顶点集合V,第三阶段则定义为“拓扑流”,专门负责预测顶点之间的连接关系F以及顶点法向量。这种渐进式、分阶段的生成策略,有效降低了模型的端到端优化难度,显著提升了最终原生网格的拓扑纯净度与结构稳定性。

                                                                    ▐顶点流:“两步走”策略,解决八叉树的“误差累积”问题

                                                                    为了让生成的 3D 模型“骨架”端正、细节丰富,TaoFlowForge在顶点生成上做了一个关键的设计决策:摒弃一步到位的连续生成,采用“由粗到精”的两阶段渐进式方案。这就好比一位雕塑大师,先用泥巴捏出大体轮廓(定型),再用雕刻刀精雕细琢(刻画细节)。

                                                                    第一阶段:定骨架(全局塑形) 

                                                                    技术路径:TaoFlowForge采用了Trellis的结构设计,首先用DiT生成16^3分辨率的结构隐变量,随后通过 VAE 解码器一次性上采样,得到64^3分辨率的顶点占用体素(voxel)。

                                                                    这一做法能很好的利用已有开源模型的强大先验信息,在低的分辨率下先把大的结构稳住,确保物体的轮廓正确。

                                                                    第二阶段:雕细节(精细刻画)

                                                                    技术路径:在得到64^3体素后,模型直接在原始坐标空间中进行三次连续上采样,最终提升至512^3的高分辨率,获取精准的量化顶点坐标。

                                                                    为了把细节逼真度拉满,这三个层级的上采样过程分别由三个完全独立、各司其职的DiT模型来完成,而不是用一个统一的模型“一干到底”。

                                                                    为什么这个设计更有优势?

                                                                    虽然整体上依然遵循经典的八叉树上采样思想,但TaoFlowForge的核心优势在于解耦控制:通过将“整体骨架”与“微观细节”的控制约束剥离,缓解了八叉树在连续上采样中“一步错、步步错”的误差累积硬伤。最终带来的直接提升,就是模型在整体结构上的高稳定性与微观细节上的高还原度。

                                                                    ▐拓扑流:引入顶点法向量的融合拓扑编码

                                                                    在确定了顶点位置V后,第三阶段的核心任务是预测顶点的连接关系F。为此,TaoFlowForge提出了一种融合了顶点连接关系与顶点法向量的拓扑编码VAE模型。

                                                                    • 拓扑与物理属性的特征融合

                                                                      该模型将每个顶点表征为一个高维特征向量,该向量同时编码了局部几何连接关系(Topology)与表面法向量(Normal)。

                                                                    • 保持顶点位置的一步式推理

                                                                      在推理阶段,算法在保持顶点空间位置V不变的前提下,直接预测出拓扑连接矩阵以及每个顶点的法向量。二者结合,即可得到结构完整、面片法向量确定的Mesh网格。

                                                                    ▐拓扑生成结果展示

                                                                    TaoFlowForge现已完全开源,与其他开源模型对比的可视化结果如图所示。EdgeRunner方法是自回归模型网格生成方法的开源代表,LATO.2则是扩散模型网格生成方法的开源代表。从图中可以看出,TaoFlowForge产出的网格整体结构稳定性最优,细节最丰富,面片拓扑结构最干净。

                                                                    与开源方法的效果对比

                                                                    更多结果展示

                                                                    更多可视化效果视频展示:

                                                                    TaoTex: 高保真3D原生材质生成

                                                                    TaoTex 生成的纹理材质展示

                                                                    材质直接决定了3D资产的最终视觉呈现。原生3D材质虽具备全局一致性、无缝衔接及无投影伪影等天然优势,但目前在高频纹理的高保真重建上仍面临瓶颈,尤其在简单几何表面的文字与精细标识呈现上表现受限。针对这一行业痛点,我们推出了首个支持高频纹理重建的3D原生材质大模型TaoTex,攻克了细节还原难题,实现了物体表面文字、Logo及精密纹理的高保真生成。

                                                                    ▐为什么要原生3D材质?

                                                                    当前3D纹理材质的生成主要分为两大技术路线:一是多视图生成结合表面投影,即将2D视角的纹理反向映射至几何表面;二是直接在3D空间中原生生成。其中,基于多视图投影的方法存在三项核心缺陷:

                                                                    • 全局一致性较难保证:多视角生成的纹理在重叠视域内往往存在差异,反投影后极易引入鬼影,尤其是是在复杂纹理区域;

                                                                    • 纹理融合难以无瑕:重叠区域的贴图拼接与混合难以做到完美过渡,在接缝处常有明显的融合瑕疵与缝隙;

                                                                    • 几何与纹理对齐容错率低:投影方法对深度边缘的对齐精度要求极高,微小的几何误差即会导致严重的纹理拉伸、撕裂或视差断层。

                                                                    相比之下,原生3D材质生成直接作用于三维表征,从机理上彻底规避了上述投影与多视角带来的固有缺陷。

                                                                    ▐原生3D材质的再次突破

                                                                    现有原生3D材质方案仍存在明显局限:在几何特征显著的区域(绿框),模型可以借助形状线索,将输入图像中的纹理对应到三维表面;但在几何先验较弱甚至缺失的区域(如红框中的平整表面文字),则完全无法精准还原。为攻克这一难题,TaoTex 从数据构建、模型架构及训练策略三方面进行了全方位优化,率先在“几何平坦但纹理高频”这一区域的纹理生成上取得了关键突破。

                                                                    类似“表面几何平坦但附带高频纹理”的特征在现实资产中极为普遍,典型如带有印刷图案与文字的服装、包装盒、日用品等。TaoTex的提出,使原生3D材质生成从理想化的几何模型走向复杂真实的现实资产,显著提升了该类模型的泛化能力与通用适用性。

                                                                    更多案例关注 https://xchaowu.github.io/papers/taotex/index.html

                                                                    ▐领先行业的纹理材质重建效果

                                                                    TaoTex同时支持单图和多图输入,相比行业现有方案,TaoTex 不仅能高精度重建复杂的文字与图案细节,在粗糙度、金属度等物理材质属性的预测上,同样展现出压倒性的综合优势。

                                                                    在多视图重建任务中,TaoTex 能够精准还原各视角下的纹理细节,实现高度自然、无瑕的平滑过渡。

                                                                    业务应用:提升购物体验

                                                                    目前3D模型已经在手机淘宝、PC淘宝上线,3D资产大小小于5MB,支持手淘和PC淘宝秒级加载和实时交互渲染。利用3D的特性:空间感、交互性、冲击力,可以让消费者可以在家提前试用商品,更准确了解商品大小和尺寸,缩短“理解—比较—决策”的路径,提升购买信心;同时也可以让商品用更具表现力的内容呈现商品卖点,提升点击率,减少因信息不充分造成的售后成本。

                                                                    团队介绍

                                                                    本文作者来自淘天集团-Meta技术团队,该团队在端侧智能、端云协同、商品三维重建、真人三维重建、3D引擎、企业级软件AI研发等方面有着深厚的技术积累,先后发布端侧推理引擎MNN、商品三维重建工具Object Drawer、Taobao3D大模型、3D真人数字人TaoAvatar、端云协同系统Walle等。团队在OSDI、MLSys、CVPR、ICCV、NeurIPS、TPAMI等顶级学术会议和期刊上发表多篇论文。欢迎对3D大模型、端侧引擎和端侧大模型、渲染引擎、AI研发等感兴趣的优秀人才加入,一起技术创新和应用探索。

                                                                    跳转微信打开

                                                                    •  

                                                                    天猫数字员工(效能篇)- 多角色场景下的 AI 研发流转效能分析

                                                                    原创 天猫技术团队 2026-10-26 11:40 浙江

                                                                    AI研发提效瓶颈在于轮次交接等待。

                                                                    图片

                                                                    本文分析了天猫技术数字员工在多角色 AI 研发场景下的流转效能。数据表明,尽管 AI 已大幅减少编码环节的人工介入,但交付周期的缩短幅度有限,主要瓶颈在于各轮次交接间的等待耗时。为此,文章提出通过“产物驱动”与“协作调度”双管齐下提升流动效率:一方面推进产物标准化与质量门禁以实现自动接续;另一方面针对仍需人工判断的环节,通过卡点私聊跟进、群内上下文提醒及个人日报聚合等主动推进机制,精准诊断并消除交接缺口,从而将局部执行提速转化为团队整体交付能力的提升。

                                                                    图片

                                                                    前言

                                                                    天猫技术正在建设统一的 AI 端到端交付架构:数字员工提供统一入口与运行时,驻进需求群承接交付;各业务域按需装配并持续沉淀自己的知识、技能与子 Agent。它与产品、前端、后端、测试共享上下文,接需求、写方案、调度 Agent、跟进交付,像一位全程在场的同事。目前已经在天猫技术的所有业务线进行落地推广,月均活跃需求交付100+。

                                                                    导读|本文基于天猫真实业务需求的交付数据,分析 AI 研发效能的影响因素,并针对协作中的交接等待,给出提升流动效率的数字员工实践方案。

                                                                    我们先从交付记录分析周期差异,再区分可自动衔接的环节与必须保留的人工判断。本文重点是后者:怎样诊断交接缺口,通过卡点跟进、群内提醒和个人日报组织协作,并验证是否带来有效推进。产物标准化与自动质量门禁可以减少重复交接;本文关注当前尚未自动贯通、以及仍需业务判断的部分。

                                                                    本文为此系列第三篇内容。

                                                                    第一篇:《天猫数字员工(协作篇)- 研发的暗物质与 AI Native 组织协作》

                                                                    第二篇:《天猫数字员工(实践篇)- 接管全链路:交付能力与技术拆解》

                                                                    数字员工以钉钉为协作入口。每条需求对应一个场景群,产品、设计、开发、测试与它共享同一份需求上下文;从 PRD、设计稿和技术方案,到编码、测试、发布与复盘,产物都回到群里。团队不用更换协作工具,@ 它即可发起任务,私聊也能使用同一套能力。

                                                                    找到入口 → 提出需求 → 确认方案 → 执行验证 → 验收交付 → 状态回写;

                                                                    六个节点均取自真实需求场景

                                                                    周期要重新算:从阶段到轮

                                                                    ▐2.1 研发模式变了,评估单元也要变

                                                                    传统研发按阶段接力,需求、开发、测试各有负责人。数字员工承接方案到部署后,人通过"提要求—AI 交付—验收或纠偏"让结果逐轮收敛,接手方可以是任何角色。人又并行参与多条需求:AI 做完时,接手人可能正在别处工作。评估因此要从"阶段"细化到"轮",看清每次交付后的等待。

                                                                    左:按阶段观察角色交接;右:细化到每轮执行 a 与接手等待 w;

                                                                    底:沿需求关键路径拆解周期,并行分支不重复相加

                                                                    沿需求的关键路径,分别记录每轮执行与接手的时间:

                                                                    周期 = 每一轮里(AI 做的时间 + 人回来的时间)的总和 + 外部等待

                                                                    一轮从人的输入开始,到 AI 交付、人接手给出下一步输入。旁听纪要、日批等自发活动不计入;轮外的外部等待单独记录,避免重复。并行任务只沿决定完结时刻的关键路径计算,不能把各分支耗时直接相加。

                                                                    ▐2.2 模型:通过 Harness 缩短轮数,通过协作缩短等待

                                                                    式子里的时间分两半。AI 做的时间和轮数归 Harness 与业务知识:一轮做得准不准、要来回几轮、人还要不要下到编码层,取决于模型、工具链、技能和沉淀的业务知识,实践篇、资产篇讲的都是这一侧。人回来的时间和外部等待归协作:产物交付之后需要谁判断、何时接手、是否值得此刻推进,取决于组织怎么安排接手。两个方向都决定周期,具体怎么做放在第 2 节。要比较两边各占多少、哪个因子真正起作用,先得能把它量出来。

                                                                    绿箭头指向 AI 做的时间与轮数,橙箭头指向人回来的时间与外部等待;

                                                                    两侧都是周期的组成部分,图内比例为示意

                                                                    一条需求的十四天长什么样。每一天,只要有人发言、数字员工回复或工具调用,就算这条需求在动;连续没有,就是停下来了,停的时候在等谁,从数字员工最后说的那句话里读出来:

                                                                    14天中7天有可见活动,流动效率为0.50;系统拼接的合成轮不计入。

                                                                    它衡量活动连续性,不是有效工时或任务完成比例

                                                                    这条需求十四天里动了七天,流动效率 = 流动天 ÷ 流逝天 = 0.5。它回答的只是"需求在不在动",不是有效工时,也不是完成比例;但它零填报、每天可算,是后面所有分析的起点。

                                                                    一条需求这样算清楚之后,就可以放到一批需求上去问:什么决定周期?先猜——把可能影响周期的量都列出来,从数字员工沿交付过程留下的记录里能提取七个候选因子:

                                                                    左:数字员工沿交付过程自动留下的记录;中:七个候选因子各自怎么算、回答什么问题;

                                                                    右侧标签是可能的改进方向,不是责任划分或投入排序

                                                                    ▐2.3 数据验证:等待占据周期主体,流动效率是关键因子

                                                                    模型到此给出两个待验证的判断:协作一侧占据周期主体,流动效率是关键因子。下面用真实数据分别检验。

                                                                    验证一:周期的主要构成落在协作一侧。 先看 Harness 这一侧。在成熟业务场景、Harness 工程较完善的条件下,编码层平均约 0.5 轮人工介入,人几乎不再需要下到代码里改。按这个投入,如果周期主要由执行决定,交付应该快出好几倍。

                                                                    实际快了多少?下图把数字员工参与的需求和历史基线放在同一把尺子下比:从首次代码提交到上线,按复杂度分层。看点是两句话:整体确实快了,这组样本里四档都缩短;但幅度只有一到三成,离"数倍"的量级差得远。 交付仍然以天、周计。执行层几乎不需要人了,周期却只快了这么一点,省下的时间去哪了?

                                                                    历史样本对照:数字员工组39个已上线需求,部分层样本较少,且使用并非随机分配。图内降幅只描述这组样本,不外推为普遍提效;日历周期也不等于模型执行时间,不能与人工介入次数直接换算

                                                                    从活动记录中寻找等待线索。 把已完结需求验证期的每一天按活动归类,返工与验证只占一小部分,沟通与静默占比较高,提示交接等待值得进一步关注。这个分类用于寻找线索,不能直接测量 AI 执行耗时,也不能量化执行提速后有多少时间转为等待:

                                                                    保留早期天粒度归类图,不是 AI 运行耗时的直接测量;图中9%/91%不能用来精确拆分执行与等待。下方为另一批静默记录的主要归因,与后文261段样本口径不同,不可拼算;模型分类未经人工抽检

                                                                    验证二:控制变量后,流动效率与较短交付周期的关联较强。 控制复杂度、改动规模与建群时机后,流动效率在图示因子中的偏相关绝对值最大;交付深度和纠错返工轮的区间也不跨零。把已完结需求按流动效率分成低、中、高三组,交付周期中位数分别约 22 天、14.5 天、8 天。流动效率与交付深度的偏相关分别约为 −0.55、−0.42,其他因子的结果见图:

                                                                    n=29;左侧为控制变量后的偏相关与90%重采样区间,右侧为同一样本按流动效率分组的周期中位数,不是控制变量后的收益。两侧均为观察性结果:样本非随机,流动效率与周期共享时间信息,不能据此认定因果关系,也不能把组间差异解释为提醒效果。纠错负相关不等于多返工会更快

                                                                    多角色协作里,一次关键接手的延迟,可能把等待传到整条依赖链上。 这就是本文余下篇幅要处理的那一半:Harness 方向的产物标准化与质量门禁在 2.1 简述,协作方向从 2.2 起展开。

                                                                    除了继续提升 AI 的交付能力,我们把优化落到交接上:减少重复核对,让必要的评审、验收和发布判断及时接上。

                                                                    怎么让需求转起来

                                                                    规则与授权明确的交接,尽量由产物直接触发;仍需人判断的交接,把材料与接手安排组织清楚。 例如 PR 合入后可以触发流水线,而报告中的风险是否接受、何时发布,仍可能需要相应角色确认。同一条需求中,这些做法可以配合使用。

                                                                    目标机制与当前边界示意:标准化产物经质量门禁后,在明确规则与授权内接续;未自动覆盖的检查与必要业务判断仍需组织接手,不代表已全量实现。

                                                                    ▐3.1 产物驱动:减少不必要的人工交接

                                                                    产物标准化要解决的,是下一环节能否直接使用这份产物。 以代码变更接预发验证为例,仅有一句“测试通过”还不够:要知道测的是哪个提交、哪个环境,覆盖了什么,失败项与执行证据在哪里。信息没有约定清楚,接手人就只能重新询问和核对。

                                                                    Harness 向交付流程延伸,需要把这些约定变成可执行的契约:

                                                                    • 产物契约:关联需求、代码版本与目标环境,保留验证范围、结果、失败项和证据入口。标准化的不只是格式,还包括可追溯性与下一步所需的信息。

                                                                    • 质量门禁:校验产物完整性、版本一致性及约定的质量条件。检查失败或证据不足时返回补齐、修复与重验,不把“报告已生成”当成“可以继续”。

                                                                    • 接续规则:明确门禁通过后能触发什么动作、由谁执行、需要什么权限,以及成功终态。质量合格不等于获得发布授权;超出规则的判断仍交给对应角色。

                                                                    把这三项约定连起来,产物的下一步才不需要靠人反复转述:

                                                                    接预发验证的设计示意:校验失败先补齐、修复与重验;规则或授权未明确先找责任人确认,结果回写后仍须校验。质量达标不等于获得发布授权,不表示全链路已经自动化

                                                                    当标准、门禁与授权能在覆盖范围内稳定执行,重复追问材料、人工搬运结果和重新发起任务,就有机会从流程中消除。产物既是本轮的交付,也是下一环节可消费的输入。“PR 合入触发流水线”就是一个例子;这类以版本化产物衔接流程的机制,也见于 Anthropic 的 AI 原生软件开发手册。

                                                                    当前的限制是覆盖与贯通还不完整,不是这些方向不重要。 我们已有业务知识与技能装载的实践,但不同业务的产物约定、质量规则、验证环境和操作授权,尚未连成一条稳定的自动交付链。不能把门禁未通过的产物往后推,也不能假设一次技术检查已经替业务作出了验收或发布决定。

                                                                    因此,减少交接等待有一条更根本的路径:把可重复检查的条件前置进 Harness,让合格产物在授权内自动接续。协作机制则承接当前尚未覆盖的检查,以及不能由既定规则代替的业务判断。

                                                                    ▐3.2 协作调度:接续仍需人参与的环节

                                                                    需要人参与的交接,要区分尚未自动化的检查与需要责任人判断的事项。前者应持续沉淀为标准和门禁;后者如业务口径、风险接受、发布窗口,仍需相应角色给出结论。数字员工负责准备材料、保留待处理事项并读取后续回应,让接手人不必重新寻找上下文,而不是代替他作出决定。

                                                                    需要人判断时,产物、问题和回答沿同一条需求接续:

                                                                    协作时序示意,沿用实践篇的主子 Agent 与共享会话视角。图中展示信息怎样回到执行上下文,不表示收到回复就自动验收,也不预设固定角色流水线。

                                                                    本文重点展开这部分协作工程。 我们把这种持续核对进展、组织必要接手的工作方式称为“主动推进”。它与产物驱动配合:能按规则继续的环节直接衔接,需要人判断的环节保留判断权,协作系统负责把依据与待办送到合适的位置。

                                                                    要组织接手,先得知道等待是否真实:是缺少某项条件、尚未有人接续,还是已经有了新的安排?只凭群里多久没人说话,还不足以选择动作。

                                                                    主动推进前,

                                                                    先确认需求在等什么

                                                                    只凭群里多久没人说话,还不足以选择动作,原因有两个。一是群聊看不到全部工作:测试可能在群外进行,发布可能另有排期,几天没动静不等于没人在做。二是静默的原因不同,该做的动作也不同:缺一份材料和忘了验收,不该用同一句话去催。

                                                                    我们在这里踩过坑。第一版群内提醒只看静默天数,到点就发模板消息,上线十五分钟就撤了:对方昨天刚说"下周再看",系统今天仍会照常催促。从那以后,静默只当排查的入口;发消息之前,先把最近一次交接还原出来:上一份产物交给了谁,对方还缺什么,有没有新的安排。 这一节讲怎么还原:先看在等什么,再看停在哪个阶段,最后落到缺的到底是什么。

                                                                    ▐4.1 在等什么:静默记录里的交接线索

                                                                    先看等待长什么样。下面是一批需求的十四天活动矩阵:每一格是当天有没有活动,空格连成一段就是一次中断;中断从哪一天开始、当时交付到了哪一步,是核对的起点:

                                                                    从原图对应的2026年8月29日历史快照选取6条需求,名称泛化;每格仅表示当日有无活动记录,距图末按最后活动日期计算。交付状态单列,“等人回应”为待核验线索,不能直接判定卡点或弃用。

                                                                    每一段中断,取静默前数字员工最后说的那句话来判断在等谁。最常见的是"等人回应",占 66%:数字员工已经提交了方案、代码或测试报告,后面需要一次评审、验收或新的指令。其余是补材料、评审或排期,以及权限、环境等不同线索:

                                                                    n=261,剔除按静默超过十天推断为弃用的记录;按段数而非时长统计,沿用原图显示比例。归因与弃用均为自动判定,尚未人工核验

                                                                    但最后一句话只保留了发起交接的现场,未必包含接手的结果,测试可能已经在群外进行,发布也可能另有排期。所以"等人回应"是待核对的线索,要连同交付物和后续对话一起看,不能直接变成发给某个人的催办。

                                                                    ▐4.2 停在哪个阶段:按阶段核对交接材料

                                                                    知道了在等什么,还要知道停在哪个阶段。同样是"等人回应",停在需求讨论阶段和停在测试阶段,要核对的材料完全不同。把静默开始时的需求状态和等待分类交叉起来,排查方向就具体了:

                                                                    261 段过滤后静默中,156 段有状态记录,另有 105 段未纳入此图。单元格为段数,着色按行内占比;状态与分类用于缩小核对范围,不能直接决定推进动作。模型分类未经人工抽检

                                                                    需求讨论阶段,25% 被归为等需求侧。此时先查 PRD 中的业务口径和约束是否明确,待确认的问题有没有得到回答。若方案还依赖一次业务决策,继续催开发进度就找错了对象。

                                                                    进入开发和预发后,要看代码、执行记录及验证条件。预发验证阶段,21% 被归为等权限和环境。一份实际日报就记录过这样的情况:需求已在开发,但缺少 Arthas 权限,无法完成预发验证。需要补的是权限;只问"开发完了吗",无法解除这个障碍。

                                                                    测试产物已经交付时,检查对象又变了:报告里的失败项是否仍待处理,验收结论是否已给出,后续对话有没有约定发布时间。"报告已提交"只确认了交付动作,接手情况要从后续记录中找。 同一个"等人回应"标签,到这里才被还原成具体问题。

                                                                    ▐4.3 缺的到底是什么:卡点与待接手

                                                                    分类和阶段都只是线索,最后要落到一个能核对的问题上:这条需求现在缺的到底是什么。 按"对下一步的阻碍知道多少",等待分成两种:已经知道缺什么的,是卡点;还不知道接下来怎么安排的,是待接手。区别不在哪条需求沉默得更久:

                                                                    结构示意:锁表示已确认的条件缺口,问号表示接续安排尚待核对;虚线表示尚未衔接,不表示等待时长。两种情况都需保留交接依据,已有明确排期不能判成无人接手。

                                                                    • 卡点:已经确认具体障碍。例如缺少权限使验证无法执行,缺少业务结论使方案无法定稿。诊断需要把障碍与受影响的动作对应起来,并核对谁有能力解除它。

                                                                    • 悬置(待接手):已有交付物,但记录中尚未看到接续,也未确认具体障碍。此时缺的是对当前安排的了解:是否有人在群外处理、是否另有排期,或确实还没有人接手。

                                                                    两种情况的诊断都要留下最近的产物、未完成的动作、相关角色和已有约定。查到明确排期,说明这段等待已有安排;查到具体障碍,才有依据提出补齐条件的动作;尚不清楚的部分保留为待确认问题,不能用模型的分类标签补成事实。

                                                                    诊断的产出,是一份带依据的交接记录。 下一节讲怎么把它送到合适的人手里,并让之后的回应、排期和处理结果持续更新同一条记录。

                                                                    需求流转优化实践

                                                                    交接记录进入产品后,要按协作范围组织,不能统一发成一条催办。 一个明确问题可以定向跟进;一条需求的接续信息可能散在多个角色手里;同一个人还需要看到多条需求的整体进展。

                                                                    交接记录提供共同依据:具体问题定向到人并持续跟进,需求安排回到群里共同确认,多条需求按个人聚合;回应与新约定回写原记录。三种方式并行,不是逐级加压的催促链

                                                                    这些方式可以并行:群内确认验收安排,私聊跟进一个权限问题,日报汇总与本人有关的进展。日报提供跨需求视野,不是催办的前置步骤。

                                                                    触达范围与执行授权分开判断。 数字员工可以整理材料、提示待处理事项;代办具体操作需要委托与确认,验收和业务取舍仍由相应角色决定。权限、环境问题的申请与处理遵循平台流程,材料补齐和责任接手仍可纳入协作跟进。

                                                                    呈现、提醒、催办与代办分别约束触达和授权;更强的动作需要独立依据,不是上一种方式无效就自动升级。

                                                                    ▐5.1 卡点推进:把具体问题私聊给能解决的人

                                                                    先讲一条需求。数字员工接到需求群里的交接,准备开始出方案,发现 PRD 还没有给到:群里只有一句口头描述,业务口径、边界和验收条件都在那份没到的文档里。它在群里询问后没有人回应:不是没人看见,是这份材料只有提需求的那位同学能补,而他当时正在别的群里忙。需求就停在了这里。

                                                                    这种停和"忘了"不一样:缺什么、缺在谁那里、为什么缺,群里的上下文已经说清楚了。 数字员工在工作时段里等了十二个小时没有回应,就把这件事记成一条卡点:问题是什么(交接缺少 PRD),需要谁做什么(对应处理人补齐交接材料),依据是群里的哪句话。然后它不在群里重复提醒,直接私聊那位同学一条消息:这件事卡在你这里,缺 PRD,补上就能继续。

                                                                    私聊卡片如下。待处理事项、谁提出的、已经挂了多久放在一起;接收人可以点「我已知晓」,也可以直接反馈这不是他的事:

                                                                    私聊卡片为独立测试截图,人员与群名已打码;“我已知晓”只记回执,不能作为问题已解决的证据。

                                                                    私聊发出之后,跟进并没有结束。这条卡点同时挂在需求群的协作看板上,谁都能看到它在等谁;后面群里的对话数字员工继续读——材料补上了、有人明确处理了、或者负责人说一句"这个我来跟",它就相应更新状态,处理完的自动消失,不用人手动关。看板与后续回应的样子如下(示意,非同一条实录):

                                                                    另一个真实事项的看板、回应与概要记录,人员和内部标识已打码;不与前图 PRD 私聊测试串成同一条实录。这里记录的是责任交接,不是开关已经打开。

                                                                    这里有三个判断要分开:知晓只是回执,自行跟进是责任交接,问题真正解除才算解决。 三者对后续的处理不一样:点了"知晓"的还要继续看,接手了的停止催促,解除了的才关闭。关闭要有证据:材料补齐、明确处理,或者后续动作证明障碍已经不在;误判和过期单独记,不算解决。回放里还见过另一种漏法:同一个问题被反复提出、被转派的人一直没接,群里其他话题却聊得很热闹。只看最后发言时间会把它漏掉,所以计时的对象是这个问题,不是这个群。

                                                                    产品设计示意:知晓、接手和解决分别影响后续跟进,不把所有回复都当作问题已解决。

                                                                    私聊是定向触达,不是加压:有提出来源,遵守免打扰、去重和个人频次上限;不向主管升级,不做催办排行;需要数字员工代办时,先取得委托和确认。处理人看完应当知道该做哪件事,而不是只知道有人在催促。

                                                                    ▐5.2 群内提醒:让相关成员接上这条需求

                                                                    另一种停没有任何障碍。数字员工做完了一个动作,比如跑完测试、交了报告,接下来该有人验收、给下一步。但评审在忙别的,PM 在跟另一条需求,群主也没注意到,几天过去,这件事便停留在群里,没有人再想起。

                                                                    一条真实的需求就是这样:测试报告已经交付,之后几天群里没有任何动静。数字员工在群里提了一句:报告已经完成,是否需要确认验收。需求负责人想起来了,把测试负责人拉进群,明确了核销、top 核销和门店分账三块的测试范围,说会进一步说明测法。一条停了几天的需求,因为这一句重新动了起来:找到了具体接手人,明确了分工:

                                                                    原始截图摘录与拼接:仅裁剪和遮挡人员信息,消息内容未改写;第二屏保留具体 @ 对象并打码,使用新提供的“等验收5天”截图。素材来自不同时间,不作为连续时间实录;对接测试负责人不等于测试完成或验收通过,单次后续推进也不能直接归因为提醒的效果。

                                                                    这就是群内提醒要做的事:把最近的交付物、待确认的事项和已有的安排放进一条消息,让相关的人不用翻历史就能回答"现在做到哪了、下一步谁来接"。 它 @ 一个默认的接手人,但发在群里,谁都可以接。

                                                                    什么时候说,比说什么更难。 静默本身只触发检查,不直接触发发消息:探测先找出连续几个工作日没有可见推进的需求,再把最后的交付物、最近的真实对话、当前状态和今天的日期一起交给数字员工核对。对方已经约了延期、需求已经结束、近期有人接手了,这些情况它都会选择不说。第一版没有这一步,就是第 3 节开头那次十五分钟撤回。试跑时还出过另一种错,一条提醒把五天前纪要里的"任务仍在运行"写成了当前状态。所以提醒必须带上今天的日期,不能把旧纪要里的进行态原样搬过来。

                                                                    调度规则约束工作时段、范围、冷却期和频次;开不开口、跟谁说、缺什么信息,由数字员工判断。最后发出去的只是一条普通的群消息,大家可以直接用自然语言回。反馈改变的是后续安排:回"过几天再说"或给了排期,就按约定等,到期再看;回"已完结""无需推进",这条等待结束;补充了进展或换了接手人,更新上下文和处理人;仍然没人回,重新检查需求状态,不能就此断定某个人有问题。

                                                                    产品设计示意:反馈改变下一次跟进;虚线回到最新情况核对,不表示自动重发。

                                                                    ▐5.3 日报:让等待先被看见

                                                                    日报按个人聚合多条需求的进展与等待。 每个工作日固定时刻,每个人收到一份按需求组织的日报,不是群列表,也不是待办清单,组织单位是需求。它分三层。第一层「需要你介入」:读的就是等待项里等你的那些,最多五条,每条必须同时满足新鲜(一天之内)和核验(读过后续上下文,确认这件事确实还没被别人推进):"你没回"不等于"还等你",别人接手了、聊过去了、已经推进了,规则测不出来,必须让模型读后续对话;无法核验的事项宁可不列,也不放入一条已经过时的事。

                                                                    第二层「活跃需求进展」:每条活跃需求三行:本期完成了什么、到什么阶段、还差什么,未关闭的等待项在等谁直接列在"还差"里。第三层一句汇总:几个在推进、几个新近停滞、其余无事;没有列出的,就是当前无需处理的。有连续性时多一行回环:"昨天说还差的权限,今天解了。"

                                                                    日报先让人扫过多条需求,再围绕关心的那一条继续追问。以下以订单查询工具的取件码字体调整为例:UAT 已完成,但代码提交、主预发部署和后续验证仍待推进。日报把下一步放到具体需求下面,追问时沿用同一份上下文:

                                                                    场景化重排:左侧依据真实日报精简进展与下一步,右侧为按编号追问的能力示意,并非原始对话;需求名泛化,人员身份已打码。不表示问题已解决,也不展示全部日报筛选规则。

                                                                    日报提供个人视野,不据此自动启动催办。某个具体问题是否需要私聊、某条需求是否需要群内提醒,仍分别核对事项与最新安排。免打扰和退订是一等公民,不希望接收的人不会收到任何推送。

                                                                    ▐5.4 效果怎么看

                                                                    效果评估先从交接记录判断是否发生了有效推进,再判断是否由提醒带来。 私聊、群内回应和后续交付会更新这些记录;回执、责任交接和新的排期要与材料补齐、必要决策、验收结论分开记录,不能把所有回复都算作收益。

                                                                    即使出现了有效推进,也可能只是排期到了、群外工作完成了。提醒是否提前了接手,还需要同期未提醒的需求作对照。

                                                                    历史记录中,261 段过滤后静默有 53% 持续两三天、32% 持续四到七天;其中被标为“等人回应”的记录,64% 后来自行恢复活动。在已恢复的记录中,恢复时长中位数为 3 天,四分之三在 5 天内。这些记录提供了等待时长的参照,不能替代同期未提醒的对照组。

                                                                    左:261 段静默的时长分布,已剔除按静默超十天推断为弃用的记录;右:仅统计其中被标为“等人回应”的记录。分类未经人工抽检,恢复活动不等于需求完成;历史比例不是提醒的因果效果

                                                                    当前已经形成等待项的判定、触发与收口机制,但还没有证据说明它缩短了多少交付周期。 后续将通过同期对照,检查提醒是否促成更早的材料补齐、决策或验收,同时记录误报、重复提醒与退订,判断收益是否值得新增的打扰。

                                                                    AI 的产出,怎样成为团队的交付

                                                                    回到开头的落差:编码层的人工介入压到每个需求半轮,周期却只快了一成六。省下的时间没有变成周期,是留在了轮之间,产物已经交付,接手还没有发生。 本文走的就是这一半:把等待还原成可核对的交接缺口,再用卡点推进、群内提醒和日报,把它送到该接手的人眼前。

                                                                    Harness 工程在改变交接的另一半。产物有统一契约,质量门禁能自动校验,授权范围内的下一步就有机会直接执行。但"测试通过"与"今天发布"仍是不同的判断。Harness 让产物可靠、可自动接续;协作机制让产物及时进入验收、决策与后续执行。 两者共同减少交付中的断点,业务时机与风险取舍仍由人决定。

                                                                    回头看,三个产品依赖的是同一份东西:每条需求此刻停在哪、缺什么、谁来接、有过什么约定。维护这份记录、按它推进,原本是项目经理的工作;现在它从执行里长出来:提交、部署、测试的回执是系统给的,进展、障碍和新约定是从对话里读出来的,人不再填账。这就是 AI Native 项目管理的起点:从工作现场取得事实,把有依据的判断送回工作现场。 系统回执与对话陈述要区分来源,每个判断都要能追溯到证据。

                                                                    演进方向示意:依据项目管理分层设计重绘,保留事实采集、跨时间研判和行动回流的关系,不表示全部能力已实现;业务验收、关键取舍与执行授权仍需相应责任人确认。

                                                                    再往前一步是跨时间的研判:报告何时交付、哪个条件尚未满足、谁已经接手、排期为什么改变,放在同一条时间线上,对照该业务的历史节奏找异常;管理系统要保留团队作出安排的理由,才能区分正常等待与需要介入的偏离。研判的结果回到协作:缺权限就把依据交给能处理的人,有发布约定就按约定核对,团队给出新结论就更新同一条记录。这是演进方向,跨时间研判与自动接续尚未全部实现,实际周期收益仍待验证。

                                                                    对准备落地的团队,可以从一条需求试起:把执行回执、人的约定和后续结果串起来,检查每个状态有没有依据、每次跟进是否尊重最新安排;再扩展到跨需求的风险识别与协作调度。

                                                                    需求的周期由每一轮 AI 做的时间和人回来的时间构成。执行提速之后,剩下的时间在轮之间。局部提速要成为团队的交付能力,需要执行与协作一起改变——让需求不停在任何一个人手里。

                                                                    团队介绍

                                                                    本文作者珈文,来自淘天集团-天猫品牌行业前端团队。我们团队负责消费电子、3C数码、运动、家装、汽车、奢品、服务等多个行业的项目。我们定位自身不局限于“传统”的前端团队,在AI、3D、工程化、中后台等领域,我们有着持续的探索和实践。

                                                                    跳转微信打开

                                                                    •  

                                                                    天猫数字员工(实践篇)- 接管全链路:交付能力与技术拆解

                                                                    原创 天猫技术团队 2026-10-23 12:37 浙江

                                                                    让AI驻群接力交付,重塑研发协作。

                                                                    图片

                                                                    本文介绍了天猫技术统一建设的 AI 端到端交付架构“数字员工”。它以群聊为统一入口,与产品、前端、后端及测试等角色共享需求上下文,实现从 PRD 到发布的全链路接力交付。系统底层采用主子 Agent 结构,结合确定性流程与动态规划,通过独立沙箱隔离运行环境,并建立严格的身份权限委托机制确保安全可控。目前该架构已在所有业务线推广,月均活跃交付超百条。其核心价值不仅在于提升编码速度,更在于将散落的业务认知沉淀为可复用资产,推动研发组织向 AI Native 演进。

                                                                    图片

                                                                    前言

                                                                    天猫技术正在建设统一的 AI 端到端交付架构:数字员工提供统一入口与运行时,驻进需求群承接交付;各业务域按需装配并持续沉淀自己的知识、技能与子 Agent。它与产品、前端、后端、测试共享上下文,接需求、写方案、调度 Agent、跟进交付,像一位全程在场的同事。目前已经在天猫技术的所有业务线进行落地推广,月均活跃需求交付100+。

                                                                    区别于一般 AI 编码工具的两个核心视角——协作:与所有角色共享同一份上下文,让协作重新连起来,而不是被 AI 切碎;资产:把散在人脑与聊天记录里的业务认知,从组织维度沉淀成可复用的资产,越用越厚。

                                                                    本文为此系列第二篇内容。

                                                                    数字员工以钉钉为协作入口。每条需求对应一个场景群,产品、设计、开发、测试与它共享同一份需求上下文;从 PRD、设计稿和技术方案,到编码、测试、发布与复盘,产物都回到群里。团队不用更换协作工具,@ 它即可发起任务,私聊也能使用同一套能力。下图从一个入口和四个协作切面,快速展示它如何围绕同一份需求上下文参与理解与推进、方案判断、执行交付与状态学习;这些动作按事件触发,可以回退,也会反复发生:

                                                                    同一个对话入口,共享一份需求上下文;理解推进、方案判断、执行交付、状态学习四个切面按需进入,不是一条固定流水线

                                                                    上一篇讨论了一个现实:编码越来越快,并不必然缩短需求从提出到上线的周期。交付中的等待、澄清、对齐和知识寻找仍然存在。数字员工因此同时处理两件事:在协作侧让所有角色共享同一份需求上下文,在资产侧把交付过程中形成的业务认知沉淀下来。本文不再重复论证问题,而是展开这套产品形态如何落地、系统如何实现,以及我们怎样度量它的效果。

                                                                    数字员工协作形态

                                                                    先回答两个定位问题:为什么造的是"一个"数字员工,以及这"一个"以什么形态嵌进团队协作。

                                                                    ▐  2.1 嵌进团队,而不是配给个人

                                                                    AI 编码工具已经显著改善个体执行效率,但组织交付仍常卡在键盘之外:需求讨论没有及时收口,方案评审依赖多人同步,联调等待接口与确认,业务规则又在讨论结束后回到少数人的记忆里。上一篇把这些问题称为研发协作的“暗物质”。

                                                                    产品形态需要回答一个更具体的问题:在多角色共同交付一条需求时,AI 应该处于什么位置?

                                                                    稳定、可枚举的交付环节适合工作流编排:阶段、输入输出与门禁都明确,便于控制和审计。研发需求同时又有很强的差异性——有的只做评估,有的修改配置,有的需要跨仓编码,难以全部固化成同一条流程。因此我们的选择不是工作流与 Agent 二选一,而是确定性流程与动态规划并用:主 Agent 判断意图和任务形态,按需调用子 Agent、Skill 或工具;进入评审、测试、发布等稳定环节后,再由明确的流程和门禁约束执行。两类方式的适用边界如下:

                                                                    左:确定性流程适合阶段明确、需要审计的环节;、右:动态规划适合需求类型不固定的入口。系统在不同环节组合使用两种方式

                                                                    解决了任务怎么执行,还要决定 Agent 与团队如何组织。

                                                                    一种常见做法是按岗位或任务拆出一组 Agent:数字产品、数字前端、数字后端、数字测试,复杂需求再由编排器调度多个 Coding Agent 并行执行。这种结构可以提高单个任务内部的专业化和并行度。但如果每个角色各自拥有一套 Agent,需求上下文仍会在角色交接时被切断:产品侧澄清得到的信息,不会自然进入技术侧的执行上下文;任务完成得更快,需求收口、跨角色对齐和组织知识沉淀仍需额外解决。两种产品形态的差异如下:

                                                                    左:每人指挥自己的 Agent 队伍——数字 PM、多 Agent 编队、数字岗位小队,队伍再大,上下文仍锁在各自窗口里、互不知晓;

                                                                    右:需求群里多一位数字员工——收口、对齐、编码都发生在所有人眼前,上下文沉在群里只有一份

                                                                    我们的产品选择是让团队在协作现场共享同一个数字员工身份和同一份需求上下文。这里的“一个”不是限制系统只能调用一个 Agent:背后仍可按任务调用需求分析、编码、测试等不同职责的子 Agent;它强调的是面对团队时只有一个稳定入口,需求收口、术语对齐、执行进展和最终产物都回到同一个现场。

                                                                    在实现上,私聊按员工身份进入个人沙箱,场景群按群身份进入独立的群沙箱。群里的所有成员看到同一个数字员工,讨论和交付共享一份上下文;不同群之间则保持隔离。需求进入后,它可以理解 PRD、定位代码、执行改动、完成验证并部署到预发,最后把验收入口送回群里。我们用自主交付率衡量这一过程:需求能够在既定流程与门禁内连续推进,没有因为流程中断、执行错误或结果不符合预期而需要人工纠正、驳回或重新启动,才算一次自主交付。方案判断、权限授权、评审确认和最终验收属于计划内的人类节点,不视为流程中断。

                                                                    电商中后台对稳定性、资损和合规都有明确要求,自主交付必须通过与人工研发一致的生产门禁。因此本文后半部分重点讨论流程约束、验证、身份权限与归因,而不是代码生成本身。

                                                                    ▐2.2 先是同事,再是工具

                                                                    落到日常,这个产品形态表现为一位嵌进团队的协作者。这里仅用四个动作快速交代它如何参与协作,完整讨论见上一篇《研发的暗物质》:

                                                                    • 驻群听全场:它与所有角色共享需求上下文。群里追问业务规则时,回答同时带回出处,不需要重新复述背景。

                                                                    • 异步卡片参与:人不盯群、不蹲会。需求通知、进度播报、异常预警、验收协作都以卡片送到人面前,要深度交互点"查看详情"进工作台——群是协作现场,详情页是个人工作台。

                                                                    • 卡点主动触达:部署完成后主动 @ 验收人并附上预发地址和改动说明;审批超时则按规则催办,不再依赖人持续盯进度。

                                                                    • 跨角色对齐:前端叫 cursor、后端叫 nextToken 的同一个分页游标,这类"传歪"在需求收口时就被对齐、记进词条,不用等到联调才爆雷。

                                                                    这些能力依赖的不只是模型,也依赖它在协作现场中的位置:常驻群聊、持续持有需求上下文,并能把讨论、任务和交付物关联起来。

                                                                    这套协作形态如何从“人找它”发展到“它找人”,上一篇已经展开。本文继续回答三个问题:它交付什么、系统怎么实现、业务如何接入。

                                                                    全链路交付能力

                                                                    这一章按三个尺度说明数字员工的交付范围:一条需求之内,多个角色如何共享上下文并完成接力;一组场景之内,能力如何按业务域配置;一个业务之上,多条并行需求如何统一管理。

                                                                    下图包含四条真实需求的五段交付记录:从截图中提取需求、根据评审意见把方案迭代到 v4、同时处理三个仓库、定位“模板无法下载”的根因,以及发布完成后汇总访问地址。它们对应不同角色和不同交付阶段,人主要在确认与验收节点参与:

                                                                    五段真实交付记录,来自四条不同需求、五类不同的活——内容未改动、人名已脱敏(点开看大图)

                                                                    ▐3.1 一条需求之内:跨角色接力

                                                                    一条需求要动用四种角色:产品、前端、后端、测试。先后与门禁由业务域按实际交付流程定义;这里先看职能:每个角色的活它都接得住,而每个角色和它的输入输出都很直接——

                                                                    • 产品:丢进来一句话需求、群里的讨论与评审意见;拿回结构化 PRD 和待澄清清单。PRD 被指出"只写接口、没写业务逻辑",它按业务逻辑分域重写一版——接受批评、按反馈返工。

                                                                    • 前端:给交互确认与联调信息;拿回页面改动、构建部署与 Diff 预览。

                                                                    • 后端:给接口口径与方案评审结论;拿回技术方案、服务改动与预发部署。

                                                                    • 测试:给验收判定与缺陷反馈;拿回测试用例与自测结果——质量门禁(静态检查 → 构建 → 自动测试)加 Harness 浏览器验证贯穿全程,写完自己验;用例带着需求澄清的全部上下文,知道这条需求"为什么这么改"。

                                                                    编码执行不重造轮子:沙箱里 Claude Code、Codex CLI、通义灵码按需选,数字员工管的是把上下文喂进去、把进度收回来。角色之间的协同,一张图说清:

                                                                    四个角色共享同一个需求会话,数字员工负责衔接各阶段;

                                                                    会话关联同一业务域资产空间,统一消费并沉淀业务知识、技术知识、记忆与产物

                                                                    再看同一条需求的完整过程。手猫「问底价」功能的一次迭代,从需求描述、元信息录入和代码级澄清,到方案评审、测试用例与预发部署,由同一个数字员工在两天内连续处理,人主要在确认和验收节点出现:

                                                                    同一条真实需求的四段切片:需求启动 → 方案确认 → 测试用例 → 部署验证,取自同一个需求群的两天记录

                                                                    编码能力可以复用现有工具,数字员工新增的价值主要发生在角色之间:需求对齐、产物衔接、过程验证和进度协调都在同一个现场完成。交付物向前流转时,上下文也随需求保留下来,人可以把注意力集中在方案判断、风险确认和最终验收上。

                                                                    一条链走得通,靠的是每一环都吃到对的知识——而物流域和供销域吃的根本不是同一套东西。链路是通用的,知识是业务的:能力怎么跟着域走?

                                                                    ▐3.2 一组场景之内:开箱即用,按域定制

                                                                    一个业务域里的场景五花八门,粗看两类:一类不成流程——找人、答疑、读文档、查数据、拉群建单,零散、随时发生;一类是标准流程——技术方案、编码、部署、迭代创建到发布,讲先后、有门禁。数字员工用一套灵活的主子结构把两类都接住:主 Agent 接非流程化的协作面,流程化的交付交给子 Agent。

                                                                    这套结构提供一条可直接运行的默认路径。主 Agent 预置需求单对接、钉钉文档与多维表读写、数据库操作、数据表理解、迭代创建和发布单创建等通用能力;默认编码子 Agent 则覆盖需求分析、方案设计、编码、测试和发布,各阶段都有明确入口、产物与评审点。新业务域不做定制也能先运行,再根据实际需求逐步扩展。

                                                                    开箱之上是深度定制,定义权归业务。交付流程以 Skill 装载:分几个阶段、每段产出什么、哪里设置评审门禁,都由业务团队定义。数字员工按配置执行,被指出遗漏步骤后也能回溯原因、补齐产物。在一类接口已经具备、以组装为主的小需求中,手猫团队把九阶段交付流程装载后,曾将需求到方案的时间压缩到十几分钟,确认后继续进入编码与部署。装载入口是业务域后台的一页配置:

                                                                    调度说明是主 Agent 的派发依据,子 Agent 清单按域生成;关联的 Skills 在派发那一刻投影给执行器(真实页面,已脱敏)

                                                                    能力按业务域配置:不同业务可以设置 Skills、Hooks、System Prompt,并关联本域知识库,让同一个数字员工在不同业务域获得相应的知识和执行能力:

                                                                    主 Agent 与每个子 Agent 独立定制,变更自动保存,数字员工运行时在分钟级加载;知识库按域关联(真实配置页,MCP 加装同属此组页签)

                                                                    自有 Agent 通过标准协议接入,业务能力在调度时按域投影;知识与资产如何生产、治理并持续变厚,是资产篇的正题。单条交付得好、每个域都接得住,需求自然就多起来——几十条并行时,考验的不再是交付本身,而是管理:谁在推进、卡在哪、产物在哪。

                                                                    ▐3.3 一个业务之上:看板与主动推进

                                                                    需求进入场景群后,数字员工同步维护需求看板:自动记录项目成员、里程碑、卡点和产物,并根据群内讨论与交付进展更新状态。群内通过吊顶卡查看当前需求,跨需求则使用 Web 大盘;每条需求对应一张卡,并与研发工单系统保持状态同步。这里同步的是工单状态,任务仍由用户在钉钉对话中发起。群内与跨需求的两种视图如下:

                                                                    左:群内吊顶看板——成员、里程碑、卡点,随讨论与交付自动更新;

                                                                    右:Web 需求大盘——四列状态流转,每条需求一张卡(真实系统页面,已脱敏)

                                                                    看板把等待状态显式记录下来。数字员工将进展同步到群与看板,在需要确认或验收时 @ 对应负责人,超时后按规则催办,并每天生成一份需求摘要,说明当前状态、下一步动作和仍待处理的事项。

                                                                    日报同时展示趋势变化、卡点负责人和停留时长。群成员可以直接回复“第 2 条展开说说”,继续查看对应需求的细节:

                                                                    日报以群成员身份发在会话里——有头像、在对话流里、可追问,回一句「第 2 条展开说说」就展开;左右为同一份日报的两段截取,中间标注读法(真实群聊消息,内容未改动、人名已脱敏)

                                                                    看板、催办和日报解决的是进展可见与待办推进;主动发现问题、主动发起协作等更进一步的能力,将在系列自主篇中展开。系统是否稳定、交付能走到多深,则需要回到运行数据判断。

                                                                    系统拆解:消息、沙箱、Agent 与身份

                                                                    理念落到工程上,依托的是一套数字员工系统。这一章沿着一条消息的旅程拆解四个问题:消息如何进入并找到对应沙箱,沙箱如何创建并保存状态,主子 Agent 如何分工,系统访问外部资源时使用谁的身份。核心调用链如下:

                                                                    钉钉消息 → 消息网关 → 按路由身份转发到专属沙箱 → 主 Agent 判断意图 → 调度子 Agent 或直接回答 → 钉钉 AI Card 实时反馈

                                                                    从触点到存储的完整结构如下:

                                                                    钉钉与 Web 两个触点收敛到同一个网关和沙箱;

                                                                    业务数据统一经数据服务落库,模型调用从网关统一出口

                                                                    ▐4.1 钉钉接入与消息路由:从群到沙箱

                                                                    先看消息怎么进来。接入使用钉钉官方 Stream 模式:网关主动建立长连接,事件沿连接推送下来,不需要暴露公网回调地址。实践中仅检查连接状态不够,我们同时监控“最后一次收到事件的时间”,用于识别连接仍在、事件却不再到达的异常状态。

                                                                    连接上下来三类事件:私聊、卡片回调、群消息。场景群即开头的需求群:建群后,数字员工发送第一条消息,此后群内消息全量进网关——@ 到的进应答,没 @ 的进旁听。

                                                                    这里遇到过一个实际问题:如何稳定判断消息是否 @ 了数字员工。平台在不同接收关系下回传的身份标识并不适合只做一份静态配置。网关因此维护机器人标识集合:已确认的标识直接匹配,尚未覆盖时使用文本规则兜底,并在运行中补全集合。

                                                                    路由规则是:一个路由身份对应一个沙箱。私聊按发送人身份路由;场景群按群会话 ID 派生群身份,做到一群一箱。群沙箱与个人沙箱保持隔离,避免不同会话的回复通道相互影响。多实例同时收到同一事件时,转发前先做原子认领,只有一个实例继续处理。

                                                                    这条通道从头到尾画出来是这样:

                                                                    从 Stream 长连接到专属沙箱:多机原子认领去重、@ 判定集合自学习、路由身份两形态

                                                                    在会话链路上,网关被刻意做“薄”:不调用 LLM,也不做业务判断,只承担三类确定性工作:

                                                                    • 接得住:消息到达后立即回执,并通过原子认领避免重复处理。

                                                                    • 留得下:图片和文件在下载凭证有效期内先行转存。

                                                                    • 送得准:识别路由身份、选择沙箱,再组装成运行时统一格式。

                                                                    业务调度为什么必须经过数字员工,而不是让网关顺手处理?三个场景可以直接说明:

                                                                    场景

                                                                    如果绕开数字员工

                                                                    经过数字员工

                                                                    用户在群里发起需求分析

                                                                    网关按关键词直接启动分析 Agent → 分析完成后缺少统一状态与反馈主体

                                                                    数字员工理解意图 → 启动分析 → 统一管理状态和交互

                                                                    分析完用户点“开始编码”

                                                                    网关解析卡片回调 → 还得知道分析结果是什么

                                                                    分析结果就在数字员工手里 → 直接传给编码 Agent

                                                                    编码中用户发了条无关消息

                                                                    网关无法判断该转发还是忽略

                                                                    数字员工推理判断 → 自己回答或转发给 Agent

                                                                    如果管道层同时承担业务判断,状态会分散在网关和数字员工两侧,后续交互很难保持一致。因此网关只负责传输与路由,业务决策统一收口到主 Agent。

                                                                    返回结果时,网关采用“先建卡、再覆盖”:先创建占位卡并取得轨道号,随后持续向同一张卡更新内容。即使遇到冷启动,用户也能先看到任务已经受理,不会出现长时间无反馈或连续刷出多张卡片。

                                                                    每轮消息在入口生成链路标识,覆盖选箱、投递、回调和发卡;看板既能查看整体情况,也能下钻到单轮消息。这里主要看三个结果:

                                                                    • 热路径首响:平均约一秒,P90 在三秒以内。

                                                                    • 冷启动首响:P90 约六秒。

                                                                    • 首响成功率:超过 99%。

                                                                    以上为截至 7 月底的内部运行数据,“首响”统一定义为第一张卡片成功推送。

                                                                    当前系统只保留对话驱动这一种发起方式。用户在钉钉群或私聊中发送“帮我分析这个需求”“帮我优化 utils.ts”等指令,数字员工先结合当前会话与项目列表匹配仓库;无法唯一匹配时,列出候选项目请用户确认,再派发需求分析或编码 Agent。执行过程中,Agent 持续输出流式事件,数字员工一边节流更新 AI Card,一边推送实时事件供详情页订阅。

                                                                    ▐4.2 一需求一沙箱:容器、初始化与记忆

                                                                    消息路由的终点是沙箱:一条需求对应一个场景群,一个场景群对应一个独立沙箱,私聊则使用个人沙箱。不同协作现场彼此隔离,一条需求中的代码、依赖和调试状态不会影响其他需求。

                                                                    镜像只包含基础运行环境,运行时代码不进入镜像,而是在启动时从发布服务拉取。这样发版不需要重新构建镜像,在线沙箱可以分批升级:守护脚本拉取新版本、切换软链,并在空闲时重启运行时。

                                                                    创建时,网关注入身份、凭证与业务域配置;多个仓库按需求并行克隆,并根据仓库特征识别技术栈。冷启动从两侧优化:一侧维护已就绪的预热池,首条消息到达时完成一次性认领,绑定完成前不接收业务消息;另一侧把需要保留的状态放到容器外部,避免沙箱重建时丢失。

                                                                    从创建到就绪、再到群里第一句问候,整条流水线:

                                                                    创建、注入、拉运行时、备仓、就绪——就绪那一刻,群里冒出它的第一句问候(真实截图,已脱敏);预热池沙箱经一次性认领上岗,升级走同一条 CDN 通道

                                                                    运行中,每次转发消息都会刷新沙箱有效期,避免活跃实例被平台回收;转发失败时先查询容器真实状态,再分别执行重建、唤醒或等待启动。

                                                                    状态设计只做一道取舍:必须记住的留下,可以重建的不留。

                                                                    类型

                                                                    内容

                                                                    处理方式

                                                                    必须保留

                                                                    会话、记忆、任务状态

                                                                    存入独立持久卷,容器重建后重新挂载

                                                                    可以重建

                                                                    仓库代码、临时执行上下文

                                                                    不进入持久卷,使用时重新生成

                                                                    这样既能保持连续会话,也允许工作容器随时替换。/reset 只重置当前运行状态,不直接删除持久数据,误操作后仍有恢复空间。

                                                                    这套 Session 设计还支持跨端:Web 工作台不另建会话,而是复用实例关联的 Session——拉取快照回放历史、订阅事件流接续实时进度,发出的消息与钉钉合流到同一个沙箱。聊到一半的需求切换到 Web 后可以继续处理,中间不断档:

                                                                    两幕是同一个群、同一条讨论线——钉钉聊到一半,Web 工作台打开接着干;

                                                                    下:两条通道进的是同一个沙箱、同一份会话状态(真实页面,已脱敏)

                                                                    ▐4.3 Agent 层开放:调度可控,执行可插拔

                                                                    消息进入沙箱后,由一主多子的 Agent 结构完成处理。主 Agent 是数字员工本体,也是自研 Agent 框架中的常驻 Thread;子 Agent 负责需求分析、编码和测试,由主 Agent 按需派发。背后的设计判断是:通用性归执行端,可控性归调度端,两层职责分开。

                                                                    为什么没有直接把通用编码 Agent 作为常驻协作中枢?两者解决的问题不同:编码 Agent 擅长在仓库中完成明确任务,而数字员工中枢还要管理消息路由、结构化交互、多会话状态和跨角色协作。以“直接作为中枢、不增加外部编排层”为比较范围,差异如下:

                                                                    数字员工要做的事

                                                                    自研主 Agent

                                                                    通用编码 Agent 直接作为中枢

                                                                    发送钉钉 AI Card

                                                                    原生工具与状态机直接控制

                                                                    需要额外适配层

                                                                    调度编码 Agent

                                                                    明确控制启动时机、上下文和回收状态

                                                                    需要在外部补充调度协议

                                                                    特定时机发送特定卡片

                                                                    由业务状态驱动结构化交互

                                                                    需要在外部映射运行事件与卡片状态

                                                                    管理多会话状态

                                                                    按群、用户和需求显式管理

                                                                    需要额外建立组织会话与编码会话的映射

                                                                    确定性消息直转

                                                                    代码路由,不调用 LLM

                                                                    需要外部网关提供短路能力

                                                                    主 Agent 的目标是让行为可控:发送消息、更新卡片、派发任务等外部动作都通过显式工具完成。但它也不能退化成规则引擎——“改完了吗”“先别管这个,帮我看看线上报错”这类消息仍需要结合上下文判断。子 Agent 清单按业务域动态生成,并在轮次边界加载新配置,不需要重建 Thread。

                                                                    子 Agent 层保持可插拔:同一个逻辑 Agent 可以使用自研执行器或 Claude Code 等后端,由业务域选择。工程约束有三条:同一会话中途不切换引擎;不同后端的流式事件统一映射;所有模型请求必须经过统一网关,未配置网关时拒绝启动。

                                                                    主 Agent 将业务域配置传给子 Agent,这一步称为能力投影,分成三个动作:

                                                                    1. 派发时装载:Skills、MCP 和 Hooks 转换为执行器的原生格式。

                                                                    2. 执行中追问:子 Agent 缺少信息时,通过桥接通道回到群里提问。

                                                                    3. 完成后收口:执行事件回到主 Thread,由主 Agent 统一更新状态并反馈结果。

                                                                    三种动作及默认、自有子 Agent 的注册关系如下:

                                                                    派发、追问、结果回传都走注册协议;默认子 Agent 初始化即有、可定制,业务自有的实现 run/resume 即注册——载体可插拔,规范统一

                                                                    下图展示一次真实的主子 Agent 对话。右栏顶部将用户原话标记为“仅作任务背景”,主 Agent 随后给出的提问才是子 Agent 当轮需要执行的指令:

                                                                    左:群里被问"为什么没走工作流",主 Agent 转发提问并转述回答;

                                                                    右:编码子 Agent 会话原文——它自陈"是我自己的判断",并承认对较大变更该走正式流程

                                                                    (真实页面,工号已脱敏)

                                                                    主子消息分流来自试点中的真实反馈。早期有用户反馈:“部署时轮询进度会占用会话,我新发的消息只能排队。”改造后,消息先经过一道不调用 LLM 的确定性路由:子 Agent 正在等待回复时直接转发;其余消息才进入推理路径,由主 Agent 决定回答、转发还是新建任务。改造后的两条路由如下:

                                                                    子 Agent 在等待回复时,消息去向是确定的,可以直接转发;只有存在歧义的消息才进入推理路径

                                                                    例如需求分析 Agent 问“登录页要支持哪几种登录方式”,用户回答“手机号验证码和钉钉扫码”,这条消息的去向已经确定,没有必要再次调用模型判断。在 Agent 系统的成本结构中,识别哪些环节不需要调用 LLM,与提升模型调用效果同样重要。

                                                                    用户侧只需要理解两层信息:群里的卡片展示阶段、状态和当前执行者;详情页持续显示执行过程。只关心结果时看卡片,需要排查过程时再进入详情页。

                                                                    任务进入沙箱前先定位仓库和分支,再按复杂度选择执行方式:

                                                                    复杂度

                                                                    执行方式

                                                                    简单

                                                                    轻量执行,完成后直接验证

                                                                    中等

                                                                    单 Agent 执行并自检

                                                                    复杂

                                                                    仍由单个编码 Agent 分阶段执行,增加方案确认、自检和发布门禁;执行过程持续回传状态,异常时由人纠偏或重启流程

                                                                    可控也不等于把行为写成固定剧本。主 Agent 可以在授权能力范围内调整执行方式:例如子 Agent 长时间没有进展时,重新规划任务,改用自己已有的工具继续处理;但后续验证、权限与发布门禁保持不变。推理负责应对变化,工程约束负责守住边界。

                                                                    这一层也向业务开放:不修改平台代码,即可在业务域后台扩展主 Agent 以及需求分析、编码、测试三个默认子 Agent,配置 System Prompt、Skills、MCP 和 Hooks。已有自研 Agent 的团队,只需实现运行与续跑协议,就能把自己的引擎注册为子 Agent。群里仍由同一个数字员工应答,背后的执行器可以替换;平台保留默认需求分析与交付 Agent,确保新业务域具备可运行的基线。执行器变化也不会改变身份边界,数据权限仍跟随当轮用户。

                                                                    ▐4.4 身份与权限:谁干活算谁的,谁消费算谁的

                                                                    同一个群里,不同人会让数字员工读取文档、提交代码、执行部署或查询受控资源。如果所有动作都使用同一套身份,要么权限不足,要么权限被无意放大。我们按动作拆分身份,原则是:谁消费数据,使用谁的权限;谁产生结果,记录谁的归属。

                                                                    动作

                                                                    实际使用的身份

                                                                    边界

                                                                    读写钉钉文档、多维表

                                                                    当轮发送人

                                                                    只能访问这个人原本有权访问的数据

                                                                    构建、部署、平台登录

                                                                    数字员工服务身份

                                                                    不借用个人账号,平台动作可独立审计

                                                                    提交代码

                                                                    当轮发送人署名

                                                                    产出归属于实际指挥者,个人凭据不落盘

                                                                    查询中间件、监控、数据平台

                                                                    群内负责人通过身份委托服务授权的身份

                                                                    资源端仍按负责人的原有权限判断,不额外扩权

                                                                    这里最重要的不是身份有几类,而是模型不能指定任意一个人。身份化调用只接受“当轮发送人”“数字员工服务身份”“已确认的群负责人”等受控角色,角色到真实身份的映射由可信环境注入。即使模型生成“以某某身份查询”,控制层也不会接受。

                                                                    受控资源再多一步显式授权。群里指定技术负责人后,只有本人登录确认,身份委托服务中的授权才生效;请求同时记录委托用户、执行 Agent 和来源沙箱。授权系统只证明“谁委托了谁”,不会扩大这个人原有的资源权限。凭证加密保存、按需续签,文档、代码和平台身份也不会因为这次委托自动同步或放大。

                                                                    这条委托链路的完整时序:

                                                                    群里一句话发起,只有负责人本人登录确认才生效;身份材料经控制面注入沙箱,资源端仍按本人原有权限判

                                                                    这套委托有一条约束:一个沙箱生命周期内,“用户 + Agent”的身份组合保持不变。更换负责人时不直接修改现有沙箱,而是销毁旧沙箱、冷启动新沙箱,并禁止从旧快照恢复,使上一身份关联的缓存和凭证不进入新环境。整套绑定在系统中实现为一台状态机:

                                                                    从提案到激活、分离、重授权、吊销的完整流转——绑定的用户、Agent、沙箱三者一致才算就绪;授权可撤、可续、可追溯

                                                                    消息入口、运行环境、Agent 调度、业务扩展与身份权限共同形成完整链路。它是否稳定、交付过程中人仍在哪些环节介入,需要由运行数据回答。

                                                                    效能度量与落地数据

                                                                    系统上线之后,效果不能只靠“感觉变快了”判断。我们先定义度量口径,再用运行数据观察它承接到什么深度,以及人的介入发生在哪里。

                                                                    ▐5.1 效能度量:刻度与归因方法

                                                                    数字员工的观测体系分为两类:稳定体验关注服务质量与用户留存,交付效能关注 AI 承接深度、产出效率和投入成本。同一套数据按使用者划分视图:平台侧查看全局,业务域只查看本域。效能侧重点观察两个信号:自主交付率与人工介入次数,矩阵与账本都围绕它们展开:

                                                                    上:稳定体验(服务质量/用户留存);下:交付效能(自主性/产出效率/投入成本)。

                                                                    统计时剔除开发者试用数据,业务域只查看本域,所有视图用于定位改进方向

                                                                    在当前 AI Coding 推进中,代码采纳率、使用覆盖率等传统指标已经处于较高水平,继续上涨也很难说明 AI 在真实业务需求中究竟承接到了哪一步。它们可以回答“有没有使用”,却不能区分一次提示词生成、一次研发闭环和一条需求的完整交付。单纯按耗时统计也容易失真:开发任务常与其他工作并行,等待和阻塞又可能发生在研发链路之外。

                                                                    因此我们使用两把尺子。需求分层 C1-C4 描述复杂度,按核心中台影响、产品形态、跨团队范围等七个维度综合判定,并采用就高原则。AI 交付深度 L1-L4 描述承接范围,从提示词驱动、研发闭环、测试闭环到全流程交付。

                                                                    在 C × L 坐标之外,我们增加一个并列的参考信号:人工介入次数——首轮任务发起之后,人继续补充、澄清、追问或纠偏的轮次。它按协作层(主 Agent 群内的讨论、澄清、评审)与交付层(进入编码子 Agent 会话后的补充与纠偏)分账,用来解释同一复杂度、同一交付深度下,人的参与主要发生在哪里。

                                                                    这项数据只用于观测和归因,也不追求越低越好。必要的追问、判断和评审本来就是交付的一部分;如果把轮次本身当成目标,延后反馈或合并消息就能让数字变得好看,却不会让交付更顺畅。它与自主交付率也不是同一个口径:计划内的判断和确认可以被记录为参与轮次,但不会把一次交付判为“非自主”;只有异常纠正、驳回或流程重启才会影响自主交付判定。两套口径的交叉视图如下:

                                                                    上:C1-C4 七维判定表,就高不就低(跨团队面等组织口径已模糊);下:L1-L4 从提示词驱动到全流程交付;交叉即效能画像主视图,每格「需求数+平均介入次数」——定位改进方向的参考

                                                                    ▐5.2 运行大盘:规模、深度与介入位置

                                                                    截至 7 月底,天猫技术下的业务线已全部接入这套流程:需求池百余条,覆盖二十多个业务域;近 30 天新建需求群与活跃会话均超过一百。从需求沟通、方案设计、评审、开发、测试到发布,每个阶段都有正在流转的需求。这组数据说明的是系统已经进入真实业务运行,而不是用规模直接替代效能结论。

                                                                    我们还逐条复核了首批十余个试点需求。这个样本不足以证明整体效率提升,但可以帮助定位人的参与发生在哪里:大部分记录集中在协作层,即群里的讨论、澄清和评审;单条需求通常有十到几十轮。这些轮次包含计划内协作,不等同于流程失败。交付层主要记录进入编码子 Agent 后的补充与纠偏,多数需求为几轮到二十轮,已完成编码的需求平均约七轮,较早稳定运行的业务域已经降到一轮左右。该批样本的全链路参与约三十轮,其中纠错返工约占两成。下一步要优化的重点,已经从“是否能生成代码”转向“能否减少协作中的反复确认与信息补充”。两层账本如下:

                                                                    上:域视角的介入归因看板——交付层与全链路两个刻度,介入轮按协作层/交付层分账;

                                                                    下:需求明细里每条的介入分层(协/交),需求名与人员已脱敏(真实系统页面)

                                                                    账本还可以继续下钻到归因。系统为每轮介入标记催进度、解决卡点、拍板确认、提出需求、纠错返工、补充上下文等类型,并识别上下文缺失、理解偏差两类风险信号。在此基础上生成预授权、Prompt 和 Skill 三类改进建议;建议经人工确认后,再沉淀为业务域资产。介入次数因此不只是一个结果指标,也成为下一轮系统优化的输入:

                                                                    左:单条需求的逐轮介入明细,每轮标协作/交付层;

                                                                    右:归因打标、风险信号与改进建议——采纳后沉淀为域决策资产(真实页面,需求名与真名已脱敏)

                                                                    总结与展望:

                                                                    AI Native 研发组织的新执行单元

                                                                    如果只把数字员工看成群里的编码机器人,前面的消息路由、长期状态、独立沙箱、身份权限和主子 Agent 都显得过重。它们组合在一起,实际上定义了一种新的组织执行单元:它有稳定身份,有持续上下文,有自己的工作环境和权限边界;能够接收需求、调用工具、产出交付物、维护状态,并在需要判断时把人请回流程。

                                                                    这也是我们理解的 AI Native:不是在现有研发流程的每个节点各加一个 AI 功能,而是重新划分人、AI 与系统之间的职责。过去由人搬运上下文、推动状态、在多个系统之间完成衔接;未来由数字员工持续持有上下文,承担确定性执行和过程推进,工单、文档与流水线在后台自动流转。人仍然拥有判断、授权和责任,但不再承担每一次信息搬运与状态轮询。

                                                                    当每条需求都拥有这样一个长期运行的执行单元,研发组织的协作方式会从串行交接转向异步并行:几十条甚至更多需求可以同时推进,人不必逐条追踪 Agent 的工作过程,而是在方案选择、风险确认和例外处理等高价值时刻进入。真正可能带来数量级变化的,不只是某一次编码更快,而是同样的人类注意力可以支撑更多并行交付。

                                                                    今天这套系统还处在这条路线的前段。更容易端到端跑通的,仍是接口和基础能力已经具备、以组装为主的需求;复杂领域改造仍需要人在需求判断、方案选择和风险确认处介入。下一阶段要解决的不是简单增加更多 Agent,而是继续补齐两块基础:一块是业务心智,让规则、口径和判例从人脑、群聊与历史交付中沉淀成可消费的组织资产;另一块是主动协作,让数字员工在授权和克制的边界内发现问题、发起协作并推动闭环。它们也分别是这个系列后两篇要回答的问题。

                                                                    数字员工不会自动修复不清晰的 PRD、依赖默契的分工和缺少沉淀的业务知识。相反,这些问题会在交付过程中更早暴露:输入不足时无法继续,责任不清时无法路由,门禁缺失时无法判断是否可以前进。建设数字员工的过程,也是在把研发体系中依赖人兜底的部分逐项显式化。从“人围着系统跑”到“系统围着人跑”的变化如下:

                                                                    协作载体的迁移——单据自动流转、状态自动回写,协作回到对话现场

                                                                    过去,需求在工单、文档和流水线之间流转,人负责搬运上下文并追踪状态。数字员工把对话重新变成协作入口:需求在群里澄清,方案在群里评审,系统在后台自动完成建单、执行、状态回写和验收衔接。变化并不是去掉原有系统,而是让系统开始围绕真实的协作现场运行。

                                                                    AI Native 的终点,也许不是每个人多用几个 AI 工具,而是组织里多了一类可以被授权、被协作、被审计,也能持续学习业务的数字同事。当它真正成为交付网络中的一个节点,研发效率的上限就不再只取决于一个人能写多快,而取决于整个组织能够同时推进多少事情,并把人类最稀缺的判断力留在最值得出现的地方。

                                                                    团队介绍

                                                                    本文作者珈文,来自淘天集团-天猫品牌行业前端团队。我们团队负责消费电子、3C数码、运动、家装、汽车、奢品、服务等多个行业的项目。我们定位自身不局限于“传统”的前端团队,在AI、3D、工程化、中后台等领域,我们有着持续的探索和实践。

                                                                    跳转微信打开

                                                                    •  
                                                                    ❌