章节总览
历史版本 / 44 · 历史版本
原目录

Auto-Thinking 的早期完整解析,保留当时的章节结构与论述。

多维表格 Code Agent 训练体系与 Auto-Thinking 完整解析

本文档整合了多维表格 Base AI Post Training 团队的 Code Agent 训练方案、Auto-Thinking 完整训练方案的深度解读,以及相关核心概念的系统梳理,并附 Auto-Thinking 原始文档全文。

资料来源:企业内部文档《多维表格 Base AI Post Training 团队核心思路深度解析》(v4/v5/v5.1)、《多维表格 CodeAgent:Auto-Thinking 的 SFT 与 RL 完整训练方案》(王哲,2026.07.30)


目录


第一部分:多维表格 Code Agent 训练体系总览

一、核心架构:CodeAct

Code Agent 采用 CodeAct 范式而非传统 Function Calling:LLM 直接生成 TypeScript 代码,通过 @bitable/agent-sdk 在沙箱中执行。

执行链路

用户需求 → LLM 生成 TS 代码 → 沙箱编译(tsc) → 试运行 → 正式执行 → 返回结果

执行采用 ReAct 模式(最多 20 步),编译失败时模型根据错误信息自动修复,最多重试 8 次。

CodeAct vs Function Calling

维度 Function Calling CodeAct
表达能力 受限于预定义工具 schema 图灵完备,可表达循环、条件、变量等任意逻辑
组合性 多步操作需要多轮对话 一次代码可完成多表创建+字段关联+视图配置
纠错能力 依赖模型理解工具返回值 编译器/运行时提供结构化错误信息,模型可直接修复
扩展性 新操作需新增工具定义 SDK 新增 API 即可,模型自动适配

关键组件

  • LLM:理解意图,生成代码,根据错误修复
  • Base Agent SDK:提供操作多维表格的 TypeScript API
  • 沙箱(Sandbox):隔离的 Node.js 执行环境,支持本地和 VeFaaS 远程两种模式
  • 工具集:write_file / edit_file / read_file / run_file / refuse_request

二、数据合成方案

训练数据主要通过三种方式构建:

1. 多 Agent 协作合成

SFT 训练数据通过多 Agent 协作方式合成,模拟真实用户场景:

User Agent(模拟用户提出需求)
  → Supervisor Agent(拆解需求,生成 spec)
    → Code Agent(基于 spec 生成代码)
      → Judge Agent(评估代码质量)

核心脚本位于 train/scripts/ 下:

  • gen_agent_trajectories.ts:生成轨迹
  • trajectory_builder.ts:构建训练格式
  • trajectory_judge.ts:质量评判
  • synthesize_v2.ts:合成主流程

数据经多层清洗(train/clean/)和质量检查(train/docs/QUALITY_CHECKLIST.md)。

2. 蒸馏数据提取

可从评测产物中提取训练样本,支持多种来源:

来源 说明
from-traces 从 Agent trace JSON 批量抽取
from-eval 从 eval results + traces 目录抽取(含 write_spec 时优先用模型写的 spec)
from-results 从 eval report JSON 抽取(零 trace),可选仅保留编译通过样本
merge-csv 从 lite_doc CSV + trajectories 对齐

输出 JSONL 每行字段:query_id、spec_doc、code、query、spec_source、compile_ok、model、judge_score 等。

3. 数据增强策略

  • 基于母本/种子的 Rewrite:Goal 不变、FinalCode 不变,语义等效改写 Context
  • React 轨迹合成:注入不影响编译运行的瑕疵,生成单 Query 双轮 React 轨迹
  • 编译/运行错误 Fix 训练:针对错误修复的专项数据
  • 多路集成:高阶模型(GPT5.4/GLM)+ 后训练模型 + Query→Spec→Code 路径交叉验证

三、训练方法论体系

1. 直接 SFT(基线方法)

最简单朴素方法,作为训练迭代的基线。

2. 课程训练(当前主力,5 月建立)

核心思想:先易后难,先让模型在容易的评测上拿高指标,再逐步提升难度。

课程阶段 训练样本要求 训练方法
阶段一:编译执行通过率、单测通过率 编译执行必须通过,Judge 可以不过 SFT + RLVR
阶段二:机评 Judge、人评满分率 机评 Judge 必须通过(允许少量不影响核心的瑕疵) SFT/RFT + RL(长度惩罚+Code GT参考+单测+LLM Judge)

关键技巧(5 月验证有效):

  • Q&A 预训练:内化 SDK、Skill、工具调用知识,运行通过率 +13.3%
  • 工具增强 2.0:强化 Agent 持续规范调用工具的能力
  • mask 修复路径:学习编译/执行失败后的修复闭环,运行通过率 +15%
  • 精简 skill/SP:压缩冗余上下文,降低长上下文负担

3. 多阶段混合训练(方法论指导)

借鉴 Cursor、DeepSeek、GLM 等技术报告:

  1. 冷启动(少量优质 SFT 数据)
  2. RL 专项任务训练
  3. 基于训练模型的拒绝采样(关注采样接受率)
  4. 补充通用数据,SFT+RL 混合训练(避免灾难性遗忘)

课程训练和多阶段训练相辅相成。但训练数据的质量始终是最基础最重要的。

4. RL GRPO 训练(当前主力)

采用 **GRPO(Group Relative Policy Optimization)**算法:

  • 每条训练样本产生 8 条并行轨迹,做组内相对排名
  • 三层 Reward 架构:
层级 内容 权重
L1 编译检查(tsc),失败短路返回 0 0.1
L2 真实执行(当前关闭,64% case 不可执行) -
L3 语义评估(vitest 单测 + LLM Judge) 0.9
  • Reward 计算:编译失败=0;编译通过但测试全挂=0.1;编译通过+部分测试通过=0.1~1.0
  • 训练数据 194 条,单测覆盖率 100%,按 W1/W2/W3 权重分配操作类型

5. Auto-Thinking 架构(下一代方案,探索中)

让模型自主决定"何时思考、思考多深",三档模式:

  • DIRECT(85.5%):直接执行,不输出 thinking
  • THINK_SHORT(12%):64~128 token 短思考
  • REPLAN(2.6%):128~192 token 重规划

每个 ReAct turn 引入 Gate token(<|mode_direct|> 等),SFT 分三阶段冷启动 → Gate warm-start → 联合对齐,RL 分 R1(正确性)→ R2(Gate 与修复)→ R3(Pareto 压缩)三阶段。

四、当前训练进展与效果

SFT 进展

  • spec 带 form 数据补充合成(554 条),解决 form 能力边界
  • spec lite 1.0 数据合成(含 Plan→Spec 改写,660 条)
  • mockdata 数据修复
  • 计划合成 300 条 form + 300 条 Building 1.0 能力数据
  • 现有 SFT 数据集回扫(SDK/Plan 对齐)

SFT 性能:

模块 基础版 PE 版
Table 76 82
Dashboard 76 75
Workflow 82 81
Permission 80 75
Form - 79
Spec lite 1.0 60 -

RL 第一版 E2E 评测(5,888 条有效轨迹)

指标 数值
编译通过率 99.47%
执行通过率 86.50%
编译执行 Pass@1 40.61%
平均编译尝试次数 2.10 次
E2E Judge 通过率 24.59%
E2E Judge 均分 7.024 / 10
最终 reward 均分 6.287 / 10
严格 E2E 成功率 21.25%

分模块诊断

模块 执行通过率 E2E Judge 通过率 诊断
Table 85.61% 49.75% 最稳定,无 Judge 调用错误
Dashboard 86.33% 23.60% Judge 均分最高(8.418)但严格通过率不高
Workflow 85.16% 20.99% Reward 均分最低(5.5),Judge 调用错误占 87.25%
Permission 93.43% 4.64% 执行最好但 Judge 最差,瓶颈在产物语义而非可执行性

训练趋势(step 1→23)

  • 执行通过率:81.25% → 94.92%(+13.67pp)
  • Pass@1:41.80% → 53.52%(+11.72pp)
  • Reward 均分:5.390 → 7.043(+1.653)

关键发现

  1. 主要瓶颈已从"能否编译"转向"修复成本和实际执行":编译率已达 99.47%,但 Pass@1 仅 40.61%
  2. Permission 模块问题不在代码可执行性,而在产物语义:执行通过率最高但 Judge 通过率最低
  3. Workflow 同时存在质量和 Judge 稳定性问题:178/204 次 Judge 调用错误来自 Workflow
  4. 训练对"可执行性"的改善比对"最终产物完全通过 Judge"的改善更稳定

五、训练平台

平台 用途
方舟(Ark) 用于 doubao 系列模型的 SFT/RL 训练
Merlin 用于开源模型(如 Qwen 3.5 9B/27B)的训练

SFT 后的模型 checkpoint 作为后续 RL 训练的基座。


第二部分:Auto-Thinking 文档深度解读

文档:《多维表格 CodeAgent:Auto-Thinking 的 SFT 与 RL 完整训练方案》 作者:王哲 日期:2026.07.30 适用场景:多维表格的搭建、修改和修复;已有约 5,000 条 DIRECT SFT 数据,计划少量补充 THINK_SHORT 与 REPLAN 作为能力冷启动,Auto-thinking 的最终决策边界主要通过线上 query 的 RL 学习;可使用编译/执行工具与"产物是否正确构建"的 JudgeRewardModel。

一、要解决的根本问题

当前 CodeAgent 已有约 5,000 条 DIRECT SFT 数据(模型不输出思考,直接写代码调工具),效果不错但有明显短板:

  • 终局 Reward 太稀疏:一次失败只给一个 terminal_success=0,模型不知道是理解错需求、表结构设计错、字段 ID 用错、公式依赖不对,还是漏了验证。长代码中的大量 token 收到相同的负 advantage,学不到可迁移的错误归因。
  • 修复效率低:第一次失败后往往要多轮 ReAct 才能修好,甚至出现语义重复(状态没变、动作没变、还在反复试)。
  • 两个极端都不好:所有轨迹都加长 CoT → 成本高、可能事后编故事;完全不思考只靠终局 RL → credit assignment 差、恢复泛化弱。

核心目标:提高 Pass@1;第一次失败后尽量一次修好;简单状态直接做,只有思考确实能改变决策时才思考或重规划。

目标函数

把一次轨迹的效用写成:

U(τ)=Rcorrect−Cregression−λtCtool−λzCthinking−λwCwalltime−λrCrepeatU(\tau) = R_{\text{correct}} - C_{\text{regression}} - \lambda_t C_{\text{tool}} - \lambda_z C_{\text{thinking}} - \lambda_w C_{\text{walltime}} - \lambda_r C_{\text{repeat}}

优化优先级应是字典序,而不是简单把所有项等价相加:

安全、权限与数据完整性
> 任务功能正确
> 无回归
> 一次恢复成功
> 少重复、少工具调用、低时延、短 thinking

原因:一次 64-token 的短 thinking 如果能避免一次昂贵的构建和两轮错误修复,总成本反而更低。只惩罚 thinking token 会把 Gate 推向永远 DIRECT;只奖励成功又会把 Gate 推向永远 THINK 或 REPLAN。

核心指标

指标 定义
Pass@1 / First-pass success 第一次完整产物提交后直接通过全部验收
First-repair success 第一次失败后,仅允许一次修复时的成功率
Conditional recovery 首次失败条件下最终恢复成功率
Median recovery turns 成功恢复所需的中位修复 turn 数
Semantic repeat rate 状态未变化、动作语义重复且无新增信息的比例
Noisy-feedback overreaction 环境噪声或存量错误导致无关代码修改的比例
Premature-stop rate 未完成或未验证就输出 done 的比例
Regression rate 目标需求通过但破坏已有表、字段、视图、公式或数据的比例
Unnecessary-thinking rate DIRECT 足够成功但 Gate 选择 THINK/REPLAN 的比例
Thinking-necessity recall THINK/REPLAN 明显优于 DIRECT 时,Gate 选择非 DIRECT 的比例
Replan precision 选择 REPLAN 的状态中,确实存在核心假设失效的比例
Mode regret 同状态最优模式效用减去 Gate 所选模式效用
Success cost 每次成功的 thinking tokens、工具次数、执行时延和计算成本

其中 ModeRegret 是判断 auto-thinking 是否真的学会的核心指标:

ModeRegret(s)=max⁡mU(s,m)−U(s,m^)\text{ModeRegret}(s) = \max_m U(s,m) - U(s,\hat m)

仅看线上 THINK 占比没有意义:10% 可能过多,也可能远远不够。

离线验收目标

Pass@1:相对基线显著提升
First-repair success:相对基线提升幅度高于最终成功率提升
Semantic repeat rate:下降 30% 以上
Unnecessary-thinking rate:控制在 10%~15% 以内
Thinking-necessity recall:达到 85%~90%
Replan precision:达到 70%~80%
成功轨迹的工具调用 P50:不高于基线

二、三档模式 + 逐 turn Gate

为什么"短思考链 + RL"通常优于"直接代码 + RL"

直接代码 RL 的学习信号过于稀疏:不带显式 thinking 时,策略近似为 πθ(a∣s)\pi_\theta(a \mid s),若只有终局 Reward,一次失败会把相似的负 advantage 分配给长代码中的大量 token,但 Reward 并不明确告诉模型具体哪里错了。

短 thinking 把大动作分解成可学习的中间变量:引入模式 mm、短决策变量 zz 和动作 aa:

πθ(m,z,a∣s)=πg(m∣s) πz(z∣s,m) πa(a∣s,m,z)\pi_\theta(m,z,a\mid s) =\pi_g(m\mid s)\, \pi_z(z\mid s,m)\, \pi_a(a\mid s,m,z)

带来三个额外价值:

  1. 很多表面不同的错误可以映射到同一可迁移类别(如 schema_reference / last_diff / repair_reference),相当于在高维代码空间中增加了低维的故障与决策表示
  2. zz 提供了可验证的 RL 支撑点:可检查 attribution 是否与证据一致、decision 是否与 action 一致、expect 是否被下一次 observation 证实
  3. 改善多轮 credit assignment:ReAct 本质上是 MDP,短 thinking 提供了过程标签

从数据密度看:直接 RL 的一条失败轨迹通常只有 terminal_success = 0;带短 thinking 后,可以得到 error_type_correct、attribution_correct、decision_action_consistent、expected_observation_match、state_progress、terminal_success 等一组过程标签。

必须保留的边界:thinking 不是天然可信。显式思考可能是事后合理化,也可能与真实决策因果无关。必须同时检查 observation → evidence/attribution → decision → action → next observation,并做置空、置换和 decision 干预实验。

三种模式的精确定义

DIRECT

适用条件:

  • 需求清晰且是熟悉、局部、低风险的操作
  • 工具反馈唯一对应一个机械修复
  • 已有充分证据,不需要新增假设
  • 验证通过后应直接停止
  • 环境错误有确定的重试或切换 scoped check 动作
  • 思考不会改变下一动作

DIRECT 不等于不看上下文,也不等于不验证。它只是"不生成显式 thinking token"。

THINK_SHORT

适用条件:

  • 工具反馈需要区分 last_diff / baseline / environment / unknown
  • 有两个以上局部候选解释,但原方案仍基本成立
  • Judge 指出产物不符合需求,需要定位遗漏的验收条件
  • 第一次相关失败出现,需要在继续修复、回滚、重试或停止中选择
  • 一段短归因能够显著降低下一动作出错概率

不推荐固定字段或固定句式。通常用 1~3 句自然语言说明:当前反馈最可能说明什么、为什么选择下一动作、下一次检查应看到什么变化。

低价值反例是只有空泛结论,例如"检查失败了,我需要修复并验证",因为它没有使用当前反馈,也不能约束下一动作。

REPLAN

适用条件:

  • observation 证伪了当前方案的核心假设
  • 连续修复没有带来状态进展,且原因不是环境噪声
  • 原数据模型无法满足联表、汇总、公式或自动化约束
  • 需要跨表、字段、视图和自动化重新安排依赖顺序
  • 当前 diff 不断扩张,继续局部补丁的预期成本高于回滚重做
  • 用户意图被根本误解

REPLAN 同样使用自然语言,不输出字段清单。它通常用一个短段落说明:哪条核心假设已经站不住、哪些现有成果仍应保留、方案应如何改变,以及先验证哪一步。

REPLAN 不是"更长的 THINK_SHORT",而是方案边界发生变化。默认每条训练轨迹最多一次 REPLAN;再次 REPLAN 通常说明任务、工具环境或数据质量需要人工审查。

THINK_SHORT 与 REPLAN 的核心区别

最实用的判断问题:

在不改变对用户目标、数据模型和主要实现路径的理解时,能否通过一个局部动作取得可验证进展?

能,而且下一动作已经唯一明确 → DIRECT
能,但需要先消除局部歧义、判断错误归因或选择修复动作 → THINK_SHORT
不能;反馈已经推翻核心假设,继续局部修改不会解决根因 → REPLAN
维度 THINK_SHORT REPLAN
核心方案 仍然成立 已被证伪或已明显不经济
主要问题 局部诊断、归因或动作选择不确定 用户目标、数据模型、依赖关系或实现路径存在根本错误
改动范围 通常是一个局部对象或相邻依赖 通常跨多个对象、阶段或依赖关系
对已有修改的态度 大部分保留,只修正局部问题 明确保留可信部分,并回滚或替换失效部分
thinking 的任务 解释"为什么下一步这样修" 解释"为什么原路走不通,以及新路径是什么"
下一步动作 一个高置信度 repair、retry、verify 或 rollback 新计划中的第一个可验证里程碑
典型 token 预算 64~128,硬上限 160 128~192,硬上限 256
使用频率 少量但可重复出现 稀有,普通轨迹通常最多一次

不要用以下表面信号直接触发 REPLAN:日志很长、错误数量很多、已经失败过一次、THINK_SHORT 接近 160 tokens、任务本身看起来复杂。

Gate token 机制

Auto-thinking 不是在任务开始时只决定一次"整条轨迹是否思考",而是在每个 ReAct turn 根据新状态重新选择。

推荐用三个显式 reasoning-mode token 作为 Gate 输出:

<|mode_direct|>
<|mode_think_short|>
<|mode_replan|>

它是模型内部的一 token 元推理决策,不是 tool call,也不是让 serving 启动不同外部工作流的控制命令。整个过程仍是一次连续的自回归生成:

当前状态 s_t
→ 模型生成 mode token m_t
→ m_t 保留在模型上下文和 KV cache 中
→ 模型继续生成自然语言 thinking、action 或 tool call

Serving 只需缓存并剥离第一个 mode token,不把它返回给用户;该 token 仍然参与后续生成的条件上下文。

Gate token 的价值

加入显式 mode token 后,策略更容易分解为 π(m,y∣s)=πg(m∣s)π(y∣s,m)\pi(m,y\mid s)=\pi_g(m\mid s)\pi(y\mid s,m),带来:

  • 可单独提取 DIRECT、THINK_SHORT、REPLAN 的概率和 logprob
  • 可对 mode token 单独设置 SFT loss、RL advantage、KL 和熵约束
  • 可直接统计模式分布、mode regret 和模式塌缩
  • 可对同一状态强制不同模式做反事实评测
  • THINK_SHORT 与 REPLAN 不依赖事后分析自然语言才能区分
  • thinking 内容仍可保持自然、灵活,不受 mode token 格式限制

显式 Gate 通常每个 ReAct turn 只增加一个 token 和一次 decode step。Gate token 是"模型产生、模型继续消费、系统隐藏"的内部 token。

Runtime availability mask

建议增加一个确定性的 runtime availability mask:

  • 全新任务首 turn:通常只开放 DIRECT / THINK_SHORT
  • 已有历史方案或失败 observation:开放 DIRECT / THINK_SHORT / REPLAN
  • 纯环境 timeout、权限不足或依赖不可用:通常屏蔽 REPLAN,避免把环境问题误判成方案问题

这不是外部链路路由,也不是代替 Gate,而是只在首 token 位置把明显不合法的模式 logit 屏蔽。

状态输入要先去噪

Gate 不应直接吞入无限增长的原始日志。建议在每个 turn 构造短状态摘要:

{
  "user_goal": "...",
  "acceptance_criteria": ["..."],
  "current_artifact": "...",
  "last_diff_summary": "...",
  "last_action": "...",
  "observation_digest": {
    "kind": "compile_error",
    "primary_error": "...",
    "location": "...",
    "baseline_present": false
  },
  "trusted_facts": ["..."],
  "failed_hypotheses": ["..."],
  "progress_since_last_turn": true
}

原始工具日志仍可供 action 分支按需读取,但 Gate 和 short-thinking 优先使用结构化 digest。

三、数据策略:增量补充,不重新切分

默认配比

已有 5,000 条 DIRECT 不删除、不为凑比例重切,在此基础上增量:

模式 建议数量 默认数量 默认总体占比 SFT 阶段的定位
DIRECT 已有 5,000 5,000 约 85.5% 主能力、Pass@1 与"不必思考"的强先验
THINK_SHORT 新增 600~800 700 约 12.0% 冷启动错误归因、一次修复和短决策接口
REPLAN 新增 100~200 150 约 2.6% 冷启动方案失效识别、回滚和重规划能力

默认总量为 5,850 条。此外构建 300~500 个同状态模式比较样本,作为轻量 Gate warm-start。

DIRECT:确保 post-feedback 覆盖

不需要为了满足新比例删除已有 DIRECT。需要审计的是它们是否过度集中在"首次生成直接成功"。建议确保其中至少 300~500 条是 post-feedback DIRECT:

子类 建议覆盖 说明
直接机械修复 200~300 字段名、参数、唯一类型错误等,反馈后仍不输出 thinking
直接验证、重试或停止 100~200 确定性 scoped retry、验证成功后 done、环境问题不改代码

这部分非常重要。否则模型容易学成:没有 error → DIRECT;一旦出现 error/check → THINK_SHORT。正确策略应是判断显式 thinking 是否会改变下一动作。

THINK_SHORT:内部分类

子类 数量 说明
编译、类型、API 与 schema 归因 220 区分 last diff、baseline 和环境问题
Judge/Check 功能错误修复 280 需求遗漏、公式、视图、自动化和关联关系错误
初始高风险决策 80 多约束状态下,一段短决策能明显提高 Pass@1
噪声、不反应与正确停止 120 学会不被无关错误带偏

约 80%~90% 的 THINK_SHORT 应放在真实反馈后的恢复状态。

REPLAN:少而精

子类 数量 说明
数据模型或依赖关系重构 70 文本字段应改为关联字段,汇总/公式依赖需重建
用户意图或验收条件误解 35 产物形式完成但业务目标不成立
多次局部修复无进展 30 证据支持停止打补丁并回滚
修改范围失控或回归 15 需要缩小范围、恢复稳定基线

模式标签怎么打

最可靠的方法:同状态反事实模式比较。先根据 runtime availability mask 得到状态 s 的合法模式集合 M(s),再从同一个精确快照强制运行每个合法模式:

restore(s) → force DIRECT      → 执行并评分
restore(s) → force THINK_SHORT → 执行并评分
restore(s) → force REPLAN      → 仅在已有方案被反馈挑战时执行并评分

每个合法模式最好采样 2~4 次。按真实环境结果计算效用 U(s,m)。

标签规则:

  1. DIRECT 成功,且与最优模式效用差不超过 δ → label = DIRECT
  2. THINK_SHORT 相比 DIRECT 显著提升正确性或一次修复率,且原方案不需要重做 → label = THINK_SHORT
  3. 核心假设已被证伪,REPLAN 的真实结果最好 → label = REPLAN
  4. 所有合法模式全部失败,或结果差异落在噪声范围内 → Gate loss mask = 0

低成本启发式预标注:

状态 推荐模式
单一明确的字段名、参数或类型修复 DIRECT
已验证成功,应停止 DIRECT
确定性的 scoped retry,不涉及代码改动 DIRECT
第一次相关错误,需要判断是否来自 last diff THINK_SHORT
Judge 指出一个需求未满足,但整体方案成立 THINK_SHORT
两个局部候选都合理,需要证据选择 THINK_SHORT
中心数据模型被证伪 REPLAN
相同假设连续失败且状态无进展 REPLAN
修改范围持续扩大并引入回归 REPLAN
环境 timeout、权限或依赖不可用 DIRECT retry/stop;不是 REPLAN

Recovery SFT 与 Loss Mask

Recovery suffix 从"正确恢复判断"开始。推荐 mask:

基模生成的错误代码或错误 tool call       mask=0
真实编译、执行或 Judge observation      mask=0
错误类别和因果归因                     mask=1
repair / rollback / retry / replan 决策 mask=1
修复代码或工具动作                     mask=1
必要验证                               mask=1
验证后的 stop/done                     mask=1

错误 action 和真实 observation 仍应放在输入上下文中,因为恢复策略需要看到模型是如何走到失败状态的。但它们不能作为 imitation target。

需要注意:mask=0 = 不模仿,mask=0 ≠ 负监督。若要压制重复动作、盲改、过度扩大范围或提前结束,应为相同状态构造 chosen/rejected,可使用 DPO、ranking loss、unlikelihood 或在线 RL。

推荐 SFT loss

LSFT=λgLgate+λzLthinking+λaLaction+λpLpreferenceL_{\text{SFT}} = \lambda_g L_{\text{gate}} + \lambda_z L_{\text{thinking}} + \lambda_a L_{\text{action}} + \lambda_p L_{\text{preference}}

第一版建议:

  • action/tool token:1.0
  • 自然语言 thinking span:0.4~0.7,按 span 或 turn 归一
  • 可选的离线语义辅助 loss:0.1~0.3
  • 正确验证和 done:1.0~1.3
  • 错误 action、tool observation、冗余 thinking:0

应使用 span-normalized 或 turn-normalized loss,避免较长的自然语言说明获得比工具 action 更大的总梯度。

训练单位不要混淆

建议把"一条轨迹"和"一个 assistant target turn"分开统计:

  • trajectory_count:用于控制场景与模式覆盖
  • target_turn_count:用于计算实际训练曝光
  • token_count:用于防止长 thinking 获得过量梯度

多轮 REPLAN 轨迹天然包含更多 assistant token。如果直接做全局 token mean,即使原始轨迹只占约 2%~4%,也可能获得远高于其样本比例的梯度。建议先在每个 assistant turn 内做 token mean,再按 turn 权重聚合。

四、SFT:三阶段,只冷启动不替代 RL

S1:模式分支能力冷启动

目的:保留已有 DIRECT 主能力,并确保 THINK_SHORT、REPLAN 被强制选择时都"会做事"。

做法:

  • 使用已有 5,000 条 DIRECT,并混入新增的 600~800 条 THINK_SHORT、100~200 条 REPLAN
  • 如果 5,000 条 DIRECT 已经训练进当前 checkpoint,不必从头完整重训;在增量 SFT 中按场景分层回放 DIRECT
  • 原始默认比例约为 85.5/12.0/2.6,有效 batch 可从 82/15/3 起步
  • 模式 token 由数据强制注入,gate token mask=0
  • 训练 DIRECT action、THINK_SHORT 的短思考与 action、REPLAN 与 action
  • recovery 样本使用前述 suffix mask
  • 使用 turn-normalized loss
  • 以 DIRECT Pass@1 无回退、强制模式能力和格式正确率早停

有效 batch:

DIRECT       80%~85%,默认 82%
THINK_SHORT  12%~17%,默认 15%
REPLAN        2%~3%,默认 3%

这一步不让 Gate 自己选,是为了避免模型在 THINK/REPLAN 分支尚不会做时,Gate 因短期 Reward 永远逃回 DIRECT。

完成条件:

强制 THINK_SHORT:格式与 tool call 稳定;decision 与 action 一致;在 Think-necessary 集合上优于 forced DIRECT
强制 REPLAN:能指出失效假设;新 action 确实改变方案;在 Replan-necessary 集合上优于局部修复

S2:轻量 Gate warm-start

目的:只让 Gate 具备最小探索能力,避免 RL 初期 THINK_SHORT/REPLAN 触发概率接近零;不追求通过 SFT 学到最终决策边界。

数据:

  • 优先使用同状态、合法模式强制 rollout 的真实比较结果
  • 只需 300~500 个高信息状态,可从已有轨迹派生
  • 标签分布建议约为 65% DIRECT / 30% THINK_SHORT / 5% REPLAN
  • 加入 Direct-sufficient 与 Think-necessary 的边界状态
  • 不确定样本的 Gate loss 设为 0

训练:

只训练 mode token,后续 thinking/action loss=0
Gate loss 相对 S1 action loss:0.2~0.5
学习率:S1 的约 0.2~0.3 倍
短程训练;能保持模式探索且 mode-regret 不恶化即停止

这里的 65/30/5 只是 Gate 冷启动标签分布,不是线上目标分布。

S3:可选的联合小步 SFT

目的:让 Gate 输出、thinking 和 action 在自然生成条件下重新对齐。

做法:

  • 不再强制 mode token
  • 保持至少 80%~85% 的高质量 DIRECT 曝光
  • 使用 S1 约 0.2~0.3 倍学习率
  • update budget 不超过本轮 SFT 的约 10%,并严格早停
  • 监控 Gate 模式分布,防止突然偏向单一模式

如果 S2 后自然生成已经稳定,S3 可以跳过。

为什么 Auto-thinking 的关键必须放在 RL

Gate SFT 优化的是 Lgate-SFT=−log⁡πg(mteacher∣s)L_{\text{gate-SFT}} =-\log \pi_g(m_{\text{teacher}}\mid s),它回答的是"teacher 在这个静态状态上标了什么模式"。三个局限:

  1. 标签依赖生成它时的 checkpoint;模型变强后,原本需要 THINK_SHORT 的状态可能已经能 DIRECT
  2. 单个模式标签不能持续表达正确性、工具成本、thinking 成本和时延之间的 Pareto 关系
  3. teacher 容易把自己的思考习惯固化成 Gate 规则

RL 优化的是当前策略在真实环境中的效用,通过同一状态下 forced DIRECT、forced THINK_SHORT、forced REPLAN 与 AUTO 的真实比较,RL 能直接回答"对于当前 checkpoint,哪个模式实际更好"。

但不能完全跳过冷启动。如果 THINK_SHORT/REPLAN 分支从未被训练,强制 rollout 几乎总失败,RL 会把"分支能力不足"误认为"这个模式不该选",最终仍塌缩到 DIRECT。

Gate 训练的三层信号

阶段 mode token thinking/action 训练目标
分支能力 SFT 强制注入,loss mask=0 loss mask=1 条件策略 π(y|s,m):已知模式时能否正确生成对应行为
Gate warm-start loss mask=1 loss mask=0 π_g(m|s) 的最小初始边界
Gate RL 由当前策略真实采样,接受 mode-level advantage 接受 turn-level advantage 学习当前模型真正的模式决策边界

Forced-mode rollout 的 mode token 不是从当前 π_g 自然采样得到的,因此不能不加处理地作为普通 on-policy GRPO 样本更新 Gate。推荐分工:

  • AUTO rollout:mode 来自当前 policy → 直接更新 Gate、thinking 和 action
  • forced-mode rollout:mode 由训练系统指定 → 估计模式反事实效用、训练给定模式后的条件分支、构造 Gate 的 CE/DPO/preference 辅助信号、默认不直接计算普通 on-policy Gate gradient

五、RL:GRPO/DAPO + 三阶段 + 分层 Reward

算法

推荐从 multi-turn GRPO/DAPO 风格的组内相对优化开始:

  • 每个 query 或状态快照采样 6~8 条 rollout
  • 早期用强制模式 rollout 保证 THINK_SHORT/REPLAN 不因低初始概率而失去探索
  • 剩余 rollout 让 Gate 自然选择,直接训练 Auto-thinking
  • 以真实工具边界划分 macro-turn
  • 使用 turn-level advantage,而不是只把终局 advantage 平均给整条轨迹
  • all-fail 组不更新 Gate,送入课程学习或 teacher recovery
  • all-correct 组在 R1 可降采样,在 R3 可通过成功成本区分模式

以 group size G=8 为例:

全新任务的初始状态:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  4 × AUTO
  REPLAN 默认被 runtime mask 屏蔽

出现真实错误或 Check 反馈后:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  1 × forced REPLAN
  3 × AUTO

Macro-turn

mode token → optional thinking → action/tool call → real observation

Observation 后的 Reward 归因给前一个 macro-turn。工具 observation 只作为下一状态输入,不参与生成 loss。

分段 RL loss

理想形式:

LRL=−E[wgAglog⁡πg(m∣s)+1m≠D wzAz1∣z∣∑ilog⁡π(zi)+waAa1∣a∣∑jlog⁡π(aj)]+β DKL(πθ∥πSFT)−η H(πg)L_{\text{RL}} =-\mathbb{E} \left[ w_g A_g \log\pi_g(m|s) +\mathbf{1}_{m\neq D}\, w_z A_z \frac{1}{|z|}\sum_i\log\pi(z_i) +w_a A_a \frac{1}{|a|}\sum_j\log\pi(a_j) \right] +\beta\,D_{\mathrm{KL}}(\pi_\theta\|\pi_{\text{SFT}}) -\eta\,H(\pi_g)

其中:

  • AgA_g:同状态不同模式的相对效用
  • AzA_z:thinking 的证据扎根性、判断与 action 一致性、可验证预期与结果的过程 advantage
  • AaA_a:实际工具动作带来的进展和终局 advantage
  • H(πg)H(\pi_g):Gate 模式熵
  • KL:防止格式、工具协议和已有代码能力漂移

第一版若无法稳定估计三个 advantage,可以共享 turn-level trajectory advantage,但使用不同 span 权重:

w_gate   = 1.0~1.5
w_action = 1.0
w_think  = 0.2~0.5

Reward 层级

推荐优先使用分层排序(字典序):

Tier 0:安全、权限、数据完整性、是否篡改测试/verifier
Tier 1:可执行功能正确与用户验收
Tier 2:无回归、幂等性与无数据破坏
Tier 3:错误归因、有效进展、正确停止
Tier 4:模式、thinking、工具、时延成本

只有 Tier 0~3 相同或足够接近时,Tier 4 才决定优劣。

如果训练框架必须使用标量,可以从以下归一化模板开始:

R=+Rterminal+Rprocess−Rfailure−Rcost−RsafetyR = + R_{\text{terminal}} + R_{\text{process}} - R_{\text{failure}} - R_{\text{cost}} - R_{\text{safety}}

示例尺度:

R_terminal:0~10
  工具调用和产物格式合法          +0.5
  编译/构建通过                   +0.5
  隐藏功能与不变量 Check          +4.0
  Judge 需求满足                  +3.0
  无回归、数据保持和幂等          +2.0

R_process:整条轨迹最多 +2
  验证过的 milestone              +0.2~0.5
  可验证的正确 attribution        +0.2~0.4
  expect 与下一 observation 一致  +0.1~0.3

R_failure
  语义重复                         -0.5~-1.0
  无关范围扩张                     -0.5~-1.0
  未验证提前 done                  -1.0~-2.0
  制造新回归                       -2.0~-5.0

R_cost:整条成功轨迹通常不超过 -1
  额外工具调用、thinking token、wall time

R_safety
  篡改测试/verifier、越权删除、数据破坏  -20 并立即终止

硬原则:

成功 Reward > 所有效率惩罚的最大可能总和
功能正确 Reward > 编译通过和 Judge 文风 Reward
安全硬惩罚 > 所有正 Reward

多维表格专用 Reward

Schema 图正确性

检查表、字段、视图是否存在;字段类型与默认值是否正确;关联字段的方向和多重性是否正确;lookup / rollup / formula 的依赖图是否合法;是否存在悬空引用和循环依赖。

公式语义 Reward

不仅检查 parse,还应在隐藏样例上计算结果;覆盖空值、时区、边界日期、0 和负数;检查返回类型;验证字段重命名后的引用保持。

View 行为 Reward

检查 filter、sort、group、visible fields 和 records:应出现的记录全部出现;不应出现的记录不出现;排序和分组符合需求;修改未破坏其他已有视图。

Automation 图 Reward

检查 trigger 对象和条件;action 顺序与参数;字段引用;循环触发风险;重复运行幂等;模拟事件后的最终状态。

数据与权限不变量

未要求删除的数据仍存在;无关表、字段、视图未被修改;字段迁移没有静默丢值;权限范围未扩大;敏感字段未写入日志或输出。

最小改动 Reward

仅在功能正确与无回归相同的成功 rollout 之间比较:修改对象数量、diff 范围、新增/删除资源数量、迁移数据量。不要在失败和成功之间用最小 diff 排序。

Process Reward

可程序化的高价值过程信号:

baseline 是否存在相同错误
错误位置是否落在当前 diff 或直接依赖
rollback 上一步后错误是否消失
一个关键假设是否被验证或证伪
本 turn 是否改变了环境状态
下一 observation 是否符合 thinking 中自然语言表达的可验证预期
是否在验证成功后停止

自然语言 thinking 的辅助 Reward:

Rthinking-sem=w1Rgrounded+w2Rthought-action+w3Rexpected-effect−w4RredundancyR_{\text{thinking-sem}} = w_1 R_{\text{grounded}} + w_2 R_{\text{thought-action}} + w_3 R_{\text{expected-effect}} - w_4 R_{\text{redundancy}}

评估器应同时看到 observation + thinking + action + next observation。该项在整条轨迹中的正奖励应设置上限,并显著小于终局功能正确 Reward。

不要奖励:thinking 的长度、使用了多少专业术语、是否使用某种固定句式、声明了多少 milestone、编译错误数量减少、每做一次 repair 就得分。

Gate Reward

Gate 的目标不是匹配静态 teacher 标签,而是最大化当前模型的真实效用:

Rgate(s,m)=Routcome(s,m)−C(s,m)R_{\text{gate}}(s,m)= R_{\text{outcome}}(s,m)-C(s,m)

在同一状态的模式组内:

  • DIRECT 和 THINK 都成功 → DIRECT 获得较高相对 advantage
  • DIRECT 失败、THINK 一次成功 → THINK 获得较高 advantage
  • 局部修复反复失败、REPLAN 成功 → REPLAN 获得较高 advantage
  • 三者都失败 → 不更新或送入课程学习

成本惩罚应在 RL 初期较弱,等三种分支都具备基本能力后再逐步增加。

RL 三阶段(顺序不能反转)

R0:Reward dry-run

不更新模型,只运行当前 SFT checkpoint:检查各 Reward 分量分布;检查正确轨迹是否总分高于失败轨迹;审计 Judge 与隐藏执行分歧;验证成本项不会压过成功;建立各 query/error bucket 的基线。

R1:正确性与恢复能力

  • 约占 RL update budget 的前 20%~30%
  • 以终局执行、隐藏 Check、Judge 和无回归为主
  • 保持模式强制探索
  • thinking 和工具成本为 0 或只给很弱惩罚
  • 重点提升 Pass@1 与 First-repair success

R2:Gate 与一次修复

  • 约占中间 40%~50%
  • 增强同状态模式组内比较
  • 启用 turn-level advantage
  • 增加语义重复、无关修复和提前停止惩罚
  • 逐步加入条件化 token/tool/wall-time 成本

R3:Pareto 压缩

  • 约占最后 20%~30%
  • 仅在相同成功和进展等级的 rollout 间优化效率
  • 逐步提高 thinking 和额外工具成本
  • 周期性重新生成模式反事实
  • 将已经稳定成功的 THINK 状态转回 DIRECT 边界

核心顺序不能反转:先让各模式能产生正确结果,再让成本塑造 Gate;否则 5,000 条 DIRECT 先验叠加早期成本惩罚,极易形成永远 DIRECT。

线上 query 的 RL 数据工程

Query 入池

线上数据进入 RL 前需要:

  1. 脱敏和权限清洗:删除 token、个人信息、真实业务敏感值
  2. schema-preserving 匿名化:保留字段类型、依赖拓扑和错误结构
  3. 语义去重:相同模板、同一 Base 快照和重写 query 只保留代表样本
  4. 可执行快照:保存初始表结构、必要数据、工具版本与随机种子
  5. 固定验收条件:在 rollout 前生成并冻结 acceptance checklist
  6. 稳定性检查:同一正确产物重复运行 verifier 的结果应一致
  7. 可解性检查:工具权限、依赖和环境必须足以完成任务

RL prompt 采样建议

桶 group success rate 样本用途与规模
Easy anchor > 0.9 少量保留,用于稳定 DIRECT 和防遗忘
Learning frontier 0.1~0.9 RL 主体,模式比较与 advantage 最有信息
All-fail < 0.1 送 teacher recovery、课程学习或 SFT,不直接大量 RL
Unstable verifier 波动高 暂停训练,修环境或 verifier

第一版 query mix:

50% 当前模型的 learning-frontier 线上 query
25% 近期线上失败与多轮重复案例
15% 回归、权限、数据完整性和噪声边界案例
10% Easy DIRECT anchor

以"修复预算"约束一次修好

单独定义:

  • initial_build_actions:完成首版产物所需的动作
  • repair_turns:第一次 Check 失败后的修复轮数

主要 RL 任务可设置:

  • 普通 recovery:最多 1 个 repair turn + 1 次最终验证
  • REPLAN bucket:最多 2 个 recovery action,且最多 1 次 REPLAN
  • 状态无变化的同类失败重复一次:提前终止并处罚

六、六种训练崩溃模式与防护

1. 永远 DIRECT

常见原因:

  • 已有 5,000 条 DIRECT 形成强先验,但 Gate warm-start 和 RL 没覆盖真正 Think-necessary 的边界状态
  • RL 太早施加 thinking/tool 成本
  • THINK_SHORT 分支尚未学会,就与成熟 DIRECT 分支竞争
  • 强制探索不足,组内几乎没有成功的 THINK 候选
  • 所有失败都只有终局 Reward,无法体现正确归因的价值
  • Gate 标签由表面难度决定,长日志反而被误标

有效修复:

  • 先做分支能力冷启动,再做轻量 Gate warm-start,最终通过强制模式 RL 学边界
  • 用 300~500 个状态做轻量 Gate warm-start,而不是扩大 thinking SFT
  • RL 初期设置每组每模式的最小采样数
  • 对 Direct-fail / Think-success 状态上采样
  • 延迟并逐步增加思考成本
  • 监控 Thinking-necessity recall 和 mode regret,而非只看 THINK 比例
  • 对 Gate 添加小的熵正则和最小探索概率

2. 永远 THINK_SHORT

常见原因:

  • teacher 几乎每次 action 前都写 thinking
  • 修复样本远多于首次成功样本
  • 只奖励成功,不计算思考、工具和时延成本
  • thinking 结构本身被 Judge 偏好
  • DIRECT 只包含简单题,缺少"修复也可 Direct"的样本
  • Gate 把"出现 error 字符串"学成固定触发器

有效修复:

  • 整体 SFT 默认保持约 85% DIRECT
  • 确保已有 DIRECT 中至少 300~500 条覆盖直接机械修复、确定性重试和正确停止
  • 为同一成功状态提供 DIRECT chosen、THINK rejected
  • 成本只在正确性相同时生效
  • Judge 不评价 thinking 文风,只评价可验证决策与结果
  • 加入长日志但 Direct-sufficient、短日志但 Think-necessary 的反例
  • 监控 Unnecessary-thinking rate

3. 永远 REPLAN

常见原因:

  • REPLAN 文本长,token-level loss 中梯度过大
  • process reward 为"计划完整"或 milestone 数量加分
  • REPLAN 只出现在困难且成功的 teacher 轨迹中,形成伪相关
  • 初始 turn 也频繁强制 REPLAN
  • 局部失败没有精确的 progress 定义

有效修复:

  • 使用 turn-normalized loss
  • REPLAN 冷启动只新增 100~200 条,默认总体约 2.6%,且以真实核心假设失效为准
  • 不奖励计划长度、步骤数和专业表达
  • 全新任务初始 turn 默认屏蔽 REPLAN,仅在接手已有失败方案等状态下开放
  • 每条普通轨迹最多一次 REPLAN
  • 加入"虽然失败但原方案仍有效,应 THINK_SHORT"的负例
  • 监控 Replan precision

4. Token 熵塌缩

症状:

Gate 很快只输出一种 mode
thinking 变成固定模板或重复短句
rollout 多样性骤降
训练 Reward 上升但 held-out 正确率下降

措施:

  • 监控 Gate、thinking、action 三个 span 的独立 entropy
  • 使用当前 policy 的 on-policy rollout,减少陈旧离线轨迹占比
  • 对 all-correct/all-fail group 做动态采样
  • 使用适当的 asymmetric clip / clip-higher 或同类稳定化
  • 保持小步更新、gradient clipping 与自适应 KL
  • 设 mode exploration floor;初始状态覆盖 DIRECT/THINK_SHORT,反馈后状态再覆盖三模式
  • 对 query、错误摘要和提示模板做不改变语义的增强
  • 按任务与错误 bucket 分别做 reward normalization
  • 对 reward 和 advantage 截断异常值
  • 训练 Judge Reward 上升而 executable Reward 下降时自动暂停
  • 保存短间隔 checkpoint,并以综合 held-out 指标选择,而不是最后一步

5. Gate 决策边界塌缩

Gate 是离散模式决策,尤其容易在多阶段训练中被单一模式占领。对应做法:

有稳定同状态优胜结果 → 更新 Gate
合法模式差异小或全部失败 → mask Gate loss
分支能力不足导致的失败 → 先训练分支,不把失败归因给 Gate
当前 checkpoint 能力变化 → 重新收集反事实,刷新标签

6. Reward hacking

重点审计:

  • 删除或放宽 Check
  • 修改 Judge 输入或验收 rubric
  • 输出空产物以减少错误
  • 只修日志显示,不修功能
  • 写出 Judge 喜欢的流畅 thinking,但内容未扎根反馈或与 action 无关
  • 故意制造容易修的小错赚 process reward
  • 提前 done 以减少工具成本
  • 修改无关数据使隐藏样例碰巧通过

防护:

  • verifier、隐藏测试与 policy 沙箱权限隔离
  • 工具层记录所有资源和数据 diff
  • hard-coded output、测试篡改、权限扩大直接终止
  • 训练 Judge、holdout Judge 和 executable verifier 分离
  • 定期人工审计"高 Reward、低执行正确率"的样本
  • 过程 Reward 设置总上限,不能抵消终局失败
  • 维护 reward-component dashboard 与 divergence 告警

七、怎么证明 Auto-Thinking 真的有效

1. 强制模式 Oracle

在固定评测状态上分别强制 DIRECT、THINK_SHORT、REPLAN、AUTO,得到每个合法模式的真实效用和 AUTO 的 mode regret。AUTO 应接近同状态最优合法模式,而不是仅在平均成功率上看起来不错。

2. 因果干预

Thinking 置空

正常 short-thinking vs. 保留 mode 但清空 thinking

如果 action 和成功率几乎不变,thinking 没有成为有效支撑点。

Thinking 置换

把任务 A 的 thinking 放到表面相似的任务 B 状态。若 action 不受其中错误证据和错误判断影响,模型可能只依赖 observation 关键词。

Decision 干预

保持其他内容相同,将自然语言中的关键判断从"当前修改破坏了公共契约,应回滚上一处改动再重新实现"替换为"现有方案仍然成立,应保留当前改动并继续局部修复"。应观察到 action 方向变化。否则这段自然语言 thinking 可能只是装饰。

Expect 校验

从 thinking 中语义抽取其可验证预期,并与真实 observation 比较:

  • 符合:说明假设得到支持
  • 不符合:下一 turn 应降低原假设置信度并重新归因
  • 连续不符合仍重复动作:计入 semantic repeat

3. 必做消融

至少比较:

  1. Direct SFT + Direct RL
  2. 固定所有状态 THINK_SHORT
  3. 固定长 CoT
  4. Auto-thinking SFT,不做 RL
  5. Auto-thinking SFT + 终局 RL
  6. Auto-thinking SFT + turn-level RL
  7. 去掉 attribution/expect process reward
  8. 去掉同状态模式反事实
  9. 去掉条件成本 Reward
  10. 完整方案

所有实验保持:同一基座与 checkpoint 起点、同一训练 query、同一 rollout 预算、同一工具和 verifier、同一测试集、相近总训练 token / compute。

4. 上线闸门

Pass@1 与 First-repair success 同时提升
Mode regret 不高于预设阈值
Thinking-necessity recall 达标
Unnecessary-thinking rate 不超标
Replan precision 达标
Semantic repeat 与 premature stop 下降
Judge Reward 与 executable Reward 同向
安全、权限和数据回归零恶化

只要其中一项明显恶化,就不能用"平均 Reward 上升"解释为训练成功。

八、高阶模型的角色

分工公式

基模 / 当前 checkpoint:产生真实状态分布
高阶模型:定位偏离、生成候选、压缩 thinking、构造反事实
真实环境:执行、验证和判真

高阶模型适合担任:

  1. 轨迹编辑器:标记 keep / mask / replace / truncate
  2. 首次偏离定位器:找出错误开始传播的 turn
  3. 恢复专家:从基模真实失败状态生成最小 recovery
  4. thinking 压缩器:将长推理改写为预算内、语义有效的自然语言短段落
  5. 反事实候选生成器:为同一状态生成 DIRECT、THINK_SHORT、REPLAN
  6. Rubric 生成器:将用户 query 转换为可执行的验收 checklist
  7. Judge 审核器:发现 JudgeRewardModel 未覆盖的失败模式

它不应:

  • 独立生成绝大多数完整轨迹
  • 虚构工具 observation
  • 同时成为唯一生成者和唯一裁判
  • 把 gold 代码、隐藏测试或不可见信息写入学生 thinking
  • 将自己的长 CoT 原样蒸馏给小模型

双教师视角

Privileged Critic

可以看到参考产物、隐藏 Check、正确修改范围,用于筛选、打标签和比较,不直接进入学生可见 target。

Blinded Actor

只能看到线上推理时可见的信息:用户 query、当前 Base/schema 与数据摘要、当前代码和 diff、已经真实返回的工具 observation。真正进入 SFT target 的 short-thinking、replan 和 action 由 Blinded Actor 生成,并在真实环境重放。

数据生产流水线

  1. 对每个任务用基模或当前 checkpoint 采样 4~8 条 rollout
  2. 保存每个 assistant turn 前的可恢复环境快照与状态 fingerprint
  3. 用高阶模型定位首次关键偏离、错误归因、重复动作和错误停止
  4. 对高价值状态的每个合法模式生成 2~4 个候选
  5. 从同一快照真实重放;所有 observation 必须来自工具
  6. 按正确性、无回归、进展和成本选最短有效路径
  7. 将 teacher 长 reasoning 压成 THINK_SHORT 或 REPLAN 格式
  8. 产出四类视图:最短 clean-success、错误前缀 mask=0 的 recovery suffix、同状态 mode preference / chosen-rejected、噪声/停止/回滚和反 reward-hacking 样本
  9. 进行硬过滤:工具格式合法、执行可重放、隐藏 Check 通过、无测试或 verifier 篡改、无数据破坏、无不可见信息泄漏、无状态不变的循环、thinking 未复制整段日志

与学生分布一致的约束

  • 状态来自基模和当前 checkpoint,而不是只来自高阶模型的干净轨迹
  • teacher 与 student 使用相同工具、相同可见上下文、相同 action schema
  • teacher 输出必须服从 student 的 160/256-token 预算
  • teacher 只生成候选,最终选择由真实环境和独立 verifier 决定
  • 每次模型能力有明显提升后重新收集 rollout
  • 按线上 error/query bucket 对齐采样
  • 保留一部分 student 自己成功的最短轨迹
  • 高阶模型的置信度只能用于排序,不能当作真值

九、落地时间线(7 步)

Step 1:建立评测与可重放环境

  • 固定 Base/schema 快照、工具版本和 acceptance checklist
  • 建立 Pass@1、first-repair、mode regret 和成本报表
  • 实现安全、数据保持、幂等、schema、公式、view 和 automation verifier
  • 校准 JudgeRM 并建立独立 holdout Judge

没有稳定 verifier 时不要急着开始在线 RL。

Step 2:审计 5,000 条 DIRECT 并补充冷启动数据

  • 保留现有 5,000 条 DIRECT,不为满足比例而删除
  • 确保其中 300~500 条覆盖 post-feedback DIRECT
  • 新增 600~800 条 THINK_SHORT,默认 700
  • 新增 100~200 条 REPLAN,默认 150
  • 从基模失败状态生成 recovery suffix
  • 将长 CoT 压为 64~128 tokens、最多 160 tokens 的 THINK_SHORT
  • 将真正方案失效样本整理为 REPLAN
  • 对错误前缀和 observation 做正确 loss mask

Step 3:高阶模型生成同状态反事实

  • 选 Gate 边界状态
  • 每个合法模式生成 2~4 个候选
  • 真实重放
  • 产出 mode label、chosen/rejected 和不确定 mask
  • 首批只需覆盖 300~500 个高信息状态

Step 4:完成能力冷启动与轻量 Gate warm-start

S1 强制模式分支能力 → S2 轻量 Gate warm-start → S3 可选联合小步

SFT 的停止条件是三个强制模式均达到最低可用门槛且 DIRECT Pass@1 无回退。

Step 5:Reward dry-run

  • 在 SFT checkpoint 上运行至少一个完整评测周期
  • 画出每个 Reward 分量与真实成功率的相关性
  • 审计高 Reward 失败样本
  • 确认成本项不会压过正确性

Step 6:R1/R2/R3 在线 RL

  • R1 前 20%~30% 先学正确和一次恢复,弱化成本
  • R2 中间 40%~50% 学 Gate、重复抑制和停止
  • R3 最后 20%~30% 做成功成本 Pareto 压缩
  • 初始状态按 2 DIRECT + 2 THINK_SHORT + 4 AUTO 探索
  • 反馈后状态按 2 DIRECT + 2 THINK_SHORT + 1 REPLAN + 3 AUTO 探索
  • 采用 learning-frontier 动态采样
  • 周期性把新失败状态交给高阶模型生成 recovery 和反事实

Step 7:周期性蒸馏与刷新

每个主要 RL checkpoint:

  1. 在固定状态强制运行全部合法模式
  2. 重新计算 mode regret 与决策边界
  3. 将稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
  4. 删除旧的冗余或被新能力淘汰的 thinking 标签
  5. 保持一部分原始 DIRECT 数据,防止灾难性遗忘

十、一句话总结

对于多维表格 CodeAgent,最优方向不是"所有轨迹都加 CoT",也不是"完全不输出 thinking,只依靠终局 RL"。更合理的方案是:

把短 thinking 设计成自然语言、但可被语义验证的决策瓶颈
把是否使用 thinking 设计成逐 turn 的 Gate
把 DIRECT、THINK_SHORT、REPLAN 作为三种能力先分别训练
再通过同状态真实反事实和多轮 RL 学习模式边界

SFT 只需让三种分支可用,并给 Gate 一个最小探索起点;不应依靠大量 THINK_SHORT/REPLAN SFT 固化模式边界。RL 才是 Auto-thinking 的核心。Auto-thinking 是否成功,最终不由 THINK 占比决定,而由:

更高 Pass@1
+ 更高一次修复率
+ 更低模式 regret
+ 更少无效重复
+ 更低成功成本
+ 无安全和数据回归

共同决定。


第三部分:核心概念深入解读

一、CoT 及其家族

1. 什么是 CoT(Chain-of-Thought,思维链)

CoT 的核心思想:让大模型在给出最终答案前,先输出一段中间推理过程。

用户:一个农夫有15只鸡和兔子,总共40条腿,各有多少?

无 CoT:鸡10只,兔子5只。(直接给答案,可能对也可能错,错了不知道错在哪)

有 CoT:
设鸡x只,兔子y只。
x + y = 15
2x + 4y = 40
解得 x=10, y=5。
鸡10只,兔子5只。(推理过程可见,可追溯)

2022 年 Google 的论文《Chain-of-Thought Prompting Elicits Reasoning in Large Language Models》发现,对于数学、逻辑、多步推理任务,只要在 prompt 里加一句"Let's think step by step"或者给几个带推理过程的示例,模型准确率就能大幅提升。

原因:

  • 大模型是自回归的,每生成一个 token 都基于前面所有 token;显式写出推理步骤相当于给模型"搭台阶"
  • 中间步骤提供了可追溯的推理路径,错误更容易定位

2. CoT 的问题

CoT 不是银弹:

(a) 成本高:每步推理都要消耗 token。简单任务写 500 token 推理纯属浪费。

(b) 可能事后合理化(faithfulness 问题):模型可能先"直觉性"地决定了答案,然后再编一段看起来合理的推理来配合它。文档引用《Measuring Faithfulness in Chain-of-Thought Reasoning》——如果删除或改变 thinking 后 action 基本不变,那这段 thinking 就是装饰。

(c) 长 CoT 可能引入错误:推理步骤越多,某一步出错的概率越大,而且错误会传播。

(d) 固定 CoT 不适应任务难度:所有任务都用同样长度的思考,简单任务过度思考,复杂任务思考不足。

3. CoT 的主要变体

变体 做法 特点
Zero-shot CoT prompt 加"Let's think step by step" 零样本,简单但效果有限
Few-shot CoT 给几个带完整推理的示例 效果更好,但需要精心设计示例
Self-Consistency 采样多条 CoT,投票选最一致的答案 提高鲁棒性,但成本乘以采样数
Tree of Thoughts (ToT) 推理过程组织成树,可回溯、可搜索 适合复杂规划,但实现复杂、成本高
隐式 CoT 不输出可见推理,靠模型内部"隐式思考"(如 DeepSeek-R1 的推理 token) 用户看不到推理,但模型内部仍在多步计算
自适应 CoT (AdaCoT) 模型自己决定什么时候需要 CoT、需要多长 文档方案的理论基础之一

4. 文档中的三档模式与 CoT 的关系

文档的方案本质上是一种精细化的自适应 CoT,但不是简单的"思考/不思考"二选一,而是三档:

DIRECT        = 完全不输出 thinking,直接行动(无 CoT)
THINK_SHORT   = 输出 64~128 token 的短推理(微型 CoT)
REPLAN        = 输出 128~192 token 的重规划(方案级 CoT)

关键区别于传统自适应 CoT:

  • 逐 turn 决策,不是任务开始时决定一次
  • 用显式 Gate token 把"要不要思考"变成可单独训练的离散变量
  • THINK_SHORT 不是自由发挥的长推理,而是有证据、有归因、有预期的短决策说明
  • REPLAN 不是"更长的 THINK_SHORT",而是方案边界发生了变化

文档引用 AdaCoT 论文,其核心思想是把 CoT 触发视为正确率与成本的 Pareto 优化——文档把这个思想从"触发/不触发"扩展到了"三档推理深度"。

5. THINK_SHORT 的 token 预算

目标长度:64~128 tokens
P90:不超过 128 tokens
硬上限:160 tokens
实验上限:192 tokens,仅用于消融

REPLAN 目标:128~192 tokens
REPLAN 硬上限:256 tokens

160-token 硬上限的合理性:THINK_SHORT 通常只需要表达基于反馈的诊断与必要证据(约 25~55 tokens)、下一动作及选择理由(约 20~40 tokens)、必要时的预期结果(约 15~30 tokens),其余预算留给对象名、公式与自然连接语。

如果一个状态稳定需要超过 160 tokens 才能决定下一动作,它通常更适合 REPLAN。

长度控制方式:训练数据在入库前压缩到预算;为 </thinking> 提供明确 stop token;对超长但正确样本做 teacher 重写;RL 中仅在正确性相同的 rollout 之间比较长度。

必做预算消融:固定相同模型、任务、工具预算和 Reward,比较 DIRECT、cap=96、cap=128、cap=160、cap=192、长自由 CoT,按 First-repair success vs. thinking tokens + 工具调用 + wall time 的二维 Pareto 选择。

二、训练范式

1. SFT(Supervised Fine-Tuning,监督微调)

最基础的微调方式:给模型一批"输入→理想输出"的配对数据,让模型模仿。模型通过最小化交叉熵损失来学习:教师输出的每个 token 概率要尽可能高。

优点:简单稳定,能快速让模型学会格式和基本能力。 局限:只能"模仿"示范轨迹,无法自我修正;泛化能力受限于数据覆盖;对于有多种正确解法的任务,SFT 会把模型拉向教师的特定解法。

文档中 SFT 的定位:只冷启动模式能力,不负责学最终决策边界。

2. RFT(Rejection Sampling Fine-Tuning,拒绝采样微调)

介于 SFT 和 RL 之间:

  1. 用当前模型对同一个问题采样多条输出
  2. 用奖励模型/验证器给每条输出打分
  3. 只保留高分输出,扔掉低分的
  4. 用高分输出做 SFT

相当于"让模型自己生成候选,挑好的来学"。比纯 SFT 更灵活,比 RL 更稳定。文档中提到"SFT/RFT + RL"作为课程训练阶段二的方法。

3. RL(Reinforcement Learning,强化学习)

不提供固定的"正确答案",而是定义一个奖励函数,让模型在环境中试错,通过最大化累计奖励来学习策略。

关键优势:模型可以发现教师没想到的更优解法;能学习"在多个选项中选哪个更好"的偏好;能从失败中学习。

关键挑战:奖励设计难(reward hacking)、训练不稳定(熵塌缩、策略漂移)、计算成本高。

4. RLHF / RLVR / RLAIF

RL 的具体子类,区别在于奖励来源:

方法 奖励来源 文档中的角色
RLHF (RL from Human Feedback) 人类标注偏好 成本高,文档未作为主力
RLVR (RL from Verifiable Rewards) 可自动验证的规则(编译通过、单测通过、schema 检查) 文档课程训练阶段一使用,高可信低歧义
RLAIF (RL from AI Feedback) AI 模型(JudgeRM)打分 文档中 L3 语义评估使用,配合可执行 verifier

文档的三层 Reward 架构就是 RLVR + RLAIF 的混合:

  • L1 编译检查 = RLVR(tsc 是否通过,客观可验证)
  • L2 真实执行 = RLVR(运行是否成功)
  • L3 语义评估 = vitest 单测(RLVR)+ LLM Judge(RLAIF)

5. DPO(Direct Preference Optimization,直接偏好优化)

不需要显式训练奖励模型、也不需要在线 rollout 的偏好学习方法。直接用"好的输出 vs 坏的输出"配对数据,通过一个简单的损失函数让模型增加好输出的概率、降低坏输出的概率。

DPO 比 PPO/GRPO 简单稳定,但它是离线的,适合做"抑制重复动作、盲改、过度扩大范围"这类有明确好坏对比的学习。文档中提到在 mask=0 不够时,用 DPO/ranking loss 来主动抑制坏行为。

6. 课程学习(Curriculum Learning)

先易后难地组织训练数据和训练阶段。文档中的课程训练:

  • 阶段一:只要求编译执行通过、单测通过(容易的目标),用 SFT + RLVR
  • 阶段二:要求机评 Judge 通过(更难的目标),用 SFT/RFT + RL

直觉上类似人类学习:先学会走路再学跑步。

三、RL 算法

1. PPO(Proximal Policy Optimization,近端策略优化)

传统 RLHF 的标准算法。核心思想:每次策略更新不能太大,用一个 clip 比率限制新旧策略的差异,保证训练稳定。

PPO 需要一个**价值模型(Value Model / Critic)**来估计每个状态的价值,用于计算 advantage。

缺点:需要额外训练价值模型,计算成本高,实现复杂。

2. GRPO(Group Relative Policy Optimization,组相对策略优化)

DeepSeek 提出的算法,是 PPO 的简化版,去掉了价值模型。

核心思想:对同一个问题采样一组(group)输出,用组内的相对排名来计算 advantage,不需要单独的价值网络。

同一个 query,采样 8 条轨迹 → 每条算 reward →
组内归一化得到 advantage → 用 advantage 加权更新策略

优点:省掉价值模型,训练更简单,适合代码/数学这类有明确奖励的场景。DeepSeek-R1 就是用 GRPO 训练的。 缺点:组内 reward 方差大时 advantage 估计不准;容易出现熵塌缩。

文档中 Code Agent 的 RL 第一版用的就是 GRPO,每条样本 8 条并行轨迹。

3. DAPO(Dynamic Sampling, Length Control, and Clipping for Policy Optimization)

OpenAI 提出的大规模开源 RL 系统/算法改进,在 GRPO 基础上加了三个关键改进:

  • 动态采样(Dynamic Sampling):按任务难度动态调整采样数
  • 长度控制(Length Control):对过长输出施加惩罚
  • 改进的 clipping:asymmetric clip,提高稳定性

文档引用 DAPO 作为缓解 naive GRPO 的 reward noise、过长输出和熵塌缩的参考。

4. On-policy vs Off-policy

  • On-policy(在策略):用当前模型自己生成的 rollout 来训练当前模型。数据新鲜,但每次更新都要重新采样,成本高。
  • Off-policy(离策略):可以用旧模型/其他模型生成的数据来训练。样本效率高,但有分布偏移问题,需要 importance sampling 修正。

文档中:

  • AUTO rollout 的 mode 来自当前 policy → on-policy,可直接更新 Gate
  • forced-mode rollout 的 mode 由训练系统指定 → 不是自然采样,默认不直接做 on-policy Gate gradient
  • 减少陈旧离线轨迹占比,多用 on-policy rollout 防熵塌缩

5. Advantage 与信用分配(Credit Assignment)

Advantage(优势):一个动作比"该状态下的平均动作"好多少。正 advantage → 增加该动作概率;负 advantage → 降低。

信用分配问题:在多轮 Agent 中,最终成功/失败应该归功(或归咎)于哪一轮的哪个动作?

如果只给整条轨迹一个终局 reward,所有 turn 都收到相同的负 advantage,模型不知道具体哪步错了。

Turn-level advantage(轮次级优势):把 reward 归因到具体的 macro-turn,每个 turn 根据自己的动作和后续 observation 获得更精确的 advantage。

短 thinking 改善信用分配的机制:thinking 中的归因、预期结果提供了可验证的中间变量。比如 thinking 说"修改筛选条件后已结清客户应该消失",如果下一次 observation 显示已结清客户还在,那就可以精确归因到"这个 thinking 的判断错了"。

四、Auto-Thinking 特有概念

1. Gate token / Reasoning-mode token

文档最核心的技术设计。传统模型"要不要思考"是隐式的,无法单独训练和干预。

文档引入三个特殊 token:<|mode_direct|>、<|mode_think_short|>、<|mode_replan|>。

这个 token 的价值:

  • 可单独提取概率和 logprob
  • 可单独设置 loss(S1 gate loss=0,S2 只训练 mode token)
  • 可单独施加 RL advantage
  • 可强制注入做反事实比较
  • 可统计模式分布和 mode regret

每 turn 只增加 1 个 token,成本几乎可以忽略,但把一个隐式决策变成了显式可训练的元推理变量。

2. Mode Regret(模式遗憾)

衡量 Auto-Thinking 是否成功的核心指标:

ModeRegret(s)=max⁡mU(s,m)−U(s,m^)\text{ModeRegret}(s) = \max_m U(s, m) - U(s, \hat m)

含义:Gate 选的模式比"该状态下最好的模式"差多少。如果 Gate 总是选到最优模式,regret=0。

为什么不用 THINK 占比?因为 10% 的 THINK 可能过多,也可能远远不够。只有 mode regret 能回答"Gate 的决策质量到底好不好"。

3. 同状态反事实比较(Counterfactual Comparison)

对同一个精确状态快照,分别强制不同模式执行,比较真实结果。这是 Gate warm-start 标签和 RL advantage 的数据基础。

没有反事实比较,Gate 的标签就只能靠"任务看起来难不难"这种主观判断,不可靠。

4. 模式塌缩(Mode Collapse)

训练过程中 Gate 退化为永远只选一种模式的现象:

  • 永远 DIRECT:5000 条 DIRECT 先验太强 + 早期成本惩罚
  • 永远 THINK_SHORT:teacher 每次都写 thinking + 只奖励成功不计成本
  • 永远 REPLAN:REPLAN 文本长梯度大 + process reward 奖励计划长度

核心修复原则:先让各分支能力均衡,再用成本塑造偏好,顺序不能反。

5. Pareto 优化 / Pareto 压缩

Pareto 最优:在不牺牲任何一个目标的前提下,无法再改善另一个目标。

文档中的 R3 阶段"Pareto 压缩":在已经能正确完成任务的 rollout 中,进一步优化效率(更少 thinking token、更少工具调用、更短时延)。

关键约束:只在相同成功和进展等级的 rollout 间比较成本。不能在失败和成功之间用"最小改动"排序。

五、工程与评估概念

1. ReAct(Reasoning + Acting)

ReAct 是一种 Agent 交互模式:模型交替进行推理(Thought)和行动(Action),观察行动结果(Observation)后再推理,循环直到完成。

文档中的 CodeAgent 就是 ReAct 模式,最多 20 步,每步就是一个 macro-turn。Auto-Thinking 的 Gate 就是在每个 ReAct turn 决定这一步要不要先思考。

2. CodeAct

CodeAct 是 ReAct 的一个特例:Action 不是调用预定义工具,而是生成代码。模型写 TypeScript 代码,代码调用 @bitable/agent-sdk,在沙箱中编译执行。

3. Verifier vs JudgeRM

Verifier(验证器) JudgeRM(评判奖励模型)
性质 程序化、客观规则 LLM 打分、主观判断
检查内容 编译通过、单测通过、schema 合法、公式计算正确 整体结构是否符合用户意图、命名是否合理、多约束是否全满足
可信度 高,不会被欺骗 中等,可能有偏差、可能被 reward hacking
成本 低,自动运行 较高,需要 LLM 调用

文档强调 JudgeRM 不能成为唯一真值,必须配合可执行 verifier,且训练 Judge、holdout Judge、executable verifier 三者分离。

4. Process Reward(过程奖励)

除了终局奖励,还给中间步骤的奖励:thinking 中的归因是否与证据一致、预期是否被证实、验证过的 milestone 等。

好处:把稀疏的终局反馈变密集,改善信用分配。 风险:容易被 reward hacking。

防护:过程奖励必须由真实执行/语义评估器得到;设总上限,不能抵消终局失败。

5. Reward Hacking(奖励作弊)

模型找到奖励函数的漏洞,用"投机取巧"的方式获得高奖励,但实际上没有完成任务。

典型方式:删除/放宽 Check、输出空产物、只修日志不修功能、写 Judge 喜欢但与 action 无关的 thinking、故意制造容易修的小错赚 process reward、提前 done。

防护核心:多层 verifier 隔离 + 人工审计高 Reward 低执行正确率的样本 + divergence 告警。

6. 熵塌缩(Entropy Collapse)

RL 训练中模型的输出分布急剧变窄,失去多样性:Gate 只输出一种 mode、thinking 变固定模板、Reward 上升但 held-out 正确率下降。

文档强调不能只靠一个全局 entropy bonus,要监控 Gate、thinking、action 三个 span 的独立 entropy 流。

7. 知识蒸馏(Distillation)

把大模型/强模型的能力迁移到小模型/目标模型。文档中的蒸馏:

  • 高阶模型生成 recovery suffix、压缩 thinking、构造反事实 → 蒸馏给基模
  • RL 训练后,把稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
  • 保留一部分原始 DIRECT 数据 → 防止灾难性遗忘

关键原则:高阶模型不能替代真实环境判真。

8. Loss Mask(损失掩码)

在 SFT 中,指定哪些 token 参与梯度计算、哪些不参与。

  • mask=1:这些 token 要模仿(计算 loss)
  • mask=0:这些 token 不模仿(不计算 loss),但仍在上下文中

文档中 recovery 数据的 mask 策略:错误前缀和 observation mask=0(不模仿错误),从正确恢复判断开始 mask=1。

注意 mask=0 ≠ 负监督:它只是"不教模型学这个",不会主动"教模型别这么做"。要主动抑制坏行为,需要 chosen/rejected 配对数据(DPO)或 RL。

六、概念组合:完整训练流水线

┌─────────────────────────────────────────────────────┐
│  数据层                                              │
│  ┌──────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │ 5000条   │  │ 新增700条    │  │ 新增150条    │  │
│  │ DIRECT   │  │ THINK_SHORT  │  │ REPLAN       │  │
│  │ SFT数据  │  │ (高阶模型    │  │ (高阶模型    │  │
│  │          │  │  压缩+蒸馏)  │  │  生成+蒸馏)  │  │
│  └────┬─────┘  └──────┬───────┘  └──────┬───────┘  │
│       │               │                 │          │
│       └───────────────┼─────────────────┘          │
│                       │                            │
│  同状态反事实比较(300~500个高信息状态)               │
│  → 产出 mode label + chosen/rejected                │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  SFT 阶段(冷启动,不替代RL)                         │
│                                                       │
│  S1: 分支能力冷启动                                   │
│      强制 mode token, gate loss=0                    │
│      有效batch 82/15/3, turn-normalized loss         │
│      学: 给定模式时能否正确生成对应行为               │
│                                                       │
│  S2: Gate轻量warm-start                              │
│      只训练mode token, 300~500状态                   │
│      标签分布65/30/5, 学习率为S1的0.2~0.3倍          │
│      学: Gate有最小探索能力, RL初期不塌缩             │
│                                                       │
│  S3(可选): 联合小步SFT                                │
│      不强制mode, 保持80~85% DIRECT曝光               │
│      update budget ≤10%, 严格早停                    │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  Reward dry-run(不更新模型)                         │
│  检查Reward分量分布与真实成功率相关性                  │
│  审计高Reward失败样本, 确认成本不压过正确性            │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  RL 阶段(GRPO/DAPO, 核心学习阶段)                   │
│                                                       │
│  每状态采样8条rollout:                                │
│    初始: 2 forced DIRECT + 2 forced THINK + 4 AUTO   │
│    反馈后: +1 forced REPLAN, -1 AUTO                 │
│                                                       │
│  三层Reward(字典序):                                  │
│    Tier0 安全/数据完整性 > Tier1 功能正确 >           │
│    Tier2 无回归 > Tier3 有效进展 > Tier4 成本         │
│                                                       │
│  Turn-level advantage + macro-turn信用分配            │
│  AUTO rollout → on-policy更新Gate                     │
│  forced rollout → 反事实估值+条件分支训练             │
│                                                       │
│  R1(20~30%): 正确性与恢复, 成本惩罚≈0                 │
│  R2(40~50%): Gate与一次修复, 逐步加成本               │
│  R3(20~30%): Pareto压缩, 成功rollout间优化效率        │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  评估与验证                                           │
│  强制模式Oracle → mode regret                        │
│  因果干预(置空/置换/decision干预) → thinking忠实性    │
│  10组消融实验 → 各组件贡献                            │
│  上线闸门: Pass@1↑ + First-repair↑ + regret↓ + ...   │
└───────────────────────┬─────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────┐
│  周期蒸馏与刷新                                       │
│  重算mode regret → 稳定高Reward最短轨迹蒸馏回SFT      │
│  删除冗余thinking标签 → 保持部分原始DIRECT防遗忘      │
│  模型能力提升后 → 原需THINK的状态可能变DIRECT         │
│  → Gate边界必须用当前checkpoint的rollout周期重算      │
└─────────────────────────────────────────────────────┘

整个方案的设计哲学:

  1. SFT 教"会做",RL 教"选对"——SFT 让三个模式分支都具备非零能力,RL 通过同状态真实反事实学习当前模型的模式决策边界。
  2. 先正确性,后成本效率——R1/R2/R3 顺序不能反转,否则 5000 条 DIRECT 先验 + 早期成本惩罚必然导致永远 DIRECT。
  3. 用 mode regret 而非 THINK 占比衡量成败——Auto-thinking 的目标不是"让模型多思考",而是"在思考确实有边际收益时才思考,其余时候直接做"。

附录:Auto-Thinking 原始文档全文

以下为《多维表格 CodeAgent:Auto-Thinking 的 SFT 与 RL 完整训练方案》原始文档全文,作者王哲,2026.07.30。

0. 结论先行

推荐采用逐 ReAct turn 的三档自适应策略:

DIRECT
  不输出 thinking,直接调用工具、生成/修改代码或结束

THINK_SHORT
  输出一段 64~128 tokens 的自然语言决策说明,硬上限 160 tokens
  然后执行一次高置信度动作

REPLAN
  原方案的核心假设已经失效时,输出 128~192 tokens 的重规划
  硬上限 256 tokens,然后按新计划执行

已有 5,000 条 DIRECT 时,不应再按"5,000 条总 SFT"重新切分。建议在其上增量补充:

模式 建议数量 默认数量 默认总体占比 SFT 阶段的定位
DIRECT 已有 5,000 5,000 约 85.5% 主能力、Pass@1 与"不必思考"的强先验
THINK_SHORT 新增 600~800 700 约 12.0% 冷启动错误归因、一次修复和短决策接口
REPLAN 新增 100~200 150 约 2.6% 冷启动方案失效识别、回滚和重规划能力

默认总量为 5,850 条,约为:DIRECT / THINK_SHORT / REPLAN = 85.5% / 12.0% / 2.6%

此外构建 300~500 个同状态模式比较样本,作为轻量 Gate warm-start。这些状态可从上述轨迹派生,不一定增加新的用户 query。

SFT 的任务是让三个分支在被强制选择时都具备可用能力,并让 Gate 不至于从零开始;它不负责规定线上最终模式比例。真正的 Auto-thinking 主要由 RL 在同一状态比较不同模式的真实正确性和成本后学习。随着模型能力提高,原来需要 THINK_SHORT 的状态会逐渐变成 DIRECT,因此 Gate 决策边界必须用当前 checkpoint 的真实 rollout 周期性重算。

推荐训练顺序:

① DIRECT 基础能力:使用已有 5,000 条数据建立 Pass@1 主能力
② 模式能力冷启动:新增少量 Short-thinking/Replan,强制 mode,Gate loss=0
③ Gate 轻量 warm-start:仅用 300~500 个高信息状态避免 RL 初始零探索
④ 多轮在线 RL:同状态强制模式探索,学习真正的 Auto-thinking 边界
⑤ Pareto 压缩与周期刷新:正确性稳定后优化成本,让更多状态回归 DIRECT

最重要的六条原则:

  1. <thinking> 应是简短、自然且有证据的决策说明,不使用固定字段表单,也不是自由发挥的长篇思考。
  2. 错误 action 和工具 observation 作为上下文保留,但在 SFT 中 loss mask=0;从正确的恢复判断开始训练 recovery suffix。
  3. mask=0 只是"不模仿错误",不会主动抑制重复;同状态偏好数据或 RL 才能教会模型"不要再这么做"。
  4. 高阶模型负责标注、纠错、压缩和生成候选,基模负责产生真实失败状态,真实环境负责最终判真。
  5. Reward 必须按"安全与数据完整性 > 功能正确 > 无回归 > 有效进展 > 成本"排序;不能用省 token、少工具调用换取错误答案。
  6. SFT 只冷启动模式能力和最小 Gate 探索,Auto-thinking 的主要训练责任放在同状态反事实 RL。

1. 训练目标与评测口径

1.1 目标函数不是"少思考",而是"以最低总代价正确完成"

把一次轨迹的效用写成:

U(τ)=Rcorrect−Cregression−λtCtool−λzCthinking−λwCwalltime−λrCrepeatU(\tau) = R_{\text{correct}} - C_{\text{regression}} - \lambda_t C_{\text{tool}} - \lambda_z C_{\text{thinking}} - \lambda_w C_{\text{walltime}} - \lambda_r C_{\text{repeat}}

优化优先级应是字典序,而不是简单把所有项等价相加:

安全、权限与数据完整性
> 任务功能正确
> 无回归
> 一次恢复成功
> 少重复、少工具调用、低时延、短 thinking

原因很简单:一次 64-token 的短 thinking 如果能避免一次昂贵的构建和两轮错误修复,总成本反而更低。只惩罚 thinking token 会把 Gate 推向永远 DIRECT;只奖励成功又会把 Gate 推向永远 THINK 或 REPLAN。

1.2 核心指标

不要只看最终成功率。至少同时看以下指标:

指标 定义
Pass@1 / First-pass success 第一次完整产物提交后直接通过全部验收
First-repair success 第一次失败后,仅允许一次修复时的成功率
Conditional recovery 首次失败条件下最终恢复成功率
Median recovery turns 成功恢复所需的中位修复 turn 数
Semantic repeat rate 状态未变化、动作语义重复且无新增信息的比例
Noisy-feedback overreaction 环境噪声或存量错误导致无关代码修改的比例
Premature-stop rate 未完成或未验证就输出 done 的比例
Regression rate 目标需求通过但破坏已有表、字段、视图、公式或数据的比例
Unnecessary-thinking rate DIRECT 足够成功但 Gate 选择 THINK/REPLAN 的比例
Thinking-necessity recall THINK/REPLAN 明显优于 DIRECT 时,Gate 选择非 DIRECT 的比例
Replan precision 选择 REPLAN 的状态中,确实存在核心假设失效的比例
Mode regret 同状态最优模式效用减去 Gate 所选模式效用
Success cost 每次成功的 thinking tokens、工具次数、执行时延和计算成本

其中:ModeRegret(s)=max⁡mU(s,m)−U(s,m^)\text{ModeRegret}(s) = \max_m U(s,m) - U(s,\hat m)

ModeRegret 是判断 auto-thinking 是否真的学会的核心指标。仅看线上 THINK 占比没有意义:10% 可能过多,也可能远远不够。

1.3 建议的离线验收目标

Pass@1:相对基线显著提升
First-repair success:相对基线提升幅度高于最终成功率提升
Semantic repeat rate:下降 30% 以上
Unnecessary-thinking rate:控制在 10%~15% 以内
Thinking-necessity recall:达到 85%~90%
Replan precision:达到 70%~80%
成功轨迹的工具调用 P50:不高于基线

真正上线前,应按 query 类型、表规模、修改对象、错误类型分别报表,避免整体均值掩盖局部模式塌缩。


2. 为什么"短思考链 + RL"通常优于"直接代码 + RL"

2.1 直接代码 RL 的学习信号过于稀疏

不带显式 thinking 时,策略近似为 πθ(a∣s)\pi_\theta(a \mid s)。s 是用户需求、当前多维表格状态、代码和工具反馈,a 是一整段代码或工具动作。若只有终局 Reward:

J(θ)=Ea∼πθ(⋅∣s)[R(s,a)]J(\theta)=\mathbb{E}_{a\sim\pi_\theta(\cdot|s)}[R(s,a)]

一次失败会把相似的负 advantage 分配给长代码中的大量 token,但 Reward 并不明确告诉模型:是理解错了用户需求、是表结构设计错了、是字段 ID 或类型用错了、是公式依赖关系不对、是工具反馈与当前修改无关,还是仅仅漏了一次必要验证。

模型仍然可能通过直接 RL 提升能力,因此"无 thinking 的 RL 只是对齐"并不完全准确;但在动作空间很大、终局反馈稀疏、多轮状态不断变化的 CodeAgent 中,它更容易学到局部输出偏好,而不是可迁移的错误归因和恢复策略。

2.2 短 thinking 把大动作分解成可学习的中间变量

引入模式 m、短决策变量z 和动作a:

πθ(m,z,a∣s)=πg(m∣s) πz(z∣s,m) πa(a∣s,m,z)\pi_\theta(m,z,a\mid s) =\pi_g(m\mid s)\, \pi_z(z\mid s,m)\, \pi_a(a\mid s,m,z)

其中:m:DIRECT、THINK_SHORT 或 REPLAN;z:一段短自然语言决策说明;a:实际代码修改或工具调用。

边缘化后仍然能表达直接策略:π(a∣s)=∑m,zπg(m∣s)πz(z∣s,m)πa(a∣s,m,z)\pi(a\mid s)=\sum_{m,z}\pi_g(m\mid s)\pi_z(z\mid s,m)\pi_a(a\mid s,m,z)

虽然 z 的表面形式是自然语言,它仍可以承载稳定的决策语义,并带来三个额外价值。

第一,很多表面不同的错误可以映射到同一可迁移类别。例如字段不存在、公式引用旧字段名、自动化 action 引用了被替换字段,都可能归结为同一类 schema_reference / last_diff / repair_reference。这相当于在高维代码空间中增加了一个低维的故障与决策表示,降低学习难度。

第二,z 提供了可验证的 RL 支撑点。即使没有固定字段,仍可通过语义评估判断:attribution 是否与 baseline、rollback 或 diff 证据一致;decision 是否与实际 action 一致;expect 是否被下一次 observation 证实;预测被证伪后是否重新归因。

第三,z 改善多轮 credit assignment。ReAct 本质上是 MDP;如果把整条轨迹视为一个 bandit 输出,最终成功或失败很难归因到具体 turn。

2.3 从数据密度看:一条轨迹不再只有一个终局标签

直接 RL 的一条失败轨迹通常只有 terminal_success = 0。带短 thinking 后,可以在离线侧得到一组相对可靠的过程标签:

error_type_correct
attribution_correct
decision_action_consistent
expected_observation_match
state_progress
terminal_success

这不意味着可以随意制造 dense reward;错误的过程奖励会引导 reward hacking。但当这些标签能被真实状态、真实工具结果或因果回放验证时,它们能显著增加有效训练信号。

这里应明确区分两层:

模型可见输出:自然语言 <thinking>,不出现固定字段名
离线标注与 Reward:可保留 error_type、attribution、decision、expected_effect 等结构化 metadata

2.4 类比:终验、工单与资深工程师

直接代码 RL:施工队只在整栋房子完工后收到"合格/不合格",能改进,但很难知道是图纸、材料还是施工顺序出了问题
固定长思考 RL:每拧一颗螺丝都写一份长报告,信息冗余、成本高,还可能事后编故事
Auto-thinking RL:简单工作直接做;遇到异常时填一张短工单:故障、归属、证据、动作、预期;发现图纸本身错了才重新出图

短 thinking 的价值不是"写得更多",而是给 RL 一个能够发力的决策接口。Auto-thinking 则让这个接口只在边际收益为正时出现。

2.5 必须保留的边界:thinking 不是天然可信

显式思考可能是事后合理化,也可能与真实决策因果无关。因此不能仅奖励"thinking 看起来合理"。必须同时检查 observation → evidence/attribution → decision → action → next observation,并做置空、置换和 decision 干预实验。若删除或改变 thinking 后 action 基本不变,说明该 thinking 很可能只是装饰。


3. 最终 Auto-Thinking 架构

3.1 Gate 必须逐 turn 决策

Auto-thinking 不是在任务开始时只决定一次"整条轨迹是否思考",而是在每个 ReAct turn 根据新状态重新选择。

推荐用三个显式 reasoning-mode token 作为 Gate 输出:

<|mode_direct|>
<|mode_think_short|>
<|mode_replan|>

更准确的名字是 reasoning-mode token。它是模型内部的一 token 元推理决策,不是 tool call,也不是让 serving 启动不同外部工作流的控制命令。整个过程仍是一次连续的自回归生成:

当前状态 s_t
→ 模型生成 mode token m_t
→ m_t 保留在模型上下文和 KV cache 中
→ 模型继续生成自然语言 thinking、action 或 tool call

例如:

<|mode_direct|>
<tool_call>...</tool_call>

<|mode_think_short|>
<thinking>自然语言短判断</thinking>
<tool_call>...</tool_call>

<|mode_replan|>
<thinking>自然语言重规划</thinking>
<tool_call>...</tool_call>

Serving 只需缓存并剥离第一个 mode token,不把它返回给用户;该 token 仍然参与后续生成的条件上下文。THINK_SHORT 和 REPLAN 的内容可由 reasoning parser 放入 reasoning.content,工具调用和最终答复仍进入正常通道。

Gate token 是否必需

Auto-thinking 没有显式 Gate token 也能工作。模型可以直接学习:第一个输出是 tool call → 隐式 DIRECT;第一个输出是 <thinking> → 隐式 THINK。此时策略是 π(y|s),输出的第一个普通 token 隐式承担 Gate。

加入显式 mode token 后,策略更容易分解为 π(m,y∣s)=πg(m∣s)π(y∣s,m)\pi(m,y\mid s)=\pi_g(m\mid s)\pi(y\mid s,m)。它不会凭空增加推理能力,但会把"是否思考、采用何种深度"和"具体思考内容"分开,从而带来:

  • 可单独提取 DIRECT、THINK_SHORT、REPLAN 的概率和 logprob
  • 可对 mode token 单独设置 SFT loss、RL advantage、KL 和熵约束
  • 可直接统计模式分布、mode regret 和模式塌缩
  • 可对同一状态强制不同模式做反事实评测
  • THINK_SHORT 与 REPLAN 不依赖事后分析自然语言才能区分
  • thinking 内容仍可保持自然、灵活,不受 mode token 格式限制

推理成本与可见性

显式 Gate 通常每个 ReAct turn 只增加一个 token 和一次 decode step。相对于 64~128 tokens 的 THINK_SHORT、工具执行、编译和 Judge 检查,这个成本通常很小,但不能视为严格为零。

Gate token 是"模型产生、模型继续消费、系统隐藏"的内部 token:用户和正常 API content 不应看到它;训练 trace、RL rollout 和可观测日志应保留它;流式输出应先缓冲首 token,解析完成后再向客户端发送;DIRECT 通常不返回空的 reasoning.content。

建议增加一个确定性的 runtime availability mask:

全新任务首 turn:通常只开放 DIRECT / THINK_SHORT
已有历史方案或失败 observation:开放 DIRECT / THINK_SHORT / REPLAN
纯环境 timeout、权限不足或依赖不可用:通常屏蔽 REPLAN,避免把环境问题误判成方案问题

这不是外部链路路由,也不是代替 Gate,而是只在首 token 位置把明显不合法的模式 logit 屏蔽。

3.2 三种模式的精确定义

DIRECT

适用条件:需求清晰且是熟悉、局部、低风险的操作;工具反馈唯一对应一个机械修复;已有充分证据,不需要新增假设;验证通过后应直接停止;环境错误有确定的重试或切换 scoped check 动作;思考不会改变下一动作。

DIRECT 不等于不看上下文,也不等于不验证。它只是"不生成显式 thinking token"。

THINK_SHORT

适用条件:工具反馈需要区分 last_diff / baseline / environment / unknown;有两个以上局部候选解释,但原方案仍基本成立;Judge 指出产物不符合需求,需要定位遗漏的验收条件;第一次相关失败出现,需要在继续修复、回滚、重试或停止中选择;一段短归因能够显著降低下一动作出错概率。

不推荐固定字段或固定句式。THINK_SHORT 通常用 1~3 句自然语言说明:当前反馈最可能说明什么,必要时指出它来自当前修改、baseline 还是环境;为什么选择下一动作,而不是其他明显候选;如果有助于验证,说明下一次检查应看到什么变化。

低价值反例是只有空泛结论,例如"检查失败了,我需要修复并验证",因为它没有使用当前反馈,也不能约束下一动作。

REPLAN

适用条件:observation 证伪了当前方案的核心假设;连续修复没有带来状态进展,且原因不是环境噪声;原数据模型无法满足联表、汇总、公式或自动化约束;需要跨表、字段、视图和自动化重新安排依赖顺序;当前 diff 不断扩张,继续局部补丁的预期成本高于回滚重做;用户意图被根本误解。

REPLAN 同样使用自然语言,不输出字段清单。它通常用一个短段落说明:哪条核心假设已经站不住、哪些现有成果仍应保留、方案应如何改变,以及先验证哪一步。

REPLAN 不是"更长的 THINK_SHORT",而是方案边界发生变化。默认每条训练轨迹最多一次 REPLAN;再次 REPLAN 通常说明任务、工具环境或数据质量需要人工审查。

3.3 THINK_SHORT 与 REPLAN 的核心区别

最实用的判断问题:在不改变对用户目标、数据模型和主要实现路径的理解时,能否通过一个局部动作取得可验证进展?

能,而且下一动作已经唯一明确 → DIRECT
能,但需要先消除局部歧义、判断错误归因或选择修复动作 → THINK_SHORT
不能;反馈已经推翻核心假设,继续局部修改不会解决根因 → REPLAN
维度 THINK_SHORT REPLAN
核心方案 仍然成立 已被证伪或已明显不经济
主要问题 局部诊断、归因或动作选择不确定 用户目标、数据模型、依赖关系或实现路径存在根本错误
改动范围 通常是一个局部对象或相邻依赖 通常跨多个对象、阶段或依赖关系
对已有修改的态度 大部分保留,只修正局部问题 明确保留可信部分,并回滚或替换失效部分
thinking 的任务 解释"为什么下一步这样修" 解释"为什么原路走不通,以及新路径是什么"
下一步动作 一个高置信度 repair、retry、verify 或 rollback 新计划中的第一个可验证里程碑
典型 token 预算 64~128,硬上限 160 128~192,硬上限 256
使用频率 少量但可重复出现 稀有,普通轨迹通常最多一次

不要用以下表面信号直接触发 REPLAN:日志很长;错误数量很多;已经失败过一次;THINK_SHORT 接近 160 tokens;任务本身看起来复杂。

两个典型边界:

"高风险客户"视图当前使用 >=0,且漏了风险等级 → 数据模型和目标都成立,只需修筛选条件:THINK_SHORT
用客户名文本模拟订单到客户的一对多关系,导致无法可靠汇总 → 核心数据模型不成立,需要建立真实关联:REPLAN

训练和评测时,不应把"第 N 次失败"写成 REPLAN 的硬规则。更可靠的触发条件是:新的 observation 是否证伪了当前核心假设 + 局部修复是否无法产生与目标相关的状态进展 + 新方案的预期收益是否明显高于继续打补丁。

3.4 状态输入要先去噪

Gate 不应直接吞入无限增长的原始日志。建议在每个 turn 构造短状态摘要:

{
  "user_goal": "...",
  "acceptance_criteria": ["..."],
  "current_artifact": "...",
  "last_diff_summary": "...",
  "last_action": "...",
  "observation_digest": {
    "kind": "compile_error",
    "primary_error": "...",
    "location": "...",
    "baseline_present": false
  },
  "trusted_facts": ["..."],
  "failed_hypotheses": ["..."],
  "progress_since_last_turn": true
}

原始工具日志仍可供 action 分支按需读取,但 Gate 和 short-thinking 优先使用结构化 digest,避免被级联错误、无关 warning 和长日志带偏。

3.5 <thinking> 与reasoning.content

<thinking> 只是训练和生成 token,不会因为名字叫 thinking 就自动进入 API 的reasoning.content。需要同时满足:训练与推理使用一致的 chat template 和特殊 token;Serving 配置匹配的 reasoning parser;parser 能分别抽取 THINK_SHORT、REPLAN、tool call 和最终 content;截断、流式输出和未闭合标签有明确处理策略。

如果基座和 serving 已原生支持 <think>...</think>,优先沿用其格式;若使用自定义<thinking>,必须实现对应 parser。Loss mask 决定"哪些生成 token 训练",parser 决定"推理输出被路由到哪个 API 字段",两者是不同层的问题。


4. 已有 5,000 条 DIRECT 后的增量 SFT 构成

4.1 默认配比

以下配额假设已有 5,000 条 DIRECT 可用于训练。若它们包含验证和测试数据,应按语义簇做 80/10/10 切分,并同步缩放新增数据;最终测试集不得由同一 query 模板、同一 Base 快照或同一用户任务的改写版本泄漏进入训练集。

DIRECT:已有 5,000 条

不需要为了满足新比例删除已有 DIRECT。需要审计的是它们是否过度集中在"首次生成直接成功"。建议确保其中至少 300~500 条是 post-feedback DIRECT:

子类 建议覆盖 说明
直接机械修复 200~300 字段名、参数、唯一类型错误等,反馈后仍不输出 thinking
直接验证、重试或停止 100~200 确定性 scoped retry、验证成功后 done、环境问题不改代码

这部分非常重要。否则模型容易学成:没有 error → DIRECT;一旦出现 error/check → THINK_SHORT。正确策略应是判断显式 thinking 是否会改变下一动作。DIRECT 占绝对多数,是为了明确告诉模型:最理想的行为仍是首次做对,而不是先制造错误再展示恢复能力。

THINK_SHORT:新增 600~800 条,默认 700 条

子类 数量 说明
编译、类型、API 与 schema 归因 220 区分 last diff、baseline 和环境问题
Judge/Check 功能错误修复 280 需求遗漏、公式、视图、自动化和关联关系错误
初始高风险决策 80 多约束状态下,一段短决策能明显提高 Pass@1
噪声、不反应与正确停止 120 学会不被无关错误带偏

约 80%~90% 的 THINK_SHORT 应放在真实反馈后的恢复状态,仅保留少量初始高风险状态。它在 SFT 阶段的目标是让模型学会短 thinking 协议和基本恢复能力,而不是把"先 thinking"训练成默认策略。

REPLAN:新增 100~200 条,默认 150 条

子类 数量 说明
数据模型或依赖关系重构 70 文本字段应改为关联字段,汇总/公式依赖需重建
用户意图或验收条件误解 35 产物形式完成但业务目标不成立
多次局部修复无进展 30 证据支持停止打补丁并回滚
修改范围失控或回归 15 需要缩小范围、恢复稳定基线

REPLAN 数据应少而精,只需保证强制进入该模式时模型具有非零、稳定的方案级恢复能力。高比例 REPLAN 会让模型把"写计划"误学成解决问题本身。

默认原始轨迹总量:

类型 数量 总体占比
DIRECT 5,000 85.5%
THINK_SHORT 700 12.0%
REPLAN 150 2.6%
合计 5,850 100%

如果基座已经具备较好的 reasoning 和工具能力,可以从 5,000 + 500 + 100 的更小冷启动开始;如果强制模式评测未达到最低能力门槛,再补数据,而不是预先堆高 THINK_SHORT/REPLAN 比例。

4.2 训练单位不要混淆

建议把"一条轨迹"和"一个 assistant target turn"分开统计:

trajectory_count:用于控制场景与模式覆盖
target_turn_count:用于计算实际训练曝光
token_count:用于防止长 thinking 获得过量梯度

多轮 REPLAN 轨迹天然包含更多 assistant token。如果直接做全局 token mean,即使原始轨迹只占约 2%~4%,也可能获得远高于其样本比例的梯度。建议先在每个 assistant turn 内做 token mean,再按 turn 权重聚合:

LSFT=mean⁡t[wt mean⁡i∈t(Mi CEi)]L_{\text{SFT}} =\operatorname{mean}_{t} \left[ w_t\, \operatorname{mean}_{i\in t} \bigl(M_i\,\mathrm{CE}_i\bigr) \right]

4.3 数据切分与线上分布

至少按以下 key 做 group split:用户 query 的语义簇、Base/schema 快照 hash、需求模板、字段和视图拓扑、同一失败状态的不同 teacher 改写。避免同一个任务的 DIRECT、THINK_SHORT 和 REPLAN 三个版本分别进入训练、验证和测试。

SFT 原始比例不必机械等于线上错误分布。建议:DIRECT 保持较高先验,服务 Pass@1;THINK_SHORT 按线上高频且可恢复错误上采样;REPLAN 覆盖高损失长尾,但不按 token 数过度曝光;对非常容易和完全不可解的样本降采样;对"基模有时成功、有时失败"的边界样本重点保留,因为它们对 Gate 最有信息量。


5. SFT 轨迹如何判断 DIRECT、THINK_SHORT 与 REPLAN

5.1 最可靠的方法:同一状态的反事实模式比较

不要仅靠"任务看起来难"打标签。先根据 runtime availability mask 得到状态 s 的合法模式集合M(s),再从同一个精确快照强制运行每个合法模式:

restore(s) → force DIRECT      → 执行并评分
restore(s) → force THINK_SHORT → 执行并评分
restore(s) → force REPLAN      → 仅在已有方案被反馈挑战时执行并评分

全新任务通常只比较 DIRECT 与 THINK_SHORT;出现真实失败反馈、接手已有失败方案或核心假设可能失效时才开放 REPLAN。每个合法模式最好采样 2~4 次,以减少温度和工具波动造成的偶然性。按真实环境结果计算效用U(s,m)。

标签规则:

  1. DIRECT 成功,且与最优模式效用差不超过 δ → label = DIRECT
  2. THINK_SHORT 相比 DIRECT 显著提升正确性或一次修复率,且原方案不需要重做 → label = THINK_SHORT
  3. 核心假设已被证伪,REPLAN 的真实结果最好 → label = REPLAN
  4. 所有合法模式全部失败,或结果差异落在噪声范围内 → Gate loss mask = 0,样本可用于分支能力训练或后续 RL,不强行教 Gate

"显著提升"应先比较正确性,再比较成本。不要把 δ 只定义成 token 数;推荐用分层效用或 bootstrap 置信区间。

5.2 低成本启发式预标注

状态 推荐模式
单一明确的字段名、参数或类型修复 DIRECT
已验证成功,应停止 DIRECT
确定性的 scoped retry,不涉及代码改动 DIRECT
第一次相关错误,需要判断是否来自 last diff THINK_SHORT
Judge 指出一个需求未满足,但整体方案成立 THINK_SHORT
两个局部候选都合理,需要证据选择 THINK_SHORT
中心数据模型被证伪 REPLAN
相同假设连续失败且状态无进展 REPLAN
修改范围持续扩大并引入回归 REPLAN
环境 timeout、权限或依赖不可用 DIRECT retry/stop;不是 REPLAN

5.3 轨迹示例一:首次 DIRECT

用户需求:在"订单"表新增"是否逾期"公式字段:状态不是"已完成"且截止日期早于今天时返回 true。

可见 schema 已明确给出字段 ID 和类型,生成动作唯一:

assistant:
<|mode_direct|>
<tool_call>
create_formula_field(
  table="订单",
  name="是否逾期",
  formula="AND({状态}!=\"已完成\", {截止日期}<TODAY())"
)
</tool_call>

这里添加 thinking 只会复述需求,不会改变动作。

5.4 轨迹示例二:修复仍然 DIRECT

工具反馈:

compile_error:
unknown field "customer_name"
available field: "customer"
location: build_order_view.ts:42

当前 diff 只把字段引用误写为 customer_name,没有其他候选解释:

assistant:
<|mode_direct|>
<tool_call>
replace_field_reference(
  file="build_order_view.ts",
  from="customer_name",
  to="customer"
)
</tool_call>

这是 recovery,但不需要显式 thinking。把所有 repair 都标成 THINK_SHORT 会训练出"遇错必思考"的坏先验。

5.5 轨迹示例三:THINK_SHORT 一次修复

工具反馈:

artifact_check_failed:
"高风险客户"视图包含了已结清客户。
当前过滤条件使用"剩余金额 >= 0"。
验收要求:剩余金额 > 0 且风险等级为"高"。

训练 target:

assistant:
<|mode_think_short|>
<thinking>
问题出在刚修改的筛选条件:`>= 0` 会把剩余金额为 0 的已结清客户也选进来,而且遗漏了风险等级约束。把条件改为"剩余金额大于 0 且风险等级为高"后重新检查,已结清客户应该从这个视图中消失。
</thinking>
<tool_call>
update_view_filter(
  view="高风险客户",
  condition="AND({剩余金额}>0, {风险等级}=\"高\")"
)
</tool_call>

下一次真实 Check 既验证代码,也验证 thinking 中对结果的预期。如果已结清客户仍存在,下一 turn 必须更新判断,不能原样重复这个 thinking。

5.6 轨迹示例四:噪声反馈下 THINK_SHORT

工具反馈:

dependency_timeout:
formula-engine unavailable before source compilation

训练 target:

assistant:
<|mode_think_short|>
<thinking>
这次失败发生在进入源码编译之前,日志也没有指向当前改动,更像是公式引擎超时。先对目标检查做一次 scoped retry;如果仍返回同一基础设施错误,就停止改代码并上报环境问题。
</thinking>
<tool_call>
run_scoped_check(target="formula-field", retry=1)
</tool_call>

如果环境错误的识别完全确定,也可以将这类样本标成 DIRECT retry。只有在归因确实存在歧义时才使用 THINK_SHORT。

5.7 轨迹示例五:REPLAN

用户要求:按客户汇总所有订单金额,并在客户表展示订单数和总金额。

原方案把客户名复制成普通文本字段,然后尝试在客户表直接做公式汇总。Judge 反馈:

artifact_check_failed:
客户表无法稳定关联同名客户的多条订单;
当前结构不支持跨表汇总与去重。

训练 target:

assistant:
<|mode_replan|>
<thinking>
当前方案把客户名当成普通文本键,无法稳定表达订单到客户的一对多关系,同名客户也会破坏汇总结果,因此继续修改文本公式解决不了根因。保留订单表、客户表和原始数据,撤销未生效的文本汇总,先建立订单到客户的关联并验证一条记录,再在客户表上创建订单数和金额汇总。
</thinking>
<tool_call>
create_relation_field(
  from_table="订单",
  to_table="客户",
  name="所属客户"
)
</tool_call>

这里继续修改文本公式属于局部打补丁,无法修复数据模型根因,因此 REPLAN 合理。


6. Recovery SFT 与 Loss Mask

6.1 Recovery suffix 从"正确恢复判断"开始

推荐 mask:

基模生成的错误代码或错误 tool call       mask=0
真实编译、执行或 Judge observation      mask=0
错误类别和因果归因                     mask=1
repair / rollback / retry / replan 决策 mask=1
修复代码或工具动作                     mask=1
必要验证                               mask=1
验证后的 stop/done                     mask=1

也就是说,recovery suffix 不只是"重写代码的 assistant 权重不为 0",而是从失败反馈后的第一个正确恢复判断开始。否则模型只能学到"看到某个报错就改代码",学不到:是否应对这个报错负责;报错是不是 baseline 已存在;应修复、回滚、重试还是停止;修复后应验证什么;什么时候不应继续 ReAct。

6.2 错误前缀为什么要保留

错误 action 和真实 observation 仍应放在输入上下文中,因为恢复策略需要看到模型是如何走到失败状态的。但它们不能作为 imitation target。

需要注意:mask=0 = 不模仿,mask=0 ≠ 负监督。若要压制重复动作、盲改、过度扩大范围或提前结束,应为相同状态构造 chosen/rejected:

chosen: 检查 baseline,确认错误与当前 diff 无关,然后运行目标 scoped check
rejected: 根据无关日志继续修改另一个模块

可使用 DPO、ranking loss、unlikelihood 或在线 RL。chosen 和 rejected 必须来自同一精确状态,不能拿两个难度不同的任务直接比较。

6.3 推荐 SFT loss

LSFT=λgLgate+λzLthinking+λaLaction+λpLpreferenceL_{\text{SFT}} = \lambda_g L_{\text{gate}} + \lambda_z L_{\text{thinking}} + \lambda_a L_{\text{action}} + \lambda_p L_{\text{preference}}

第一版建议:

action/tool token:1.0
自然语言 thinking span:0.4~0.7,按 span 或 turn 归一
可选的离线语义辅助 loss:0.1~0.3
正确验证和 done:1.0~1.3
错误 action、tool observation、冗余 thinking:0

自然语言 thinking 不再按 type/evidence/decision/expect 等字段切分 token 权重,也不使用字段是否出现作为监督目标。离线 metadata 可以训练低权重的错误归因或动作分类辅助任务,但这些标签不进入可见 thinking。应使用 span-normalized 或 turn-normalized loss,避免较长的自然语言说明获得比工具 action 更大的总梯度。


7. SFT 训练顺序:冷启动能力,不替代 RL

7.1 阶段 S1:模式分支能力冷启动

目的:保留已有 DIRECT 主能力,并确保 THINK_SHORT、REPLAN 被强制选择时都"会做事"。

做法:

  • 使用已有 5,000 条 DIRECT,并混入新增的 600~800 条 THINK_SHORT、100~200 条 REPLAN
  • 如果 5,000 条 DIRECT 已经训练进当前 checkpoint,不必从头完整重训;在增量 SFT 中按场景分层回放 DIRECT,维持下面的有效 batch 占比即可
  • 原始默认比例约为 85.5/12.0/2.6,有效 batch 可从 82/15/3 起步
  • 模式 token 由数据强制注入,gate token mask=0
  • 训练 DIRECT action、THINK_SHORT 的短思考与 action、REPLAN 与 action
  • recovery 样本使用前述 suffix mask
  • 使用 turn-normalized loss
  • 以 DIRECT Pass@1 无回退、强制模式能力和格式正确率早停

有效 batch 中可对少量 THINK_SHORT/REPLAN 做适度上采样,但不要改变 DIRECT 的强先验:

DIRECT       80%~85%,默认 82%
THINK_SHORT  12%~17%,默认 15%
REPLAN        2%~3%,默认 3%

这一步不让 Gate 自己选,是为了避免模型在 THINK/REPLAN 分支尚不会做时,Gate 因短期 Reward 永远逃回 DIRECT。它的完成条件不是固定 epoch,而是:

强制 THINK_SHORT:格式与 tool call 稳定;decision 与 action 一致;在 Think-necessary 集合上优于 forced DIRECT
强制 REPLAN:能指出失效假设;新 action 确实改变方案;在 Replan-necessary 集合上优于局部修复

达到门槛后,应转入 RL,而不是继续堆大量 thinking SFT。

7.2 阶段 S2:轻量 Gate warm-start

目的:只让 Gate 具备最小探索能力,避免 RL 初期 THINK_SHORT/REPLAN 触发概率接近零;不追求通过 SFT 学到最终决策边界。

数据:

  • 优先使用同状态、合法模式强制 rollout 的真实比较结果
  • 只需 300~500 个高信息状态,可从已有轨迹派生
  • 标签分布建议约为 65% DIRECT / 30% THINK_SHORT / 5% REPLAN
  • 加入 Direct-sufficient 与 Think-necessary 的边界状态,而不是只挑复杂任务
  • 不确定样本的 Gate loss 设为 0

训练:

只训练 mode token,后续 thinking/action loss=0
Gate loss 相对 S1 action loss:0.2~0.5
学习率:S1 的约 0.2~0.3 倍
短程训练;能保持模式探索且 mode-regret 不恶化即停止

这里的 65/30/5 只是 Gate 冷启动标签分布,不是线上目标分布。最终模式比例和动态决策边界由 RL 的真实执行结果决定。

7.3 阶段 S3:可选的联合小步 SFT

目的:让 Gate 输出、thinking 和 action 在自然生成条件下重新对齐。

做法:

  • 不再强制 mode token
  • 保持至少 80%~85% 的高质量 DIRECT 曝光
  • 使用 S1 约 0.2~0.3 倍学习率
  • update budget 不超过本轮 SFT 的约 10%,并严格早停
  • 监控 Gate 模式分布,防止突然偏向单一模式

如果 S2 后自然生成已经稳定,S3 可以跳过。SFT 到此只需提供可工作的三分支与最小 Gate 探索,不应继续拟合一个静态的"正确模式分类器"。

7.4 Gate warm-start 的关键不是标签数量,而是边界信息量

以下样本对 Gate 几乎没有帮助:

非常简单,所有合法模式都成功
非常困难,所有合法模式都失败
teacher 永远先想再做,缺少 DIRECT 对照
仅凭错误日志长度把样本标成 THINK

最有价值的是:

DIRECT 有时失败、THINK_SHORT 常能一次修好
THINK_SHORT 与 DIRECT 都成功,但 DIRECT 明显更便宜
THINK_SHORT 连续局部修复失败,而 REPLAN 能恢复
工具日志很长但其实是确定性环境错误,应 DIRECT

这些边界状态在 SFT 中只做轻量 warm-start;当前 checkpoint 上真正的模式效用比较,应留给在线 RL。

7.5 为什么 Auto-thinking 的关键必须放在 RL

Gate SFT 优化的是 Lgate-SFT=−log⁡πg(mteacher∣s)L_{\text{gate-SFT}} =-\log \pi_g(m_{\text{teacher}}\mid s)。它回答的是"teacher 在这个静态状态上标了什么模式"。即使标签来自真实执行,它仍然存在三个局限:

  1. 标签依赖生成它时的 checkpoint;模型变强后,原本需要 THINK_SHORT 的状态可能已经能 DIRECT。
  2. 单个模式标签不能持续表达正确性、工具成本、thinking 成本和时延之间的 Pareto 关系。
  3. teacher 容易把自己的思考习惯固化成 Gate 规则,例如"见 error 必 THINK"或"复杂需求必 REPLAN"。

RL 优化的是当前策略在真实环境中的效用:

Jgate-RL=Em∼πg(⋅∣s)[Rcorrect(s,m)−C(s,m)]J_{\text{gate-RL}} =\mathbb{E}_{m\sim\pi_g(\cdot|s)} \left[ R_{\text{correct}}(s,m)-C(s,m) \right]

通过同一状态下 forced DIRECT、forced THINK_SHORT、forced REPLAN 与 AUTO 的真实比较,RL 能直接回答"对于当前 checkpoint,哪个模式实际更好"。因此:

SFT:保证每个模式有非零能力和非零探索概率
RL:学习当前模型真正的模式决策边界

但不能完全跳过冷启动。如果 THINK_SHORT/REPLAN 分支从未被训练,强制 rollout 几乎总失败,RL 会把"分支能力不足"误认为"这个模式不该选",最终仍塌缩到 DIRECT。

7.6 Gate 训练的真正意义

Gate 训练不是让模型记住一个固定模式比例,也不是让它机械复现 teacher 的选择。它要学的是:对当前 checkpoint 和当前状态,哪种推理模式能以最低总代价获得正确结果?

具体包含三个目标:

目标 含义
Exploration support 三种合法模式具有非零概率,RL 能实际探索其结果
Decision boundary 识别 DIRECT 足够、THINK_SHORT 有增益、REPLAN 才能解决根因的状态边界
Cost calibration 正确性相同时偏向更便宜模式,思考有明显收益时允许支付额外成本

Gate 的训练信号应按阶段分开。

分支能力 SFT

mode token:由数据强制注入,loss mask=0
后续 thinking/action:loss mask=1

这一步训练的是条件策略 π(y|s,m):已知模式时,模型能否正确生成对应行为。虽然 mode token 本身不计算输出 CE,它仍作为后续 token 的上下文,通过后缀 loss 学到区分三种分支的 embedding。

Gate warm-start

mode token:loss mask=1
后续 thinking/action:loss mask=0

这一步训练 π_g(m|s) 的最小初始边界,使 THINK_SHORT 和 REPLAN 不会在 RL 开始时概率接近零。它只负责冷启动,不承担最终 Auto-thinking 学习。

Gate RL

AUTO rollout 中,mode token 由当前策略真实采样,可以直接接受 mode-level advantage:

Lgate-RL=−Ag(s,m)log⁡πg(m∣s)L_{\text{gate-RL}} =-A_g(s,m)\log\pi_g(m\mid s)

A_g 应来自同状态下不同模式的相对正确性和成本,而不是模式名称本身:

DIRECT 与 THINK_SHORT 都成功 → 正确性相同后,较便宜的 DIRECT advantage 更高
DIRECT 失败,THINK_SHORT 一次修好 → THINK_SHORT advantage 更高
局部修复均无进展,REPLAN 成功 → REPLAN advantage 更高

Forced-mode rollout 的 on-policy 边界

人为注入 <|mode_think_short|> 或<|mode_replan|> 时,这个 mode token 不是从当前π_g 自然采样得到的,因此不能不加处理地作为普通 on-policy GRPO 样本更新 Gate。

推荐分工:

AUTO rollout:mode 来自当前 policy → 直接更新 Gate、thinking 和 action
forced-mode rollout:mode 由训练系统指定 → 估计模式反事实效用、训练给定模式后的条件分支、构造 Gate 的 CE/DPO/preference 辅助信号、默认不直接计算普通 on-policy Gate gradient

如果训练框架能记录行为策略概率并正确做 importance correction,也可以让 forced rollout 参与 Gate policy gradient;第一版不建议为了这一点增加过多算法复杂度。

Gate 是否训练成功

不要用"线上 THINK 占比接近某个目标值"判断。应看:mode regret 是否下降;Think-necessary 状态的召回率是否提高;Direct-sufficient 状态的不必要 thinking 是否下降;Replan precision 是否提高;Pass@1 与 First-repair success 是否同时改善;在相同成功率下,thinking tokens、工具调用和时延是否下降;Gate entropy 是否保持在可探索但不随机的合理区间。

因此,Gate token 的价值可以概括为:几乎不增加序列长度,却为 Auto-thinking 提供了一个可以单独监督、单独强化、单独干预和单独评测的元推理支点。


8. 如何使用更强的高阶模型构建轨迹

8.1 最合理的分工

推荐公式:

基模 / 当前 checkpoint:产生真实状态分布
高阶模型:定位偏离、生成候选、压缩 thinking、构造反事实
真实环境:执行、验证和判真

高阶模型适合担任:

  1. 轨迹编辑器:标记 keep / mask / replace / truncate
  2. 首次偏离定位器:找出错误开始传播的 turn
  3. 恢复专家:从基模真实失败状态生成最小 recovery
  4. thinking 压缩器:将长推理改写为预算内、语义有效的自然语言短段落
  5. 反事实候选生成器:为同一状态生成 DIRECT、THINK_SHORT、REPLAN
  6. Rubric 生成器:将用户 query 转换为可执行的验收 checklist
  7. Judge 审核器:发现 JudgeRewardModel 未覆盖的失败模式

它不应:独立生成绝大多数完整轨迹;虚构工具 observation;同时成为唯一生成者和唯一裁判;把 gold 代码、隐藏测试或不可见信息写入学生 thinking;将自己的长 CoT 原样蒸馏给小模型。

8.2 双教师视角

Privileged Critic

可以看到参考产物、隐藏 Check、正确修改范围,用于:

{
  "first_bad_turn": 3,
  "invalidated_assumption": "客户名文本可作为稳定关联键",
  "required_milestones": [
    "建立订单到客户的关联",
    "基于关联创建汇总"
  ],
  "leakage_risk": false
}

这些信息只用于筛选、打标签和比较,不直接进入学生可见 target。

Blinded Actor

只能看到线上推理时可见的信息:用户 query、当前 Base/schema 与数据摘要、当前代码和 diff、已经真实返回的工具 observation。真正进入 SFT target 的 short-thinking、replan 和 action 由 Blinded Actor 生成,并在真实环境重放。

8.3 可落地的数据生产流水线

  1. 对每个任务用基模或当前 checkpoint 采样 4~8 条 rollout。
  2. 保存每个 assistant turn 前的可恢复环境快照与状态 fingerprint。
  3. 用高阶模型定位首次关键偏离、错误归因、重复动作和错误停止。
  4. 对高价值状态的每个合法模式生成 2~4 个候选。
  5. 从同一快照真实重放;所有 observation 必须来自工具。
  6. 按正确性、无回归、进展和成本选最短有效路径。
  7. 将 teacher 长 reasoning 压成 THINK_SHORT 或 REPLAN 格式。
  8. 产出四类视图:最短 clean-success、错误前缀 mask=0 的 recovery suffix、同状态 mode preference / chosen-rejected、噪声/停止/回滚和反 reward-hacking 样本。
  9. 进行硬过滤:工具格式合法、执行可重放、隐藏 Check 通过、无测试或 verifier 篡改、无数据破坏、无不可见信息泄漏、无状态不变的循环、thinking 未复制整段日志。

8.4 如何保证与学生分布一致

至少执行以下约束:

  • 状态来自基模和当前 checkpoint,而不是只来自高阶模型的干净轨迹
  • teacher 与 student 使用相同工具、相同可见上下文、相同 action schema
  • teacher 输出必须服从 student 的 160/256-token 预算
  • teacher 只生成候选,最终选择由真实环境和独立 verifier 决定
  • 每次模型能力有明显提升后重新收集 rollout,避免训练永远停留在旧失败分布
  • 按线上 error/query bucket 对齐采样,不用 teacher 喜好的题型替代真实流量
  • 保留一部分 student 自己成功的最短轨迹,避免语言风格完全 teacher 化
  • 高阶模型的置信度只能用于排序,不能当作真值

自然语言 thinking 还需要做表达去模板化:不固定句首,不要求每条都按"问题是—所以—预计"展开;同一语义可由不同 teacher 或不同提示生成少量自然改写;只保留与 observation 和 action 一致的版本;不为了语言多样性改变技术判断或加入无依据内容;结构化 error type、归因、decision 和预期结果只保存在离线 metadata。


9. THINK_SHORT 的 token 预算

9.1 推荐默认值

目标长度:64~128 tokens
P90:不超过 128 tokens
硬上限:160 tokens
实验上限:192 tokens,仅用于消融

REPLAN 目标:128~192 tokens
REPLAN 硬上限:256 tokens

"token"必须按实际基座 tokenizer 统计。中文、英文标识符、XML 标签和 JSON 的 tokenization 差异较大,不能用字符数替代。

9.2 160-token 硬上限为什么是合理起点

THINK_SHORT 通常只需要自然地表达以下语义中的必要部分:

基于反馈的诊断与必要证据   约 25~55 tokens
下一动作及选择理由         约 20~40 tokens
必要时的预期结果           约 15~30 tokens
对象名、公式与自然连接语   其余预算

这不是要求每条 thinking 机械包含三段内容,也不规定顺序。64~128 tokens 给模型足够空间完成有证据的自然语言判断,160-token cap 则为较长的中文字段名、公式、错误位置和必要理由留出余量,同时仍能限制:复制完整编译日志;重述全部历史;枚举大量未验证假设;在 action 前写一份新方案;用流畅叙事掩盖归因不确定性。

如果一个状态稳定需要超过 160 tokens 才能决定下一动作,它通常更适合 REPLAN,而不是把 THINK_SHORT 无限制拉长。THINK_SHORT 与 REPLAN 的区分仍应以"原方案是否失效"为主,而不是仅凭长度。

9.3 长度控制方式

不要在 160 tokens 处粗暴截断未闭合的 <thinking>。推荐:训练数据在入库前压缩到预算;为 </thinking> 提供明确 stop token;对超长但正确样本做 teacher 重写,而不是简单裁剪;RL 中仅在正确性相同或进展相同的 rollout 之间比较长度;thinking 未闭合或吞掉 tool call 时施加格式惩罚;独立记录 reasoning_tokens,不要与代码 tokens 混合惩罚。

9.4 必做预算消融

固定相同模型、任务、工具预算和 Reward,比较:DIRECT、THINK_SHORT cap=96、cap=128、cap=160、cap=192、长自由 CoT。按以下二维 Pareto 选择,而不是只看成功率:

First-repair success vs. thinking tokens + 工具调用 + wall time

默认选择 64~128 目标区间和 160 硬上限。若 160 相比 128 只增加输出长度、没有提升 First-repair success,可把生产 soft cap 收紧到 128;若 192 相比 160 有明显收益,应先检查这些样本是否实际属于 REPLAN,再决定是否扩容,避免把 THINK_SHORT 演化成长 CoT。


10. 线上 query 的 RL 数据工程

10.1 Query 入池

线上数据进入 RL 前需要:

  1. 脱敏和权限清洗:删除 token、个人信息、真实业务敏感值
  2. schema-preserving 匿名化:保留字段类型、依赖拓扑和错误结构
  3. 语义去重:相同模板、同一 Base 快照和重写 query 只保留代表样本
  4. 可执行快照:保存初始表结构、必要数据、工具版本与随机种子
  5. 固定验收条件:在 rollout 前生成并冻结 acceptance checklist
  6. 稳定性检查:同一正确产物重复运行 verifier 的结果应一致
  7. 可解性检查:工具权限、依赖和环境必须足以完成任务

Judge 的 rubric 必须在 rollout 前冻结。不能让 policy 在看到自己产物后改写验收标准。

10.2 RL prompt 采样建议

推荐按当前 checkpoint 的 group success rate 动态分桶:

桶 group success rate 样本用途与规模
Easy anchor > 0.9 少量保留,用于稳定 DIRECT 和防遗忘
Learning frontier 0.1~0.9 RL 主体,模式比较与 advantage 最有信息
All-fail < 0.1 送 teacher recovery、课程学习或 SFT,不直接大量 RL
Unstable verifier 波动高 暂停训练,修环境或 verifier

第一版 query mix 可从:

50% 当前模型的 learning-frontier 线上 query
25% 近期线上失败与多轮重复案例
15% 回归、权限、数据完整性和噪声边界案例
10% Easy DIRECT anchor

开始,再按分桶指标调整。

10.3 以"修复预算"约束一次修好

不要简单把整个 Agent 的工具预算设得极低。搭建复杂 Base 本身可能需要多个必要 action。建议单独定义:

initial_build_actions:完成首版产物所需的动作
repair_turns:第一次 Check 失败后的修复轮数

主要 RL 任务可设置:

  • 普通 recovery:最多 1 个 repair turn + 1 次最终验证
  • REPLAN bucket:最多 2 个 recovery action,且最多 1 次 REPLAN
  • 状态无变化的同类失败重复一次:提前终止并处罚

训练和评测都显式报告 First-repair success,才能真正推动"一次修对",而不是靠更长轨迹堆出最终成功率。


11. RL Reward 体系

11.1 Reward 层级

推荐优先使用分层排序:

Tier 0:安全、权限、数据完整性、是否篡改测试/verifier
Tier 1:可执行功能正确与用户验收
Tier 2:无回归、幂等性与无数据破坏
Tier 3:错误归因、有效进展、正确停止
Tier 4:模式、thinking、工具、时延成本

只有 Tier 0~3 相同或足够接近时,Tier 4 才决定优劣。

如果训练框架必须使用标量,可以从以下归一化模板开始:

R=+Rterminal+Rprocess−Rfailure−Rcost−RsafetyR = + R_{\text{terminal}} + R_{\text{process}} - R_{\text{failure}} - R_{\text{cost}} - R_{\text{safety}}

示例尺度:

R_terminal:0~10
  工具调用和产物格式合法          +0.5
  编译/构建通过                   +0.5
  隐藏功能与不变量 Check          +4.0
  Judge 需求满足                  +3.0
  无回归、数据保持和幂等          +2.0

R_process:整条轨迹最多 +2
  验证过的 milestone              +0.2~0.5
  可验证的正确 attribution        +0.2~0.4
  expect 与下一 observation 一致  +0.1~0.3

R_failure
  语义重复                         -0.5~-1.0
  无关范围扩张                     -0.5~-1.0
  未验证提前 done                  -1.0~-2.0
  制造新回归                       -2.0~-5.0

R_cost:整条成功轨迹通常不超过 -1
  额外工具调用、thinking token、wall time

R_safety
  篡改测试/verifier、越权删除、数据破坏  -20 并立即终止

具体数值必须通过 reward attribution 日志和消融校准。硬原则是:

成功 Reward > 所有效率惩罚的最大可能总和
功能正确 Reward > 编译通过和 Judge 文风 Reward
安全硬惩罚 > 所有正 Reward

11.2 现有两类 Reward 如何使用

编译/执行工具

适合作为高可信、低歧义 verifier,但不要只给"编译通过"高分。编译成功只是必要条件;空实现、删除功能或绕过逻辑也可能编译。可拆分为:tool-call schema validity、compile/build、目标功能执行、隐藏输入和边界输入、已有功能回归、重复执行的幂等性。

JudgeRewardModel

适合判断开放式需求是否满足:表、字段和视图的整体结构是否符合用户意图;命名、布局和可用性是否合理;多个约束是否全部满足;最终产物是否"看起来构建正确"。

但 JudgeRM 不应成为唯一真值。建议:Judge Reward 占终局 Reward 的比例不超过可执行 verifier;使用固定 rubric、隐藏 Check 和独立 holdout Judge;对多条件 query 逐条评分;对 Judge 与执行结果分歧的样本进入人工审计池;定期用不同模型家族的 Judge panel 复核;监控训练 Judge 上升但隐藏执行正确率下降的 divergence;周期性刷新 JudgeRM,但测试 Judge 永不参与训练。

11.3 建议新增的多维表格专用 Reward

Schema 图正确性

检查表、字段、视图是否存在;字段类型与默认值是否正确;关联字段的方向和多重性是否正确;lookup / rollup / formula 的依赖图是否合法;是否存在悬空引用和循环依赖。

公式语义 Reward

不仅检查 parse,还应在隐藏样例上计算结果;覆盖空值、时区、边界日期、0 和负数;检查返回类型;验证字段重命名后的引用保持。

View 行为 Reward

检查 filter、sort、group、visible fields 和 records:应出现的记录全部出现;不应出现的记录不出现;排序和分组符合需求;修改未破坏其他已有视图。

Automation 图 Reward

检查 trigger 对象和条件;action 顺序与参数;字段引用;循环触发风险;重复运行幂等;模拟事件后的最终状态。

数据与权限不变量

未要求删除的数据仍存在;无关表、字段、视图未被修改;字段迁移没有静默丢值;权限范围未扩大;敏感字段未写入日志或输出。

最小改动 Reward

仅在功能正确与无回归相同的成功 rollout 之间比较:修改对象数量、diff 范围、新增/删除资源数量、迁移数据量。不要在失败和成功之间用最小 diff 排序,否则模型会学会什么都不改。

11.4 Process Reward

可程序化的高价值过程信号:

baseline 是否存在相同错误
错误位置是否落在当前 diff 或直接依赖
rollback 上一步后错误是否消失
一个关键假设是否被验证或证伪
本 turn 是否改变了环境状态
下一 observation 是否符合 thinking 中自然语言表达的可验证预期
是否在验证成功后停止

这些过程信号应由真实执行、离线 metadata 或语义评估器得到,不要用正则检查 thinking 是否包含"归因""因此""预计"等词。

自然语言 thinking 的辅助 Reward 可以写成:

Rthinking-sem=w1Rgrounded+w2Rthought-action+w3Rexpected-effect−w4RredundancyR_{\text{thinking-sem}} = w_1 R_{\text{grounded}} + w_2 R_{\text{thought-action}} + w_3 R_{\text{expected-effect}} - w_4 R_{\text{redundancy}}

评估器应同时看到 observation + thinking + action + next observation,而不是只根据 thinking 的文风独立打分。该项在整条轨迹中的正奖励应设置上限,并显著小于终局功能正确 Reward。

不要奖励:thinking 的长度;使用了多少专业术语;是否使用某种固定句式或是否逐项覆盖模板字段;声明了多少 milestone;编译错误数量减少;每做一次 repair 就得分。

11.5 Gate Reward

Gate 的目标不是匹配静态 teacher 标签,而是最大化当前模型的真实效用:

Rgate(s,m)=Routcome(s,m)−C(s,m)R_{\text{gate}}(s,m)= R_{\text{outcome}}(s,m)-C(s,m)

在同一状态的模式组内:

  • DIRECT 和 THINK 都成功 → DIRECT 获得较高相对 advantage
  • DIRECT 失败、THINK 一次成功 → THINK 获得较高 advantage
  • 局部修复反复失败、REPLAN 成功 → REPLAN 获得较高 advantage
  • 三者都失败 → 不更新或送入课程学习

成本惩罚应在 RL 初期较弱,等三种分支都具备基本能力后再逐步增加。否则 Gate 会在能力尚未形成时因为短期省 token 而塌缩到 DIRECT。


12. RL 算法与 Loss 设计

12.1 推荐起点

对于可并行执行同一状态多个候选的场景,推荐从 multi-turn GRPO/DAPO 风格的组内相对优化开始:

  • 每个 query 或状态快照采样 6~8 条 rollout
  • 早期用强制模式 rollout 保证 THINK_SHORT/REPLAN 不因低初始概率而失去探索
  • 剩余 rollout 让 Gate 自然选择,直接训练 Auto-thinking
  • 以真实工具边界划分 macro-turn
  • 使用 turn-level advantage,而不是只把终局 advantage 平均给整条轨迹
  • all-fail 组不更新 Gate,送入课程学习或 teacher recovery
  • all-correct 组在 R1 可降采样,在 R3 可通过成功成本区分模式

以 group size G=8 为例:

全新任务的初始状态:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  4 × AUTO
  REPLAN 默认被 runtime mask 屏蔽

出现真实错误或 Check 反馈后:
  2 × forced DIRECT
  2 × forced THINK_SHORT
  1 × forced REPLAN
  3 × AUTO

这样既能看到"直接做是否已经足够",也能看到"短思考能否提升一次修复率"和"方案是否真的需要重做"。随着 Gate 变得稳定,可逐步降低 forced rollout 比例,但应保留小的探索下限。

这里的 forced rollout 主要用于反事实估值和条件分支训练;其 mode token 默认不直接进入普通 on-policy Gate gradient。Gate 的直接 policy-gradient 更新以 AUTO rollout 为主,或使用经过正确 importance correction 的 forced 数据。

12.2 Macro-turn

mode token → optional thinking → action/tool call → real observation

Observation 后的 Reward 归因给前一个 macro-turn。工具 observation 只作为下一状态输入,不参与生成 loss。

12.3 分段 RL loss

理想形式:

LRL=−E[wgAglog⁡πg(m∣s)+1m≠D wzAz1∣z∣∑ilog⁡π(zi)+waAa1∣a∣∑jlog⁡π(aj)]+β DKL(πθ∥πSFT)−η H(πg)L_{\text{RL}} =-\mathbb{E} \left[ w_g A_g \log\pi_g(m|s) +\mathbf{1}_{m\neq D}\, w_z A_z \frac{1}{|z|}\sum_i\log\pi(z_i) +w_a A_a \frac{1}{|a|}\sum_j\log\pi(a_j) \right] +\beta\,D_{\mathrm{KL}}(\pi_\theta\|\pi_{\text{SFT}}) -\eta\,H(\pi_g)

其中:

  • A_g:同状态不同模式的相对效用
  • A_z:thinking 的证据扎根性、判断与 action 一致性、可验证预期与结果的过程 advantage
  • A_a:实际工具动作带来的进展和终局 advantage
  • H(π_g):Gate 模式熵
  • KL:防止格式、工具协议和已有代码能力漂移

第一版若无法稳定估计三个 advantage,可以共享 turn-level trajectory advantage,但使用不同 span 权重:

w_gate   = 1.0~1.5
w_action = 1.0
w_think  = 0.2~0.5

随着 verifier 完善,再为 groundedness、判断—动作一致性、预期结果和 action 构造独立 advantage。不要一开始就让 Judge 对自然语言 thinking 的文风施加强梯度。

12.4 RL 分阶段

R0:Reward dry-run

不更新模型,只运行当前 SFT checkpoint:检查各 Reward 分量分布;检查正确轨迹是否总分高于失败轨迹;审计 Judge 与隐藏执行分歧;验证成本项不会压过成功;建立各 query/error bucket 的基线。

R1:正确性与恢复能力

  • 约占 RL update budget 的前 20%~30%
  • 以终局执行、隐藏 Check、Judge 和无回归为主
  • 保持模式强制探索
  • thinking 和工具成本为 0 或只给很弱惩罚
  • 重点提升 Pass@1 与 First-repair success

R2:Gate 与一次修复

  • 约占中间 40%~50%
  • 增强同状态模式组内比较
  • 启用 turn-level advantage
  • 增加语义重复、无关修复和提前停止惩罚
  • 逐步加入条件化 token/tool/wall-time 成本

R3:Pareto 压缩

  • 约占最后 20%~30%
  • 仅在相同成功和进展等级的 rollout 间优化效率
  • 逐步提高 thinking 和额外工具成本
  • 周期性重新生成模式反事实
  • 将已经稳定成功的 THINK 状态转回 DIRECT 边界

这些比例是初始建议,应用 held-out Pass@1、First-repair success、mode regret 和模式熵决定阶段切换。核心顺序不能反转:先让各模式能产生正确结果,再让成本塑造 Gate;否则 5,000 条 DIRECT 先验叠加早期成本惩罚,极易形成永远 DIRECT。


13. 如何避免训练崩溃与模式塌缩

13.1 永远 DIRECT

常见原因:

  • 已有 5,000 条 DIRECT 形成强先验,但 Gate warm-start 和 RL 没覆盖真正 Think-necessary 的边界状态
  • RL 太早施加 thinking/tool 成本
  • THINK_SHORT 分支尚未学会,就与成熟 DIRECT 分支竞争
  • 强制探索不足,组内几乎没有成功的 THINK 候选
  • 所有失败都只有终局 Reward,无法体现正确归因的价值
  • Gate 标签由表面难度决定,长日志反而被误标

有效修复:

  • 先做分支能力冷启动,再做轻量 Gate warm-start,最终通过强制模式 RL 学边界
  • 用 300~500 个状态做轻量 Gate warm-start,而不是扩大 thinking SFT
  • RL 初期设置每组每模式的最小采样数
  • 对 Direct-fail / Think-success 状态上采样
  • 延迟并逐步增加思考成本
  • 监控 Thinking-necessity recall 和 mode regret,而非只看 THINK 比例
  • 对 Gate 添加小的熵正则和最小探索概率

13.2 永远 THINK_SHORT

常见原因:

  • teacher 几乎每次 action 前都写 thinking
  • 修复样本远多于首次成功样本
  • 只奖励成功,不计算思考、工具和时延成本
  • thinking 结构本身被 Judge 偏好
  • DIRECT 只包含简单题,缺少"修复也可 Direct"的样本
  • Gate 把"出现 error 字符串"学成固定触发器

有效修复:

  • 整体 SFT 默认保持约 85% DIRECT
  • 确保已有 DIRECT 中至少 300~500 条覆盖直接机械修复、确定性重试和正确停止
  • 为同一成功状态提供 DIRECT chosen、THINK rejected
  • 成本只在正确性相同时生效
  • Judge 不评价 thinking 文风,只评价可验证决策与结果
  • 加入长日志但 Direct-sufficient、短日志但 Think-necessary 的反例
  • 监控 Unnecessary-thinking rate

13.3 永远 REPLAN

常见原因:

  • REPLAN 文本长,token-level loss 中梯度过大
  • process reward 为"计划完整"或 milestone 数量加分
  • REPLAN 只出现在困难且成功的 teacher 轨迹中,形成伪相关
  • 初始 turn 也频繁强制 REPLAN
  • 局部失败没有精确的 progress 定义

有效修复:

  • 使用 turn-normalized loss
  • REPLAN 冷启动只新增 100~200 条,默认总体约 2.6%,且以真实核心假设失效为准
  • 不奖励计划长度、步骤数和专业表达
  • 全新任务初始 turn 默认屏蔽 REPLAN,仅在接手已有失败方案等状态下开放
  • 每条普通轨迹最多一次 REPLAN
  • 加入"虽然失败但原方案仍有效,应 THINK_SHORT"的负例
  • 监控 Replan precision

13.4 Token 熵塌缩

症状:

Gate 很快只输出一种 mode
thinking 变成固定模板或重复短句
rollout 多样性骤降
训练 Reward 上升但 held-out 正确率下降

措施:

  • 监控 Gate、thinking、action 三个 span 的独立 entropy
  • 使用当前 policy 的 on-policy rollout,减少陈旧离线轨迹占比
  • 对 all-correct/all-fail group 做动态采样
  • 使用适当的 asymmetric clip / clip-higher 或同类稳定化
  • 保持小步更新、gradient clipping 与自适应 KL
  • 设 mode exploration floor;初始状态覆盖 DIRECT/THINK_SHORT,反馈后状态再覆盖三模式
  • 对 query、错误摘要和提示模板做不改变语义的增强
  • 按任务与错误 bucket 分别做 reward normalization
  • 对 reward 和 advantage 截断异常值
  • 训练 Judge Reward 上升而 executable Reward 下降时自动暂停
  • 保存短间隔 checkpoint,并以综合 held-out 指标选择,而不是最后一步

naive RLVR/GRPO 的熵塌缩是已观察到的训练问题,不能只依靠一个全局 entropy bonus 解决;至少要监控 token span 与 Gate 级的熵流。

13.5 Gate 决策边界塌缩

Gate 是离散模式决策,尤其容易在多阶段训练中被单一模式占领。自适应 CoT 研究将其视为正确率与成本的 Pareto 优化,并使用 selective loss masking 避免不确定样本破坏边界。

本场景的对应做法:

有稳定同状态优胜结果 → 更新 Gate
合法模式差异小或全部失败 → mask Gate loss
分支能力不足导致的失败 → 先训练分支,不把失败归因给 Gate
当前 checkpoint 能力变化 → 重新收集反事实,刷新标签

13.6 Reward hacking

重点审计:

  • 删除或放宽 Check
  • 修改 Judge 输入或验收 rubric
  • 输出空产物以减少错误
  • 只修日志显示,不修功能
  • 写出 Judge 喜欢的流畅 thinking,但内容未扎根反馈或与 action 无关
  • 故意制造容易修的小错赚 process reward
  • 提前 done 以减少工具成本
  • 修改无关数据使隐藏样例碰巧通过

防护:

  • verifier、隐藏测试与 policy 沙箱权限隔离
  • 工具层记录所有资源和数据 diff
  • hard-coded output、测试篡改、权限扩大直接终止
  • 训练 Judge、holdout Judge 和 executable verifier 分离
  • 定期人工审计"高 Reward、低执行正确率"的样本
  • 过程 Reward 设置总上限,不能抵消终局失败
  • 维护 reward-component dashboard 与 divergence 告警

14. 怎样证明 Auto-Thinking 真的符合预期

14.1 强制模式 Oracle

在固定评测状态上分别强制 DIRECT、THINK_SHORT、REPLAN、AUTO,得到每个合法模式的真实效用和 AUTO 的 mode regret。AUTO 应接近同状态最优合法模式,而不是仅在平均成功率上看起来不错。

14.2 因果干预

Thinking 置空

正常 short-thinking vs. 保留 mode 但清空 thinking

如果 action 和成功率几乎不变,thinking 没有成为有效支撑点。

Thinking 置换

把任务 A 的 thinking 放到表面相似的任务 B 状态。若 action 不受其中错误证据和错误判断影响,模型可能只依赖 observation 关键词。

Decision 干预

保持其他内容相同,将自然语言中的关键判断从"当前修改破坏了公共契约,应回滚上一处改动再重新实现"替换为"现有方案仍然成立,应保留当前改动并继续局部修复"。应观察到 action 方向变化。否则这段自然语言 thinking 可能只是装饰。

Expect 校验

从 thinking 中语义抽取其可验证预期,并与真实 observation 比较:

  • 符合:说明假设得到支持
  • 不符合:下一 turn 应降低原假设置信度并重新归因
  • 连续不符合仍重复动作:计入 semantic repeat

14.3 必做消融

至少比较:

  1. Direct SFT + Direct RL
  2. 固定所有状态 THINK_SHORT
  3. 固定长 CoT
  4. Auto-thinking SFT,不做 RL
  5. Auto-thinking SFT + 终局 RL
  6. Auto-thinking SFT + turn-level RL
  7. 去掉 attribution/expect process reward
  8. 去掉同状态模式反事实
  9. 去掉条件成本 Reward
  10. 完整方案

所有实验保持:同一基座与 checkpoint 起点、同一训练 query、同一 rollout 预算、同一工具和 verifier、同一测试集、相近总训练 token / compute。

14.4 Auto-thinking 的上线闸门

不能从理论上保证 Gate 永远正确,但可以用可审计标准约束:

Pass@1 与 First-repair success 同时提升
Mode regret 不高于预设阈值
Thinking-necessity recall 达标
Unnecessary-thinking rate 不超标
Replan precision 达标
Semantic repeat 与 premature stop 下降
Judge Reward 与 executable Reward 同向
安全、权限和数据回归零恶化

只要其中一项明显恶化,就不能用"平均 Reward 上升"解释为训练成功。


15. 推荐的完整落地时间线

Step 1:建立评测与可重放环境

  • 固定 Base/schema 快照、工具版本和 acceptance checklist
  • 建立 Pass@1、first-repair、mode regret 和成本报表
  • 实现安全、数据保持、幂等、schema、公式、view 和 automation verifier
  • 校准 JudgeRM 并建立独立 holdout Judge

没有稳定 verifier 时不要急着开始在线 RL。

Step 2:审计 5,000 条 DIRECT 并补充冷启动数据

  • 保留现有 5,000 条 DIRECT,不为满足比例而删除
  • 确保其中 300~500 条覆盖 post-feedback DIRECT;不足时替换低价值重复样本或增补
  • 新增 600~800 条 THINK_SHORT,默认 700
  • 新增 100~200 条 REPLAN,默认 150
  • 从基模失败状态生成 recovery suffix
  • 将长 CoT 压为 64~128 tokens、最多 160 tokens 的 THINK_SHORT
  • 将真正方案失效样本整理为 REPLAN
  • 对错误前缀和 observation 做正确 loss mask

Step 3:高阶模型生成同状态反事实

  • 选 Gate 边界状态
  • 每个合法模式生成 2~4 个候选
  • 真实重放
  • 产出 mode label、chosen/rejected 和不确定 mask
  • 首批只需覆盖 300~500 个高信息状态,作为 Gate warm-start 和 RL 反事实种子

Step 4:完成能力冷启动与轻量 Gate warm-start

S1 强制模式分支能力 → S2 轻量 Gate warm-start → S3 可选联合小步

SFT 的停止条件是三个强制模式均达到最低可用门槛且 DIRECT Pass@1 无回退,不以固定 epoch 或静态 Gate 分类准确率为唯一标准。

Step 5:Reward dry-run

  • 在 SFT checkpoint 上运行至少一个完整评测周期
  • 画出每个 Reward 分量与真实成功率的相关性
  • 审计高 Reward 失败样本
  • 确认成本项不会压过正确性

Step 6:R1/R2/R3 在线 RL

  • R1 前 20%~30% 先学正确和一次恢复,弱化成本
  • R2 中间 40%~50% 学 Gate、重复抑制和停止
  • R3 最后 20%~30% 做成功成本 Pareto 压缩
  • 初始状态按 2 DIRECT + 2 THINK_SHORT + 4 AUTO 探索
  • 反馈后状态按 2 DIRECT + 2 THINK_SHORT + 1 REPLAN + 3 AUTO 探索
  • 采用 learning-frontier 动态采样
  • 周期性把新失败状态交给高阶模型生成 recovery 和反事实

Step 7:周期性蒸馏与刷新

每个主要 RL checkpoint:

  1. 在固定状态强制运行全部合法模式
  2. 重新计算 mode regret 与决策边界
  3. 将稳定高 Reward 的最短轨迹蒸馏回小规模 SFT refresh
  4. 删除旧的冗余或被新能力淘汰的 thinking 标签
  5. 保持一部分原始 DIRECT 数据,防止灾难性遗忘

16. 推荐的首版配置全览

architecture:
  modes: [DIRECT, THINK_SHORT, REPLAN]
  gate_scope: per_react_turn
  gate_token:
    required_for_auto_thinking: false
    recommended: true
    implementation: reasoning_mode_special_token
    tokens:
      DIRECT: "<|mode_direct|>"
      THINK_SHORT: "<|mode_think_short|>"
      REPLAN: "<|mode_replan|>"
    external_workflow_routing: false
    retained_in_model_context: true
    visible_to_user: false
    overhead_tokens_per_turn: 1

sft:
  existing_direct_trajectories: 5000
  add_trajectories:
    THINK_SHORT:
      range: [600, 800]
      default: 700
    REPLAN:
      range: [100, 200]
      default: 150
  default_total_trajectories: 5850
  default_raw_ratio:
    DIRECT: 0.8547
    THINK_SHORT: 0.1197
    REPLAN: 0.0256
  direct_post_feedback_coverage: [300, 500]
  ability_sft_effective_batch:
    DIRECT: 0.82
    THINK_SHORT: 0.15
    REPLAN: 0.03
  recovery_prefix_loss_mask: 0
  tool_observation_loss_mask: 0
  normalization: per_assistant_turn
  stages:
    branch_ability:
      force_mode_token: true
      gate_token_loss_mask: 0
    gate_warm_start:
      states: [300, 500]
      role: exploration_bootstrap_only
    joint_consolidation:
      optional: true
      max_update_budget: 0.10

thinking:
  surface_form: natural_language
  fixed_field_schema: false
  visible_wrapper: thinking_tags_only
  semantic_expectations:
    - grounded_in_observation
    - explains_next_action_when_needed
    - states_verifiable_effect_when_useful
  structured_annotations:
    location: offline_metadata_only
    visible_to_student: false
  semantic_reward:
    context: [observation, thinking, action, next_observation]
    checks: [groundedness, thought_action_consistency, expected_effect, redundancy]
    positive_cap_relative_to_terminal_reward: 0.10
  THINK_SHORT:
    target_tokens: [64, 128]
    hard_cap_tokens: 160
  REPLAN:
    target_tokens: [128, 192]
    hard_cap_tokens: 256

gate_sft:
  warm_start_label_mix:
    DIRECT: 0.65
    THINK_SHORT: 0.30
    REPLAN: 0.05
  train_mode_token_only: true
  uncertain_state_gate_mask: 0
  label_source: same_state_forced_mode_execution

rl:
  rollout_group_size: 8
  initial_state_group:
    forced_DIRECT: 2
    forced_THINK_SHORT: 2
    forced_REPLAN: 0
    AUTO: 4
  post_feedback_group:
    forced_DIRECT: 2
    forced_THINK_SHORT: 2
    forced_REPLAN: 1
    AUTO: 3
  credit_assignment: turn_level
  primary_sampling_bucket: learning_frontier
  ordinary_max_repair_turns: 1
  replan_max_recovery_actions: 2
  max_replans_per_episode: 1
  early_mode_exploration: forced
  gate_update:
    on_policy_source: AUTO_rollouts
    forced_mode_uses:
      - counterfactual_utility_estimation
      - conditional_branch_training
      - gate_preference_construction
    forced_mode_direct_gate_gradient: false
    importance_correction_required_to_enable: true
  cost_penalty_schedule: delayed_and_increasing
  stage_update_budget_default:
    correctness_and_recovery: 0.25
    gate_and_first_repair: 0.50
    pareto_compression: 0.25
  stage_update_budget_range:
    correctness_and_recovery: [0.20, 0.30]
    gate_and_first_repair: [0.40, 0.50]
    pareto_compression: [0.20, 0.30]
  reference_policy: sft_checkpoint

reward_priority:
  - safety_and_data_integrity
  - executable_correctness
  - judge_user_intent
  - regression_and_idempotence
  - verified_process_progress
  - mode_and_interaction_cost

launch_metrics:
  - pass_at_1
  - first_repair_success
  - mode_regret
  - thinking_necessity_recall
  - unnecessary_thinking_rate
  - replan_precision
  - semantic_repeat_rate
  - judge_executable_divergence

17. 总结

对于多维表格 CodeAgent,最优方向不是"所有轨迹都加 CoT",也不是"完全不输出 thinking,只依靠终局 RL"。更合理的方案是:

把短 thinking 设计成自然语言、但可被语义验证的决策瓶颈
把是否使用 thinking 设计成逐 turn 的 Gate
把 DIRECT、THINK_SHORT、REPLAN 作为三种能力先分别训练
再通过同状态真实反事实和多轮 RL 学习模式边界

Auto-thinking 不一定需要显式 Gate token;直接输出 tool call 或 <thinking> 也能形成隐式 Gate。但 reasoning-mode token 每 turn 通常只增加一个 token,却把模式选择变成可独立监督、强化、干预和评测的元推理变量,因此在三档模式方案中更值得采用。它由模型生成并继续参与后续上下文,serving 只负责隐藏,不用于启动外部工作流。

短 thinking 相比直接代码 RL 的主要价值,是把稀疏终局反馈转化为诊断、归因、动作理由、预期观察和 action 等可验证支撑点,从而改善 credit assignment、恢复泛化和一次修复率。它的价值不来自固定结构或长度,而来自自然语言中真实使用了当前证据,并与下一动作和工具反馈形成闭环。

对于当前已有的 5,000 条 DIRECT SFT,建议采用:

保留 DIRECT 5,000 条
新增 THINK_SHORT 600~800 条,默认 700
新增 REPLAN 100~200 条,默认 150
另构建 300~500 个可复用的 Gate warm-start 状态

默认原始比例约为 85.5% / 12.0% / 2.6%。THINK_SHORT 目标 64~128 tokens、硬上限 160。高阶模型主要用于基模真实失败状态上的纠错、压缩和反事实生成,不能替代真实环境判真。

SFT 只需让三种分支可用,并给 Gate 一个最小探索起点;不应依靠大量 THINK_SHORT/REPLAN SFT 固化模式边界。RL 才是 Auto-thinking 的核心:AUTO rollout 负责直接更新 Gate,forced-mode rollout 主要负责反事实估值、条件分支训练和偏好构造;先优化正确性和 First-repair success,再逐步优化 token、工具和时延成本。Auto-thinking 是否成功,最终不由 THINK 占比决定,而由:

更高 Pass@1
+ 更高一次修复率
+ 更低模式 regret
+ 更少无效重复
+ 更低成功成本
+ 无安全和数据回归

共同决定。


参考资料