## §0 TL;DR Cheat Sheet > 💡 **9 句话搞定 Agentic RL** — RL for LLM agents 是 2024-2026 把 reasoning RL 推向真实工具使用、Web、代码与 GUI 的核心范式（详见 §1-§9 推导 + §10 25 高频题）。 1. **Agentic RL 与 RLHF 的本质区别**：RLHF 是 single-turn 偏好对齐，reward 来自 RM 对整段 response 的打分；**Agentic RL 是 multi-turn 决策，state 是 (obs, history)，action 是 (thought, tool_call)，reward 来自外部环境（test-pass、task success、verifier）而非 RM**。整条轨迹长度从 RLHF 的几百 token 涨到 agent 的数千乃至数万 token，credit assignment 难度上一个台阶。 2. **PPO/GRPO 在 agent 上的关键改造**（必背）：**token mask** 必须只对 agent 自己 generate 的 token 算 loss——observation token（tool 返回的 stdout / search snippet）属于环境，policy gradient 不能流到那里；否则 model 会试图"教 tool 怎么回答"，行为崩坏。GRPO 优势更明显：在 long-horizon trajectory 上，value model 几乎学不动 per-token V（中间几乎全 0 reward），组内归一化是更稳的 baseline。 3. **Reward 设计三层金字塔**：(a) **Outcome reward** 最便宜也最稀疏——final answer/task success 0/1；(b) **Process reward** 给每步打分，需要 PRM 或 step verifier；(c) **Hybrid / shaping**——tool-call shaping（鼓励调对工具）、length penalty（防 agent 拖太长）、format reward（强约束输出 schema）。R1 路线用 rule-based outcome reward（数学正确 + 格式），SWE-RL 用 test-pass，WebRL 用 task success——**rule-based outcome reward + dense format shaping** 是 2025 工业实测最稳的组合。 4. **代表性早期 work**：**AgentTuning** (Zeng et al. 2023 arXiv 2310.12823 THU)——agent SFT 数据集 + 多任务训练；**Agent-FLAN** (Chen et al. 2024 ACL Findings arXiv 2403.12881)——把 agent corpus 拆成 multi-turn / formatted / negative example 三类；**ReFT** (Trung et al. 2024 ACL arXiv 2401.08967)——SFT warm-start + online RL on math reasoning，PPO 在 GSM8K 上 +9pp。这三篇是 Agentic RL 的"先 SFT 后 RL"标准三段式。 5. **Tool-augmented reasoning RL**：**ToolRL** (Qian et al. 2025 arXiv 2504.13958)——把 tool 调用嵌入 GRPO，reward 含 correctness + format + tool-use efficiency；**ReSearch** (Chen et al. 2025 arXiv 2503.19470)——把 search call 当 first-class action，rule-based reward 学 multi-hop search；**RAGEN / StarPO** (Wang et al. 2025 arXiv 2504.20073)——多回合 RL 训练 framework，state-action token level loss + critic-free GRPO 变种。共同点：**outcome-only reward + format shaping + token-mask loss + GRPO**。 6. **Web / GUI agent RL**：**WebRL** (Qi et al. 2024 ICLR-25 arXiv 2411.02337)——self-evolving curriculum + ORM + retrospective rollout，把 8B Llama 推到 WebArena 43%；**AgentQ** (Putta et al. 2024 arXiv 2408.07199)——MCTS 搜索 + AI critique + DPO offline 训练；**Computer-Use** (Anthropic Claude 3.5/3.7/4 Sonnet, 2024-10-22 起)——RLHF + RL 在屏幕截图 + 鼠标键盘 action space 上训练 GUI 控制（公开知识：训练细节未披露，但 system card 说明用了大量人工 + AI 反馈）。 7. **Code agent RL**：**CodeRL** (Le et al. 2022 NeurIPS arXiv 2207.01780) 首次把 unit test 当 reward 信号 + actor-critic；**PPOCoder** (Shojaee et al. 2023 arXiv 2301.13816) 加入 compilable + functional correctness 的 composite reward；**SWE-RL** (Wei et al. 2025 Meta FAIR arXiv 2502.18449) 用 rule-based reward（patch similarity + test-pass）在 GitHub PR 数据上做 RL，Llama-3.3-70B 把 SWE-bench Verified 推到 41%。 8. **Self-rewarding & exploration**：**Self-Rewarding LM** (Yuan et al. 2024 Meta arXiv 2401.10020) 让 policy 同时当 judge，iterative DPO with LLM-as-judge；但 self-rewarding 在 agent 上比单 turn alignment 更危险——judge 也是 agent 自己，**容易 reward drift / model collapse**。生产里多用 LLM-as-judge ensemble + rule-based grounding（test-pass、math checker）+ human spot check 三件套。 9. **长 horizon credit assignment 的"三种武器"**：(a) **GAE + γ < 1** 把信用沿轨迹回传，但在 sparse outcome reward 下退化为 MC return；(b) **Hindsight relabeling**（HER 思路在 agent 上的对应物）——失败轨迹按"中间状态当 goal"重新标 reward；(c) **subgoal decomposition + process reward**——把 50 步轨迹切成 5 个 subgoal × 10 步，PRM 给每个 subgoal 打分。L3 面试常问的"为什么 GRPO 在 long-horizon agent 上比 PPO sample efficient"——答案是 **trace-level reward 直接匹配 trace-level credit**，绕开 value model 在 long-CoT 上几乎学不动的痛点。 ## §1 直觉：从 RLHF 到 Agentic RL ### 1.1　把 LLM 从"会写字的策略"升级成"会动手的 agent" RLHF 把 LLM 训成"会按人类偏好写字"的 policy；但 RLHF policy 在调用 tool / 多轮交互 / 长 horizon 任务上仍然脆弱： - **single-turn 偏好** 不 directly transfer 到 multi-turn task success - **RM 学的是"哪种文风讨人喜欢"**，不是"哪种调用顺序能解决问题" - **整段 response reward**，无法区分"前 100 token 推理对、第 101 token 选错了 tool" Agentic RL 的本质是把 RL 信号挂在 **trajectory 终点的客观结果** 上（test pass、math 答对、网页 task 完成），而不是 RM 的主观偏好。这一步让 alignment-style RL 升级为 **decision-making RL**。 ### 1.2　Mental model：MDP / POMDP 表述 | 元素 | RLHF (single-turn) | Agentic RL | |---|---|---| | State $s_t$ | prompt | $(o_0, a_0, o_1, \dots, o_{t-1}, a_{t-1})$（history） | | Action $a_t$ | 整段 response | 一步 `(thought, tool_call)` 或 token-level subaction | | Reward $r_t$ | terminal RM 分 | terminal task success（多数时刻为 0） | | Horizon $T$ | 1（一段 response） | 10-200 步（agent loop） | | Trajectory 长度 (token) | $10^2$-$10^3$ | $10^3$-$10^5$ | | Environment | RM (神经网络) | 真实环境（shell / browser / search / Python） | ``` ┌──────────────────────────────┐ │ Policy π_θ (LLM) │ agent └──────────────┬───────────────┘ │ action a_t = (thought, tool_call) ↓ ┌──────────────────────────────┐ │ Environment / Tool │ │ - search / shell / browser │ │ - Python / unit test │ └──────────────┬───────────────┘ │ observation o_t ↓ ┌──────────────────────────────┐ │ History buffer │ │ (拼回 prompt 给下一步) │ └──────────────┬───────────────┘ │ └─→ 回到 π_θ ``` ### 1.3　Agentic RL 与三类 RL 邻居的关系 | 邻居 | 共同点 | 差异 | |---|---|---| | **RLHF / DPO** | LLM + KL-anchored RL | Agentic 必须多轮 + tool I/O，reward 来自环境而非 RM | | **Reasoning RL（R1, R1-Zero）** | rule-based outcome reward + GRPO | R1 只在数学/代码答题，无 tool；Agentic RL 在 tool 调用 + 多步交互上 | | **经典 robotic RL（VPT, OpenVLA）** | sparse terminal reward + long horizon | LLM agent action space = token sequence；机器人 RL action = 连续控制 | > 💡 **面试 framing** — 被问到"Agentic RL 是什么"时，**先 disambiguate**。 - (1) 严格定义：multi-turn + tool I/O + outcome reward RL - (2) 与 RLHF 的边界：RLHF 是 single-turn alignment，Agentic 是 multi-turn decision-making - (3) 与 reasoning RL 的边界：reasoning RL 只算答题正确，Agentic RL 算 task success on real environment 这三句话能在 30 秒内把面试官的预期 anchor 准。 ## §2 PPO / GRPO 在 agent 上的关键改造 ### 2.1　Token mask：only loss on agent tokens **这是 Agentic RL 第一条铁律**。agent trajectory 里的 token 分两类： - **agent token**：policy $\pi_\theta$ generate 的（thought, action JSON, final answer） - **environment token**：tool 返回的 observation（search snippet, stdout, screenshot caption） PPO/GRPO 的 log-prob ratio 与 loss **必须只在 agent token 上算**。如果在 observation token 上也加 loss： - policy 会试图"教 tool 怎么回答"（毫无意义且会 reward hack） - gradient 会被大量低信息 observation token 稀释 - KL penalty 也会错误地把 environment text 当成自己的 distribution 估计 实现上是一个 **action_mask: [B, L]** tensor：1 表示 agent 自己 generate 的 token，0 表示 prompt / observation / padding。loss 计算时 `(loss * action_mask).sum() / action_mask.sum()`。 > ⚠️ **常见 bug** — 早期开源实现（包括早期 TRL agent example）漏了 observation mask，导致训练 metric 看起来在涨但 task success 下降——典型 reward hacking on tool output。OpenRLHF / verl / TRL 2024 版本都已修正，自己写 trainer 必须显式加。 ### 2.2　Trajectory-level GAE for agent agent 轨迹长（50-200 步），reward 极稀疏（只在终点）。设： - $r_t \in \mathbb{R}$：第 $t$ 步 reward（多数 $t$ 上 $r_t = 0$，终点 $r_T = R \in \{0, 1\}$） - $V_\phi(s_t)$：critic 估计 TD residual： $$\delta_t = r_t + \gamma V_\phi(s_{t+1}) - V_\phi(s_t)$$ GAE： $$A_t^{\text{GAE}(\gamma, \lambda)} = \sum_{l=0}^{\infty} (\gamma\lambda)^l \delta_{t+l}$$ **LLM agent 中 $\gamma$ 怎么取？** 取决于"step"的定义： - 如果 step = **单 token**：$\gamma$ 接近 1（token level discount 没意义） - 如果 step = **一次 thought-action-obs 循环**：$\gamma \in [0.95, 0.99]$ 合理，控制长 horizon 的折扣 **LLM agent 中 GAE 的退化**：sparse terminal reward 下，$\lambda = 1$ + $\gamma = 1$ 等价于 sequence-level MC return 减 baseline。这正是 GRPO 直接做 trace-level reward 的隐含解释。 ### 2.3　PPO loss adapted to agent 带 mask 的 PPO-Clip（按整条 trajectory 算，外层是 trajectory 期望，内层 sum over tokens）： $$\boxed{\;L^{\text{CLIP-agent}}(\theta) = \mathbb{E}_{\tau \sim \pi_\text{old}}\!\left[\frac{\sum_{t=1}^{T} m_t \cdot \min\!\big(\rho_t A_t,\, \text{clip}(\rho_t, 1-\epsilon, 1+\epsilon) A_t\big)}{\sum_{t=1}^{T} m_t}\right]\;}$$ 其中 $\tau$ 是 trajectory（包含所有 $T$ 个 token / step），$m_t \in \{0, 1\}$ 是 agent action_mask（agent 自己生成的 token 为 1，observation/system token 为 0），$\rho_t = \pi_\theta(a_t \mid s_t) / \pi_{\theta_\text{old}}(a_t \mid s_t)$ 是 token-level importance ratio。注意外层 expectation 索引是 trajectory $\tau$，内层 sum 索引是 token $t$，不能混淆。 per-token KL penalty（写进 reward）： $$\tilde{r}_t = m_t \cdot \big(\text{rule}\_\text{reward}_t - \beta \log \tfrac{\pi_\theta(a_t \mid s_t)}{\pi_\text{ref}(a_t \mid s_t)}\big)$$ 注意只对 agent token 算 KL；observation token 的 $\pi$ 是没有意义的（它们是环境给的，不是 model sample 出的）。 ### 2.4　GRPO for agents：trace-level group-relative advantage GRPO 在 agent 上更适用，因为： 1. **省 critic**——agent value 难学（长 horizon + sparse reward） 2. **trace-level reward 直接对应 trace-level advantage**——不需要 per-step value 3. **同 prompt 多 rollout 自动 variance reduction**——agent 任务通常 deterministic env，多次 rollout 给出真实 reward 方差 公式（保留 PPO-Clip 结构，advantage 改组内归一化）： $$\hat{A}_i = \frac{r_i - \text{mean}(\{r_1, \dots, r_G\})}{\text{std}(\{r_1, \dots, r_G\}) + \epsilon}$$ 整条 trajectory 的所有 **agent token** 共享同一个 $\hat{A}_i$（observation token 仍然 mask 掉）： $$L^{\text{GRPO-agent}}(\theta) = \mathbb{E}\!\left[\frac{1}{G}\sum_{i=1}^G \frac{1}{\sum_t m_{i,t}}\sum_{t=1}^{T_i} m_{i,t} \cdot \Big(\min(\rho_{i,t} \hat{A}_i, \text{clip}(\rho_{i,t}, 1-\epsilon, 1+\epsilon) \hat{A}_i) - \beta\, \text{KL}_{i,t}\Big)\right]$$ KL 通常用 K3 estimator（Schulman 2020 blog）：$\text{KL}_{i,t} = \exp(\log\pi_\text{ref} - \log\pi_\theta) - (\log\pi_\text{ref} - \log\pi_\theta) - 1$。 > ✅ **GRPO-agent 的"四省"** — 列举如下。 - 省 value model（一份显存） - 省 per-token credit assignment（trace-level advantage） - 省 reward shaping（rule-based terminal 就够） - 省 hyperparameter（$c_v, \lambda$ 都不需要） > ⚠️ **GRPO-agent 的"三痛"** — 仍有三个 trade-off 需要承认。 - 长 trajectory 上 trace-level advantage 太粗（所有 agent token 共享同一 $\hat{A}$）——长 trajectory 的 credit dilution - 全 success / 全 fail group $\text{std} = 0$ 退化（agent 任务 reward 二值，常出现） - on-policy rollout 慢（agent rollout 含 tool I/O 延迟，远比 chat completion 慢） ## §3 Reward design for agents（核心） reward 是 Agentic RL 的命门。**Reward 错了，模型再大、算法再新也学不到东西**；reward 对了，简单 GRPO 就能上 SOTA。 ### 3.1　Outcome reward vs Process reward | 维度 | **Outcome reward** | **Process reward** | |---|---|---| | 监督粒度 | trajectory 终点 1 个 reward | 每步 (or 每 subgoal) 1 个 reward | | Label 来源 | task success（test pass / answer match）| PRM / step verifier / human | | 稀疏度 | 极稀疏（多数 step 0） | dense | | Credit assignment | 难（长 horizon 上 GAE 也难) | 易（每步直接打分） | | Reward hacking | 较低（rule-based 时） | 较高（PRM 可被 hack） | | 实施难度 | 易（test-pass / 答案 match） | 难（PRM 训练成本高） | **面试 take**：reasoning RL（R1）选 outcome reward 因为数学/代码可程序化验证；agent RL 主流也选 outcome reward 因为 agent 任务 ground truth 更明确（task 完成 yes/no）。**process reward 主要用于 reasoning-heavy 任务**（数学 step 标 PRM），在 tool-use agent 上较少。 ### 3.2　Verifier-based reward（rule-based） 这是 Agentic RL 最干净的 reward 形式：把 reward 写成 **可执行的 verifier 函数**。 ```python def verifier_reward(trajectory) -> float: """ trajectory: list of (thought, action, observation) 返回 0 或 1 的 outcome reward """ final_answer = trajectory[-1].final_answer # 1. 数学题：精确匹配 ground truth if task_type == "math": return 1.0 if normalize_math(final_answer) == ground_truth else 0.0 # 2. 代码题：跑 unit test if task_type == "code": code = extract_code(final_answer) pass_count = run_unit_tests(code, test_cases) return pass_count / len(test_cases) # partial credit # 3. SWE-bench: apply patch + run test if task_type == "swe": try: apply_patch(repo, final_answer) return 1.0 if run_test(repo, expected_test) else 0.0 except PatchError: return 0.0 # 4. Web agent: task-specific verifier if task_type == "webshop": return webshop_grader(final_state) # 由 benchmark 提供 ``` **verifier-based reward 的核心优势**： - 接近 ground truth，**绕开 learned-RM 的 reward hacking 主要 failure mode** - 可重复（同一 trajectory reward 一致），便于 advantage estimate - 显存 / 算力开销极小（执行 verifier 比一次 LLM forward 便宜数百倍） **核心限制**：只能用于"可验证任务"——math、code、formal verification、可 grader 化的 web/GUI task。开放式任务（写作、对话）仍需 RM。 ### 3.3　Format reward / shaping reward 仅有 outcome reward 时 agent 经常学到"格式崩坏但偶然答对"的 trajectory——例如不写 `` 块就直接 `Action: answer(42)`。**Format reward** 给一个轻量的格式约束信号： ```python def format_reward(trajectory) -> float: """ 检查 trajectory 是否符合预期格式 schema 返回 [0, 1] 的连续 score """ score = 0.0 # 必须有 ... 块 if "" in trajectory.text and "" in trajectory.text: score += 0.3 # tool call 必须是合法 JSON for action in trajectory.actions: if is_valid_json(action.tool_call): score += 0.1 else: score -= 0.2 # 严重错误 # final answer 必须用 \boxed{...} 包裹（math task） if has_boxed_answer(trajectory.final): score += 0.2 return max(0.0, min(1.0, score)) ``` **Composite reward** 的典型写法： $$r_\text{total} = \alpha \cdot r_\text{outcome} + \beta \cdot r_\text{format} + \gamma \cdot r_\text{shaping}$$ R1 / R1-Zero 用 `accuracy_reward + format_reward` 的简单加和；ToolRL / RAGEN 等加 tool-call efficiency shaping。 ### 3.4　Length penalty（防 agent 拖太长） agent RL 的一个 emergent failure mode：**model 学到"拖长 trajectory 拿到正确答案的概率更高"**——明明能 5 步解决的任务，agent 偏要走 50 步。这是 reward hacking 的一种形式。 缓解： $$r_\text{adjusted} = r_\text{outcome} - \lambda \cdot \max(0, T - T_\text{target})$$ 或更柔和的 sigmoid 形式： $$r_\text{adjusted} = r_\text{outcome} \cdot \sigma\!\big(-(T - T_\text{target}) / \tau\big)$$ DAPO 报告 "overlong shaping"——超出 length budget 后 reward 指数衰减，避免 agent 拖到 context 上限。 ### 3.5　Tool-call shaping reward 给"调对工具"奖励、给"调错工具 / 重复调用"惩罚： ```python def tool_shaping(trajectory) -> float: score = 0.0 # 调对工具（task 关联性 heuristic） if task_needs_search and any(a.tool == "search" for a in trajectory.actions): score += 0.1 # 惩罚连续重复同样调用 consecutive_dup = count_consecutive_duplicate_calls(trajectory.actions) score -= 0.05 * consecutive_dup # 惩罚调用不存在的 tool invalid_calls = sum(1 for a in trajectory.actions if a.tool not in TOOL_REGISTRY) score -= 0.3 * invalid_calls return score ``` > ⚠️ **shaping reward 的风险** — shaping 给得不当，agent 会 over-fit shaping signal 而忽略 outcome。**主流做法**：shaping reward weight ≪ outcome reward weight（典型 0.1 : 1），且 shaping 必须 capped（不能无限累加）。 ### 3.6　RLAIF for agents：用 LLM 当 reward 外部 verifier 难写时（开放式任务），用强 LLM 当 judge： ```python def llm_judge_reward(trajectory, judge_model) -> float: """ 用 judge LLM 给 trajectory 打分 """ prompt = f""" Judge whether the agent completed this task successfully. Task: {trajectory.task} Final state: {trajectory.final_state} Return JSON: {{"success": bool, "reasoning": str}} """ judgment = judge_model(prompt) return 1.0 if judgment["success"] else 0.0 ``` **风险**： - judge LLM 自己有偏见（长度偏好、谄媚）→ 偏见放大到 student - judge 自己可能被 prompt-injected（agent trajectory 含恶意指令） - 算力开销高（每个 trajectory 一次 judge call） 主流缓解：(a) **judge ensemble**（3-5 个不同 model judge 取多数）；(b) **judge with rubric**（强约束输出结构）；(c) **rule + LLM 混合**（可验证部分 rule，开放部分 LLM）。 ## §4 Long-horizon credit assignment ### 4.1　稀疏 reward 是 agent RL 的核心痛点 经典 game RL（Atari、Mujoco）reward dense；LLM agent 在长 trajectory 上**几乎所有 step reward = 0，只在终点有信号**。这导致： - value model 几乎学不到东西（中间 V 应该是什么？） - per-token policy gradient 方差极大 - 早期 step 与 reward 的因果链被稀释——"我第 3 步选了 search tool" 是不是导致了第 50 步答对？ ### 4.2　Discount + GAE 在 agent 上的退化 回顾 GAE： $$A_t = \sum_l (\gamma\lambda)^l \delta_{t+l}, \quad \delta_t = r_t + \gamma V(s_{t+1}) - V(s_t)$$ 在 sparse terminal reward 下 ($r_t = 0$ for $t \lt T$, $r_T = R$)： $$A_t = \gamma^{T-t} R - V(s_t) + \text{value correction terms}$$ 即 **advantage ≈ 折扣回报 - baseline**。如果 $V_\phi$ 学不准（在 agent 上经常），这就退化为 raw MC return；GAE 的 bias-variance trade-off 失效。 **实践 take**：agent RL 上 GAE 不如 group-relative advantage（GRPO）稳，这是 GRPO 比 PPO 在 agent 上 sample efficient 的根本原因之一。 ### 4.3　Hindsight relabeling for agents Hindsight Experience Replay (Andrychowicz et al. 2017 NeurIPS) 起源于 robot manipulation：失败 trajectory 不丢，而是**把"实际达成的状态"当成 goal**重新标 reward。 LLM agent 版本： ```python def hindsight_relabel(trajectory): """ 把 failed trajectory 改造成 "alternative task" 的 successful trajectory """ if trajectory.outcome == 1: return [trajectory] # 成功的不动 # 假设 agent 在 web 上 navigate 时本来想买商品 A，但最后停在商品 B 页面 # → 改成"找到商品 B 的 trajectory"，reward = 1 alt_task = describe_terminal_state(trajectory.final_state) relabeled = trajectory.with_task(alt_task) relabeled.outcome = 1 return [trajectory, relabeled] ``` > 💡 **Agentic Hindsight 的难点** — 需要"任意 terminal state 都能被描述成一个合理 task"。对开放 web 环境（购物、导航）容易；对 math/code 任务很难（错答案不能被改成"另一个题的对答案"）。 ### 4.4　Subgoal decomposition + process reward 长 trajectory 切成 subgoal 是另一条 credit assignment 路线： - 把 100 步 trajectory 切成 5 个 subgoal × 20 步 - 每个 subgoal 终点给一个 process reward（subgoal 是否完成） - subgoal reward 累加成 trajectory reward 实现方式： - **hand-crafted subgoal**：人写每个 subgoal 的判据（如 "找到购物车页面" 触发 subgoal-1 reward） - **LLM-decomposed subgoal**：让一个 planner LLM 把 task 拆 subgoal，verifier 判每个 subgoal - **PRM-style step reward**：训一个 PRM 评每步好坏（Math-Shepherd 思路） > ⚠️ **subgoal RL 的代价** — subgoal boundary 错画会导致 agent 学到"刻意触发 subgoal reward 而不真正完成 task"。这是 process reward 通病。 ### 4.5　Per-step KL penalty 防止 policy collapse agent 长 trajectory 上 policy 容易"全押"（每步生成 high-confidence token），导致 entropy 崩坏： $$\tilde{r}_t = m_t \cdot \big(r_t - \beta \cdot \text{KL}(\pi_\theta(\cdot \mid s_t) \| \pi_\text{ref}(\cdot \mid s_t))\big)$$ **关键**：KL 必须 per-step + 只对 agent token 算。一旦 KL 算到 observation token 上，policy 会被"惩罚 mimicking 环境文本"——但这惩罚没有意义（policy 不该 mimick 环境，只是用 observation 做条件）。 R1-Zero 用 $\beta = 0.001$，agent task 上常用 $\beta \in [0.001, 0.05]$。 ## §5 Self-rewarding & exploration in agent RL ### 5.1　Self-Rewarding LM（Yuan et al. 2024 Meta arXiv 2401.10020） 核心 idea：让 policy 自己当 judge，iterative DPO： ``` Iteration k: 1. policy_k 生成 multiple responses per prompt 2. policy_k 自己 LLM-as-judge 打分（也是 policy_k 的另一个 prompt） 3. 高分 vs 低分构成 preference pair 4. policy_{k+1} = DPO(policy_k, preference_pair) ``` 效果：在 AlpacaEval 上 iterative 自打分能持续涨点。 ### 5.2　Self-Rewarding 在 agent 上的危险 agent 任务 vs alignment 任务最大差异：alignment 有"客观偏好分布"（人觉得有用、礼貌），可以 LLM judge；**agent 任务有客观 ground truth（test pass / task success）**——self-rewarding 会: - judge 自己可能错（agent 答错了但自评对）→ training collapse - iterative drift：每轮把"自己以为对"的轨迹强化，离 ground truth 越走越远 - 探索退化：自评高分 prefer 已知 pattern，反而抑制探索新工具 **主流做法**：agent RL **优先用 rule-based ground truth**，self-rewarding 仅作为辅助信号（如开放式任务 fallback）。 ### 5.3　Exploration in agent RL agent action space 包括： - **token-level exploration**：sampling temperature，控制 token 选择多样性 - **tool-call-level exploration**：每个 thought-action 周期选择不同 tool / 不同 query - **trajectory-level exploration**：完全不同 trajectory plan 经典做法： | 方法 | 实现 | |---|---| | Temperature schedule | rollout 时 $T \in [0.7, 1.2]$，训练随轮次降温 | | Top-p / Top-k | 限制 sampling 范围避免 outlier token | | ε-tool-choice | 以 $\epsilon$ 概率随机选 tool（替代 LLM-policy 选择） | | Diverse beam | 多 trajectory 用 diverse beam search 保证多样性 | | GRPO group sampling | 同 prompt $G = 16$ 个 rollout，天然 exploration | **RAGEN / StarPO 的关键 insight**（Wang et al. 2025 arXiv 2504.20073）：multi-turn agent RL 中 **rollout 多样性是 collapse 的"防火墙"**——单 trajectory 训练会让 policy 退化为 deterministic mode。 ### 5.4　Curriculum & difficulty scheduling agent 任务从易到难排序，按 model 当前能力 schedule： - **WebRL** (Qi et al. 2024 ICLR-25 arXiv 2411.02337) 用 self-evolving curriculum——失败任务被记录，下轮加入 buffer - **Absolute Zero** / R-Zero 用 learnability reward：选 model success rate ≈ 50% 的任务（最有学习信号） > 💡 **Curriculum 是"长 horizon agent RL 的隐性 component"** — 不是 algorithm contribution，但**实测对 sample efficiency 比换 algorithm 影响更大**。R1 / R1-Zero 的 reasoning RL 也用了 implicit curriculum（数据难度逐渐升级）。 ## §6 Specific algorithms（代表性 Agentic RL papers） 按 "时间 + 数据/任务类型" 排序，每个给一句话 + 关键公式。 ### 6.1　VPT (Baker et al. 2022 NeurIPS OpenAI, arXiv 2206.11795) **Setting**: Minecraft，先用 70k hours youtube 视频 pretrain inverse dynamics model (IDM)，再用 IDM 自动标 action label → behavior clone → RL fine-tune. **Key**: 第一个大规模"视频 → action label → policy → RL"的 pipeline。Agent RL 的早期蓝本，证明了 **scaling RL with imitation pretrain** 可行。 ### 6.2　AgentTuning (Zeng et al. 2023 THU arXiv 2310.12823) **Setting**: 构建 AgentInstruct dataset（6 个 agent task 的 demonstration），多任务 SFT。 **Key**: 不是 RL，是 **agent SFT**——但这是 Agentic RL 的标准 warm-start 步骤。Llama-2 经 AgentTuning 后 agent task 平均 +50%。 > 💡 **AgentTuning 的位置** — 在 Agentic RL pipeline 里，AgentTuning-style SFT 是 RL 之前的必要 warm-start。直接 from-scratch RL 跑 agent 极其困难，因为 base model 不知道怎么 emit 合法 tool call schema。 ### 6.3　Agent-FLAN (Chen et al. 2024 ACL Findings, arXiv 2403.12881) **Setting**: Agent SFT 数据分三类——multi-turn dialogue / formatted tool call / negative examples（拒绝/失败案例）。 **Key**: **negative example 显著缓解 hallucinated tool call**——SFT 不只看"怎么用对"，还看"为什么这样不对"。是 Agent SFT 工程化的重要 milestone。 ### 6.4　ReFT (Trung et al. 2024 ACL arXiv 2401.08967) **Setting**: math reasoning agent，先 SFT warm-start，再 PPO with rule-based outcome reward (answer correctness)。 **Key formula**（标准 PPO + verifier）： $$r(\tau) = \mathbb{1}[\text{answer}(\tau) = y^*] - \beta \cdot \text{KL}(\pi_\theta \| \pi_\text{SFT})$$ **Result**: GSM8K +9pp over SFT，MathQA +7pp。证明 PPO + outcome reward 在 reasoning agent 上稳定可行——这是 R1 的前身实验。 ### 6.5　DeepSeek-R1 (DeepSeek-AI 2025 arXiv 2501.12948) 在 agent 上的扩展 R1 本身不是 agent paper，但 R1 的 GRPO + rule-based reward + format reward 方法论被 ToolRL / ReSearch / RAGEN 直接继承。**R1 = Agentic RL 的算法基线模板**。 复习 GRPO 在 agent 上的应用： - per-prompt $G$ rollouts - trace-level reward（rule-based） - group-relative advantage - per-step KL with K3 estimator - agent token mask ### 6.6　ToolRL (Qian et al. 2025 arXiv 2504.13958) **Setting**: tool-augmented LLM 上做 GRPO，reward = correctness + format + tool-use efficiency。 **Key formula**: $$r(\tau) = r_\text{correct} + \alpha \cdot r_\text{format} + \gamma \cdot r_\text{tool-eff}$$ 其中 $r_\text{tool-eff}$ 惩罚冗余/无效 tool call。 **Result**: 在 BFCL (Berkeley Function Calling Leaderboard) 上 7B model 接近 GPT-4 性能。开源验证 GRPO + tool shaping 的稳定性。 ### 6.7　ReSearch (Chen et al. 2025 arXiv 2503.19470) **Setting**: search-augmented agent，把 search 当 first-class action，reward = answer correctness only（rule-based）。 **Key idea**: 不需要 process reward 也能学会 multi-hop search，**outcome-only + GRPO 足够**——前提是 base model 经 SFT warm-start 已能 emit 合法 search query。 ### 6.8　RAGEN / StarPO (Wang et al. 2025 arXiv 2504.20073) **Paper**: "Understanding Self-Evolution in LLM Agents via Multi-Turn Reinforcement Learning". **Setting**: multi-turn RL agent training framework，state-action token-level loss + critic-free。 **Key contributions**: 1. **StarPO**（**S**tate-**T**hinking-**A**ctions-**R**eward Policy Optimization）：critic-free，整段 trajectory 共享 advantage，加 token mask 严格只在 agent token 上算 loss。**StarPO-S** 变种引入 fine-grained reasoning-aware reward + 可选 critic incorporation，进一步缓解多轮 reward sparsity（论文摘要原话） 2. **rollout 多样性 = collapse 防火墙**：实测 group size $G = 16$ 比 $G = 4$ 显著更稳 3. **trajectory length 信号**：失败 trajectory length 大时 reward shaping 应加 length penalty ### 6.9　WebRL (Qi et al. 2024 ICLR-25 arXiv 2411.02337) **Setting**: Web agent (WebArena)，self-evolving curriculum + ORM + retrospective rollout。 **Key components**: - ORM (Outcome Reward Model) 训自 task success → 在线给 reward - 失败 task 进入 curriculum buffer，下一轮加大权重 - retrospective rollout：失败 trajectory 用 LLM 改造成 "正确 trajectory" 重新 SFT **Result**: Llama-3.1-8B 在 WebArena 上 43%（vs GPT-4 14.4%），证明小 model + 好 RL pipeline > 大 model + zero-shot。 ### 6.10　AgentQ (Putta et al. 2024 arXiv 2408.07199) **Setting**: web agent，MCTS + AI critique + offline DPO。 **Key idea**: MCTS 搜出"reward-balanced" preference pair（高分 trajectory vs 低分 trajectory），用 DPO offline 训练。不需要 online RL infra，对算力受限场景实用。 ### 6.11　WebGUM (Furuta et al. 2024 ICLR arXiv 2305.11854) **Setting**: HTML + screenshot multimodal web agent，offline SFT from demonstrations（**不是 RL fine-tune** — 论文是 imitation/supervised 范式）。 **Key**: 把网页 DOM + 截图同时喂给 model，相比纯 text 提升 grounding 准确率。是 Computer-Use / web agent RL（如 WebRL, AgentQ）的 dataset + base 阶段。后续 web agent RL 工作常在 WebGUM 这类 base 上做 RL fine-tune。 ### 6.12　CodeRL (Le et al. 2022 NeurIPS arXiv 2207.01780) **Setting**: 代码生成 + actor-critic，reward = unit test pass。 **Key formula**: 经典 actor-critic + critic 用作 token-level baseline，PG 信号来自最终 test-pass。 ### 6.13　PPOCoder (Shojaee et al. 2023 arXiv 2301.13816) **Setting**: code generation + PPO，composite reward = compilable + functional correctness。 **Key**: 早期把 PPO 用在 code-gen 上的尝试。证明 multi-component reward 比单 test-pass 训练更稳。 ### 6.14　SWE-RL (Wei et al. 2025 Meta FAIR arXiv 2502.18449) **Setting**: SWE-bench / GitHub PR 数据，rule-based reward = patch similarity + test-pass，GRPO。 **Key features**: - 数据规模：Meta 用 GitHub PR commit history 构造 76M+ context-issue-patch 三元组 - reward：edit similarity (oracle patch ↔ predicted patch) + test pass binary - 算法：纯 GRPO + format reward **Result**: Llama-3.3-70B + SWE-RL 在 SWE-bench Verified 上 41%（无 scaffold），证明 **rule-based RL on real PR data 可以让 model 学到 emergent reasoning behavior**——例如 file-level retrieval planning、root cause analysis、test self-validation。 ### 6.15　OpenVLA (Kim et al. 2024 arXiv 2406.09246) **Setting**: vision-language-action 7B 模型 for robot manipulation，970K 真实机器人 demonstrations 上 fine-tune (开源 base + LoRA fine-tuning recipe)；论文重点是 imitation learning + parameter-efficient adaptation，**不是 task-specific RL fine-tune**。 **Key**: 是 robot agent 而非 LLM agent；常被作为"LLM agent vs robot agent"对比讨论。后续工作（如 OpenVLA-OFT、π-RL 系列）才在 OpenVLA base 上做 RL，但 OpenVLA 论文本身没做 RL。 ### 6.16　Anthropic Computer-Use（公开知识 — 训练细节未披露） Anthropic Claude 3.5 Sonnet (new) 2024-10-22 起支持 Computer-Use；3.7 / 4.0 / 4.5 / Opus 4.x 持续迭代。 **公开资料只描述了能力 + 安全护栏，训练算法 / reward 形式未披露**： - action space = 屏幕坐标 + 键盘事件 + 鼠标事件（截图作为 observation） - 安全性：constitutional AI 风格的护栏 + 红队 + prompt-injection 防御 - system card 提到训练涉及人工演示 + 合成数据，但**没有公开** RLHF / GRPO / verifier reward 等具体细节 社区**推测**（**仅推测**，非官方）：可能用 GRPO/PPO + verifier-based reward + Constitutional AI 风格的 AI feedback，但无任何官方确认。面试时讨论 Computer-Use 训练应明确区分 "公开能力" vs "推测内部细节"。 ## §7 Code patterns（PyTorch / 伪代码） 实现 Agentic RL 时最容易写错的几段。每段独立可读。 ### 7.1　Agent rollout（state, action, reward 收集） ```python import torch from dataclasses import dataclass @dataclass class Step: obs: str # 上一步 observation 或 prompt thought_tokens: list[int] # agent 生成的 thought action_tokens: list[int] # agent 生成的 tool_call JSON tool_name: str tool_args: dict observation: str # tool 返回结果 done: bool def rollout(policy, env, prompt, max_steps=20, max_tokens_per_step=512): """ 一条 agent trajectory rollout 返回: trajectory (list of Step), final reward """ trajectory = [] history = prompt for step_idx in range(max_steps): # ── agent 生成 (thought, action) ── agent_output = policy.generate( prompt=history, stop_tokens=[""], max_new_tokens=max_tokens_per_step, temperature=0.7, ) thought, action_json = parse_thought_action(agent_output) # ── 调用 tool ── tool_name = action_json["tool"] tool_args = action_json["args"] if tool_name == "final_answer": obs = action_json["answer"] done = True else: obs = env.call(tool_name, tool_args) done = False # 更新 history（拼回 prompt） history = history + agent_output + f"\n{obs}\n" trajectory.append(Step( obs=history, # 前置 history thought_tokens=tokenize(thought), action_tokens=tokenize(action_json), tool_name=tool_name, tool_args=tool_args, observation=obs, done=done, )) if done or step_idx == max_steps - 1: break # ── 终点 reward ── final_reward = env.compute_reward(trajectory) return trajectory, final_reward ``` ### 7.2　Trajectory-level GAE advantage ```python import torch def trajectory_gae(rewards, values, dones, gamma=0.99, lam=0.95): """ 计算 step-level GAE advantage rewards: [T] per-step reward (多数 = 0, 终点 = R) values: [T+1] V(s_0)...V(s_T), V(s_T) 应为 0 (terminal) dones: [T] 1 if terminal else 0 返回: advantages [T], returns [T] """ T = rewards.shape[0] advantages = torch.zeros_like(rewards) gae = 0.0 for t in reversed(range(T)): non_term = 1.0 - dones[t] delta = rewards[t] + gamma * values[t + 1] * non_term - values[t] gae = delta + gamma * lam * non_term * gae advantages[t] = gae returns = advantages + values[:T] return advantages, returns ``` ### 7.3　PPO loss adapted to agent（with action_mask） **这是 Agentic RL 最重要的一段代码**。区别 RLHF 的 PPO：必须显式 mask out observation token。 ```python import torch import torch.nn.functional as F def ppo_agent_step(policy, value, batch, eps_clip=0.2, c_v=0.5, c_e=0.01): """ batch: input_ids: [B, L] full trajectory tokens (prompt + thought + action + obs ...) action_mask: [B, L] 1 = agent-generated token, 0 = prompt/observation/pad old_log_probs: [B, L] log π_θ_old at sample time, 0 at masked positions advantages: [B, L] step-level GAE advantages (broadcast to all agent tokens of that step) returns: [B, L] GAE returns for value loss """ logits = policy(batch["input_ids"]).logits # [B, L, V] log_probs = F.log_softmax(logits[:, :-1], dim=-1) # [B, L-1, V] targets = batch["input_ids"][:, 1:].unsqueeze(-1) new_log_probs = log_probs.gather(-1, targets).squeeze(-1) # [B, L-1] new_log_probs = F.pad(new_log_probs, (1, 0)) # 对齐 [B, L] # ── 关键: action_mask ── mask = batch["action_mask"].float() # 只对 agent 自己生成的 token 算 ratio / loss ratio = torch.exp((new_log_probs - batch["old_log_probs"]) * mask) # observation 位置: ratio = exp(0) = 1, 不影响 surr1/surr2 A = batch["advantages"] surr1 = ratio * A surr2 = torch.clamp(ratio, 1.0 - eps_clip, 1.0 + eps_clip) * A # mask 后求均值（避免 observation token 拉低 loss scale） policy_loss = -((torch.min(surr1, surr2) * mask).sum() / mask.sum().clamp_min(1.0)) # value loss: 也只在 agent token 上算（observation 的 V 没意义） V = value(batch["input_ids"]).squeeze(-1) # [B, L] value_loss = (((V - batch["returns"]) ** 2) * mask).sum() / mask.sum().clamp_min(1.0) # entropy bonus: 只在 agent token 上 probs = log_probs.exp() entropy = -(probs * log_probs).sum(-1) # [B, L-1] entropy = F.pad(entropy, (1, 0)) entropy_bonus = (entropy * mask).sum() / mask.sum().clamp_min(1.0) loss = policy_loss + c_v * value_loss - c_e * entropy_bonus # 监控 with torch.no_grad(): approx_kl = ((ratio - 1) - torch.log(ratio.clamp_min(1e-8))) * mask approx_kl = approx_kl.sum() / mask.sum().clamp_min(1.0) return loss, { "policy": policy_loss.item(), "value": value_loss.item(), "entropy": entropy_bonus.item(), "approx_kl": approx_kl.item(), } ``` > ⚠️ **agent_mask 的 5 个易错点** — - 必须 cover **prompt tokens**：prompt 不是 agent generate 的，mask = 0 - 必须 cover **all observation tokens**：tool 返回的每一个 token（甚至包括 `` 标签本身）mask = 0 - 必须 cover **all padding**：右 pad 的位置 mask = 0 - **separator token**（如 ``, ``）算 agent token，mask = 1 - multi-turn batch 里**不同 trajectory 的 mask pattern 不同**，必须 per-sample 算 ### 7.4　GRPO group-relative reward on agent trajectories ```python import torch import torch.nn.functional as F def grpo_agent_loss(policy, ref_policy, batch, eps_clip=0.2, beta=0.04): """ batch: input_ids: [N, L] N = sum_b G samples in batch action_mask: [N, L] agent-generated token mask old_log_probs: [N, L] detached log probs at rollout time rewards: [N] trajectory-level outcome reward group_id: [N] same prompt → same group_id """ rewards = batch["rewards"] gid = batch["group_id"].long() # ── 组内归一化 ── num_groups = int(gid.max().item()) + 1 counts = torch.zeros(num_groups, device=rewards.device).scatter_add_( 0, gid, torch.ones_like(rewards)) sums = torch.zeros(num_groups, device=rewards.device).scatter_add_( 0, gid, rewards) group_mean = sums / counts.clamp_min(1.0) diff_sq = (rewards - group_mean[gid]) ** 2 sq_sums = torch.zeros(num_groups, device=rewards.device).scatter_add_( 0, gid, diff_sq) group_std = (sq_sums / counts.clamp_min(1.0)).sqrt() A = (rewards - group_mean[gid]) / (group_std[gid] + 1e-8) # [N] A = A.unsqueeze(-1) # [N, 1] 整段共享 # ── log-prob ratio ── logits = policy(batch["input_ids"]).logits[:, :-1] log_probs = F.log_softmax(logits, dim=-1) tgt = batch["input_ids"][:, 1:].unsqueeze(-1) new_log_probs = log_probs.gather(-1, tgt).squeeze(-1) new_log_probs = F.pad(new_log_probs, (1, 0)) # [N, L] mask = batch["action_mask"].float() ratio = torch.exp((new_log_probs - batch["old_log_probs"]) * mask) # ── PPO-Clip surrogate (advantage broadcast 到整段) ── surr1 = ratio * A surr2 = torch.clamp(ratio, 1.0 - eps_clip, 1.0 + eps_clip) * A # ── KL with K3 estimator (Schulman 2020 blog) ── with torch.no_grad(): ref_logits = ref_policy(batch["input_ids"]).logits[:, :-1] ref_log_probs = F.log_softmax(ref_logits, dim=-1) ref_token_lp = ref_log_probs.gather(-1, tgt).squeeze(-1) ref_token_lp = F.pad(ref_token_lp, (1, 0)) delta = ref_token_lp - new_log_probs # log(π_ref / π_θ) kl_per_token = torch.exp(delta) - delta - 1.0 # K3, non-negative token_obj = torch.min(surr1, surr2) - beta * kl_per_token # [N, L] seq_len = mask.sum(dim=-1).clamp_min(1.0) # [N] per_seq = (token_obj * mask).sum(dim=-1) / seq_len # [N] loss = -per_seq.mean() return loss, { "reward_mean": rewards.mean().item(), "advantage_std": A.squeeze(-1).std().item(), "kl": (kl_per_token * mask).sum().item() / mask.sum().clamp_min(1.0).item(), } ``` ### 7.5　Outcome + step reward combination ```python def composite_reward(trajectory, weights=None): """ 把 outcome / format / shaping reward 合成最终 reward weights: dict[str, float] """ if weights is None: weights = {"outcome": 1.0, "format": 0.2, "tool_eff": 0.1, "length": -0.05} r = {} r["outcome"] = outcome_verifier(trajectory) # in {0, 1} r["format"] = format_score(trajectory) # in [0, 1] r["tool_eff"] = tool_efficiency_score(trajectory) # in [-1, 1] r["length"] = max(0, len(trajectory.steps) - target_len) # excess steps total = sum(weights[k] * r[k] for k in r) return total, r ``` > 💡 **process-then-outcome 复合形式** — 若有 PRM，可以：先 PRM 给 step-level shaping，但**最终轨迹 reward 至少 50% 由 outcome 决定**，避免 agent 偷只关心 PRM score 的局部最优。 ### 7.6　Verifier-based reward（code test / math match） ```python import re import subprocess def verifier_reward(trajectory, task_type, ground_truth): """ rule-based outcome reward """ final = trajectory.final_answer if task_type == "math": return float(extract_boxed_answer(final) == normalize(ground_truth)) if task_type == "code": code = extract_python_code(final) if code is None: return 0.0 passed = 0 for test in ground_truth["tests"]: try: result = subprocess.run( ["python", "-c", code + "\n" + test], capture_output=True, timeout=5, ) if result.returncode == 0: passed += 1 except subprocess.TimeoutExpired: continue return passed / len(ground_truth["tests"]) if task_type == "swe": patch = extract_unified_diff(final) if patch is None: return 0.0 success = apply_patch_and_run_test( repo=ground_truth["repo"], patch=patch, test=ground_truth["test"], ) return float(success) if task_type == "webshop": return webshop_grader(trajectory.final_state, ground_truth) raise ValueError(f"Unknown task type: {task_type}") ``` ## §8 Frontier (2024-2026 关键趋势) ### 8.1　Critic-free RL is the new default DeepSeek-R1 (Jan 2025) 之后，**critic-free RL（GRPO 系）成为开源 agent RL 主流**。原因： - value model 在长 horizon agent 上几乎学不动 - 一份模型显存省下来可以加大 batch / group size - 调参简单（不用调 $c_v$, value lr） verl (ByteDance 2024+)、OpenRLHF、TRL 都已把 GRPO / RLOO / ReMax 当 first-class trainer。 ### 8.2　Rule-based reward 在 agent 上的胜利 WebRL / ReSearch / SWE-RL / RAGEN 共同点：**outcome reward + format reward，rule-based**，避开 learned RM 的 reward hacking 主 failure mode。 **为什么 rule-based 突然变可行**： - Agent task 比 alignment task 更"可程序化验证"——test pass / answer match / task complete - DeepSeek-R1 证明 rule-based 在 LLM RL 上 stable 且 scalable - learned RM 在 multi-turn 上更容易 hack（轨迹空间大） ### 8.3　Long-horizon training 的 infra challenge agent RL rollout 慢，因为每个 trajectory 包含 tool I/O 延迟。infra 趋势： - **vLLM / SGL 异步 rollout**：把 generation 与 training 解耦，rollout 池化 - **Sandboxed execution**：tool execution 在 isolated container，并行化 - **Trajectory queue**：rollout worker / training worker 异步，trajectory 通过 message queue 流转 - **off-policy correction**：rollout 与 update 之间有 lag，用 IS clip 或 V-trace 校正 代表实现：**verl** (ByteDance Seed open-source), **AReaL** (Ant Group + Tsinghua, async RL system arXiv 2505.24298), **OpenRLHF v0.5+**. ### 8.4　Tool-RL on TAU-bench / SWE-bench / OSWorld 工业 benchmark 上的 SOTA 趋势（2025-2026 公开数字）： | Benchmark | Task | 2024 SOTA | 2025-2026 SOTA | Key approach | |---|---|---|---|---| | **TAU-bench (retail)** | customer service multi-turn | ~50% (GPT-4) | 70-80% (Claude 4.x, GPT-5) | RLHF + agent SFT | | **SWE-bench Verified** | GitHub PR fix | ~25% (Claude 3.5) | **70-80%+** (Claude 4.x, o3) | Agent scaffold + RL | | **OSWorld** | OS GUI task | ~12% (GPT-4V) | ~50-60% (Claude 4.x, Operator) | Computer-Use RL | | **WebArena** | web nav | 14.4% (GPT-4) | 43% (WebRL Llama-8B) | curriculum + RL | | **GAIA** | general assistant | 15% (GPT-4) | 60-70% (Claude 4.x, o3) | Agent + tool RL | 注意：benchmark contamination 风险大，**2026Q1 OpenAI 已弃用 SWE-bench Verified**（原因：contamination + test flaw）；当前更可信 benchmark 是 SWE-Lancer、SWE-bench Multilingual、private holdout。 ### 8.5　Anthropic Computer-Use（Claude 3.5 → 4.5 → Opus 4.x） **公开知识**： - 2024-10-22 Claude 3.5 Sonnet (new) 首发 Computer-Use beta - 2025: Claude 3.7 / 4.0 / 4.5 持续迭代，速度 + 准确率提升 - 训练涉及大量人工演示 + AI-generated rollout + RLHF + 安全红队 - Action space = 屏幕截图 + 鼠标 + 键盘 + 文件系统访问 - 公开 system card 提及 Constitutional AI + Computer-Use specific safety filter **算法层面的 inferred 信息**（学术界推测，未官方确认）: - 训练大概率涉及 RLHF on screenshot trajectories - reward 含 task completion grader (LLM-as-judge) + safety classifier - 可能用 GRPO / RLOO style critic-free RL（公开 paper 多次提及 critic-free） ### 8.6　2025-2026 papers 群像 | 论文 | 方向 | 核心贡献 | |---|---|---| | **KodCode** (Xu et al. 2025) | 代码 agent RL | 高质量代码 RL 数据集 + GRPO baseline | | **DAPO** (Yu et al. 2025 ByteDance) | GRPO 改进 | clip higher / dynamic sampling / token loss / overlong shaping | | **VAPO** (字节跳动 2025) | GRPO 加 lightweight critic | trace-level credit dilution 缓解 | | **CISPO** (MiniMax 2025) | importance sampling 改进 | 解决 negative advantage 大 ratio 失稳 | | **R-Zero** | Self-Play RL | Challenger-Solver self-play，learnability reward | | **Absolute Zero** | Self-Play RL | 完全无外部 task，code executor 当 verifier | | **Search-R1** | search agent RL | search 当 first-class action + rule reward | | **Light-R1** / **Sky-T1** | reasoning + tool RL | 开源 reproduction R1 + agent extension | | **OpenAgent** / **Llama-Agent** | 数据 + 框架 | 大规模 agent SFT + RL pipeline | > 💡 **2026Q1-Q2 趋势** — agent RL on real environment（OS, browser, IDE）成为开源主线。**simulator → 真实环境 → 部署 RL** 的 sim-to-real pipeline 是下一个 frontier。Anthropic / OpenAI / DeepSeek / Meta 等都在做但细节未公开。 ## §9 Failure modes & 工程经验 ### 9.1　Agentic RL 的"七宗罪" | 失败模式 | 症状 | 根因 | 缓解 | |---|---|---|---| | **Token mask 漏 observation** | reward 上不去 / agent 学到怪行为 | gradient 流到 environment token | 严格 per-sample action_mask | | **Reward hacking on grader** | benchmark 涨但人评下降 | grader 有漏洞 | grader ensemble + holdout test | | **Length-explosion** | agent 拖到 context 上限 | reward 与 length 正相关 | length penalty + max_steps cap | | **Tool-call hallucination** | agent 调不存在的 tool | base model SFT 不够 | Agent-FLAN-style negative SFT | | **Loop / repetition** | agent 反复调同样 tool | exploration 不够 | tool-call diversity bonus + ε-tool | | **Group $\sigma = 0$ collapse** | advantage = NaN / 0 | 全 success 或全 fail | data filter + std clamp | | **KL collapse** | policy entropy → 0 | β 太小 | per-step KL + entropy bonus | ### 9.2　Online vs offline RL trade-off | 维度 | Online RL (PPO/GRPO) | Offline RL (DPO/RFT) | |---|---|---| | 数据效率 | 低（每轮新 rollout） | 高（一次 dataset 多次训） | | 训练速度 | 慢（rollout 含 tool I/O） | 快（pure SFT-style） | | 性能上限 | 高（持续学习新分布） | 中（受限于 dataset 分布） | | 实现复杂度 | 高（trajectory queue + verifier server） | 低 | | 适合 | 长期投入 + 真实环境 | 资源受限 + 已有 demo data | **实践建议**：从 offline RL（agent SFT + DPO）起手，建立 baseline；有算力后迁移到 online RL（PPO/GRPO + verifier）。 ### 9.3　Rollout 优化经验 - **vLLM PagedAttention** 比 HF generate 快 5-10×，是 agent rollout 的必装 - **Tool sandbox** 用 Docker + gVisor，单机并行 64-128 个 trajectory 没问题 - **Async rollout pipeline**：rollout worker 不阻塞 trainer worker - **Trajectory replay buffer**：FIFO + priority 混合，replay 时按 reward 加权 - **Batch size = group_size × prompt_per_batch**：典型 $G = 16$, prompt = 32 → 512 trajectory / batch ### 9.4　Debug checklist agent RL 跑崩了，按顺序排查： 1. **看 reward**：是否多数 trajectory reward = 0？rule 写错了？ 2. **看 length 分布**：是否大多数 trajectory 在 max_steps 截断？说明 agent 不会 finish 3. **看 action_mask**：是否正确 cover prompt + observation + padding？ 4. **看 KL**：approx_kl 是否爆？β 调大；entropy 是否塌？entropy_bonus 调大 5. **看 group_std**：是否大量 group 全 0/全 1？需要 data filter 6. **看 tool call distribution**：是否过度依赖某一个 tool？引入 diversity bonus 7. **看 sample efficiency**：单 prompt 多 rollout reward 方差是否合理？太大说明 base 太弱 ## §10 25 高频面试题（L1 必会 / L2 进阶 / L3 顶级 lab） 按难度分 3 档：L1 = 任何 agent / LLM RL 岗会问；L2 = research / alignment 团队会问；L3 = 顶级 lab 硬核题。每题点开看答案要点 + 易踩坑。 ### L1 必会题（10 题）
Q1. Agentic RL 和 RLHF 的本质区别？ - **RLHF**: single-turn alignment，state = prompt，action = 整段 response，reward 来自 RM 对偏好的打分，horizon = 1 - **Agentic RL**: multi-turn decision-making，state = (obs, history)，action = (thought, tool_call)，reward 来自外部环境（test pass / task success），horizon = 10-200 - 算法层面都用 PPO/GRPO，但 Agentic 必须加 **action_mask**（只对 agent token 算 loss） - reward 形式：RLHF 偏好打分（subjective），Agentic 客观 outcome（objective） 把它们当成同一件事；或不知道 action_mask 的必要性。
Q2. 为什么 Agentic RL 必须用 action_mask？ - agent trajectory 含两类 token：agent 自己 generate 的 + tool 返回的 observation - 如果不 mask，PPO/GRPO 的 ratio 和 loss 会流到 observation token 上 - 后果：(a) policy 试图"教 tool 怎么回答"，无意义且会 reward hack；(b) gradient 被 low-information observation 稀释；(c) KL penalty 错误地把 environment text 当自己分布估计 - 实现：`action_mask: [B, L]`，1 = agent token，0 = prompt/obs/pad；loss 计算时除以 `mask.sum()` 标准化 说"只在 response 上算 loss"不够具体（agent task 没有"response"这个明确边界）；或漏了 mask 必须 cover all observation tokens。
Q3. GRPO 在 agent 上比 PPO 好的核心原因？ - **省 critic**：agent value 在长 horizon + sparse reward 下几乎学不动 - **trace-level reward 直接匹配 trace-level credit**：不需要 per-token V，避开 value 学不动的痛 - **组内归一化** 自动做 variance reduction，比 raw advantage 稳 - **省一份显存**：可以扩大 batch / group size - 限制：长 trajectory 上 advantage 太粗（整段共享），credit dilution 仍存在 只说"省 critic"不全面；或不知道 trace-level reward 与 trace-level credit 的匹配关系。
Q4. Outcome reward 和 process reward 的区别？agent 上常用哪个？ - **Outcome reward**: trajectory 终点 1 个 reward（test pass / answer match），极稀疏，credit assignment 难，但 reward hacking 风险低 - **Process reward**: 每步打分，dense，credit assignment 易，但 reward hacking 风险高（PRM 可被 hack） - **Agent 上主流: outcome reward**——agent task ground truth 明确（test/grader）；R1, SWE-RL, ReSearch, RAGEN 都用 outcome-only - Process reward 主要用于 reasoning-heavy 任务（PRM 在数学 step 上），agent 上少用 以为 process reward 总是好（实际 agent 上 outcome 更稳）；或不知道 reward hacking 风险差异。
Q5. Verifier-based reward 比 learned RM 好在哪？ - **接近 ground truth**：避开 learned RM 漂出训练分布的主要 failure mode - **可重复**：同一 trajectory reward 一致（learned RM 输出有噪声） - **显存便宜**：执行 verifier 比一次 LLM forward 便宜数百倍 - **可解释**：reward 来自客观 rule，可 trace 失败原因 - **限制**：只能用于可验证任务（math/code/grader-able web） 说 verifier-based "完全没有 hacking"——错，仍可能被正则漏洞 / format trick / test 泄露 hack，但比 RM hacking 容易堵。
Q6. R1 / R1-Zero 的方法能直接用在 agent 上吗？ - 算法可以直接搬：GRPO + rule-based reward + per-step KL + token mask - 但需要补： - **action_mask**: agent 有 observation token，R1 数学任务没有 - **trajectory rollout infrastructure**: 含 tool I/O，比纯 generation 复杂 - **format reward 调整**: agent task 的 format 是 JSON tool call，不只是 `` - 代表性工作 ReSearch / RAGEN / ToolRL / SWE-RL 都是 R1 算法 + 上述改造 说"R1 不能直接搬"——其实可以但要改 wrapper；或不知道 ReSearch / RAGEN / ToolRL 这些工作。
Q7. Agent RL 中为什么需要 SFT warm-start？ - base model 不知道怎么 emit 合法 tool call schema（JSON 格式 / argument 名称） - 直接 from-scratch RL 几乎不可能 explore 到合法 tool call → reward 全 0 → 学不动 - SFT warm-start（AgentTuning / Agent-FLAN 数据）让 model "知道动作空间长什么样" - 之后 RL 在合法 action 子空间内 optimize 只说"RL 慢，SFT 加速"——不够；核心是 action space exploration 困难，SFT 解决"知道动作空间"。
Q8. Length penalty 在 agent RL 中起什么作用？ - agent 容易学到"拖长 trajectory 拿对答案"的捷径（reward hacking） - length penalty 给超出 budget 的 trajectory 减分：$r = r_\text{outcome} - \lambda \max(0, T - T_\text{target})$ - DAPO 的 "overlong shaping" 是工业级实现（指数衰减） - 限制：penalty 过大会让 agent 不敢探索；要 cap 不知道 length-explosion 是 agent RL 常见 failure mode；或不会写 length penalty 公式。
Q9. Group std = 0 的情况怎么处理？ - 当 group 内 G 个 rollout reward 全相同（全 success / 全 fail）→ $\sigma = 0$ - 加 $\epsilon$ 时 advantage = 0，policy gradient 项归零，**但 KL 项仍存在**（policy 仍被拉回 reference） - 不加 $\epsilon$ 时是 NaN - 实践： - **Skip 该 prompt**（data filter）：常见做法，避免无信号更新 - **Clamp σ 下限**（如 0.1）：保留少量信号 - **DAPO dynamic sampling**：丢全对全错 group 说一定会 NaN（不对，看实现）；或不知道这种 prompt 暗示 task 过易/过难。
Q10. SWE-RL 是怎么训的？ - 数据：GitHub PR commit 历史，构造 ~76M context-issue-patch 三元组（Meta 公开） - Reward: rule-based = patch similarity (oracle ↔ pred) + test pass binary - 算法: 纯 GRPO + format reward - Model: Llama-3.3-70B - Result: SWE-bench Verified 上 41%（无 scaffold），证明 rule-based RL 让 model 学到 emergent reasoning：file retrieval / root cause / test self-validation 不知道 SWE-RL 的 reward 设计；或以为是 SFT 而非 RL。
### L2 进阶题（10 题）
Q11. 推导 PPO loss 在 agent 上加 action_mask 后的形式。 1. 标准 PPO-Clip：$L = \mathbb{E}[\min(\rho_t A_t, \text{clip}(\rho_t, 1-\epsilon, 1+\epsilon) A_t)]$ 2. agent 有 $m_t \in \{0, 1\}$，1 = agent token，0 = obs/prompt 3. ratio 计算时 $\rho_t = \exp((\log\pi_\theta - \log\pi_\text{old}) \cdot m_t)$，observation 位置 $\rho = e^0 = 1$，不影响 surr1/surr2 4. loss 归一化：$L^\text{agent} = -\sum_t m_t \cdot \min(\rho_t A_t, \text{clip}) / \sum_t m_t$ 5. KL 项也只在 agent token：$\text{KL}_\text{total} = \sum_t m_t \cdot \text{KL}_t / \sum_t m_t$ 只写公式不解释 mask 的作用；或忘了 normalization 用 mask.sum() 而非 batch size。
Q12. RAGEN / StarPO 的关键贡献？ - **StAble multi-tuRn Policy Optimization**: critic-free GRPO 变种，整段 trajectory 共享 advantage - **严格 token mask**：observation 位置 mask = 0，loss 只在 agent token - **rollout 多样性 = collapse 防火墙**：group_size $G = 16$ 比 $G = 4$ 显著更稳 - **trajectory length 信号**：失败 trajectory length 大时加 length penalty - 适用：multi-turn agent task（与 single-turn alignment 区分） 只说"GRPO 变种"——不够；要说出 multi-turn 上的 stability 贡献。
Q13. WebRL 的 self-evolving curriculum 是怎么工作的？ - 初始 task set $\mathcal{T}_0$（small），训 policy 跑 trajectory - 失败 trajectory 进入 buffer，加到下一轮 curriculum $\mathcal{T}_{k+1}$ - retrospective rollout：失败 trajectory 用 LLM 改造成"正确 trajectory"（hindsight relabel），再做 SFT - ORM (Outcome Reward Model) 训自 task success → 在线给 RL reward - Result: Llama-3.1-8B 在 WebArena 上 43%（vs GPT-4 14.4%） 不知道 self-evolving 的循环结构；或把 WebRL 当作纯 SFT。
Q14. 为什么 self-rewarding LM 在 agent 上比在 alignment 上风险更高？ - alignment 任务有"客观偏好分布"，LLM judge 与人评有较高相关 - agent 任务有**客观 ground truth**（test pass / task success）—— judge 自己可能错（认错对错） - iterative drift：每轮把"自评对"的轨迹强化 → 远离 ground truth - 探索退化：自评偏好已知 pattern → 抑制探索新 tool - 主流做法：agent RL 优先 rule-based ground truth，self-rewarding 仅作开放式任务 fallback 说 self-rewarding 总是危险（alignment 上仍可用）；或不知道 agent 上 ground truth 客观性是关键
Q15. 推 outcome-reward sparsity 对 critic learning 的影响。 - value $V_\phi(s_t) = \mathbb{E}_\pi[\sum_{l \ge 0} \gamma^l r_{t+l} \mid s_t]$ - sparse terminal reward → $V(s_t) \approx \gamma^{T-t} \cdot P(\text{success} \mid s_t)$ - 中间状态 $s_t$ 的 value 几乎只取决于"未来是否成功"——这是隐含 long-horizon 预测 - value MSE loss $(V_\phi - V_\text{target})^2$ 在多数 step 上 target 接近 0，gradient 极小 - 等价于"几乎没有 supervision"——value 学不动是 sparse reward 的必然结果 - 这也是 GRPO 省 critic 的理论基础：critic 本来就学不动，省了反而省去 noise 只说"critic 学不动"；不会推 $V \approx \gamma^{T-t} P(\text{success})$；或不知道这是 GRPO 设计动机。
Q16. ToolRL 的 reward 设计有什么 nontrivial 之处？ - composite: $r = r_\text{correct} + \alpha r_\text{format} + \gamma r_\text{tool-eff}$ - $r_\text{tool-eff}$ 惩罚冗余 tool call（重复调同样工具 / 调用无效 tool） - 这是典型的 shaping reward：缓解 length-explosion + tool-overuse 两个 failure mode - weight 平衡：outcome ≫ format > tool-eff，避免 shaping override outcome - BFCL benchmark 上 7B 接近 GPT-4 只说"加 tool call 奖励"；不知道 shaping reward weight 平衡是关键。
Q17. Hindsight relabeling 在 agent RL 中怎么用？ - 失败 trajectory 不丢，改造为 "alternative task" 的 successful trajectory - 例：agent 想买 A 商品但停在 B → 改造为"找到 B 商品"，reward = 1 - 实现：`alt_task = describe(trajectory.final_state)`，relabel reward = 1 - 适用：开放 web 环境、navigation；不适用：math/code（错答案不能改成对答案） - 起源：HER (Andrychowicz 2017 NeurIPS) for robot manipulation 不知道 HER 起源；或不知道适用边界（开放环境 vs 答题任务）。
Q18. Per-step KL penalty 和 trajectory KL penalty 的区别？ - **per-step KL**: 每个 agent token 算 KL($\pi_\theta(\cdot \mid s_t) \| \pi_\text{ref}(\cdot \mid s_t)$)；加进 reward 或 loss - **trajectory KL**: 整段 trajectory 一个 KL；加进 loss - per-step 更精细，能控制每步漂移；trajectory 简单但缺乏 token-level resolution - GRPO 用 per-step + K3 estimator（数值稳定） - agent RL 上 per-step 更主流（trajectory 太长，单 KL 数值不稳） 混淆两者；或不知道 K3 estimator 解决数值问题（K3: $\text{KL} \approx \exp(\Delta) - \Delta - 1$ 非负）。
Q19. Subgoal decomposition + process reward 怎么做？什么时候用？ - 长 trajectory 切 subgoal：100 步 trajectory → 5 个 subgoal × 20 步 - 每个 subgoal 终点给 process reward（subgoal 是否完成） - 实现路径： - hand-crafted: 人写 subgoal 判据 - LLM planner: planner LLM 拆 subgoal，verifier 判 - PRM-style: PRM 评每步 - 适用：long-horizon agent + 可以 hand-craft subgoal 的任务 - 风险：subgoal boundary 错画 → agent 学到"刻意触发 subgoal reward 而不真正完成 task" 说 process reward 总是好——错；要说出风险与限制。
Q20. Online RL vs Offline RL 在 agent 上的 trade-off？ - **Online RL (PPO/GRPO)**: 数据效率低（每轮新 rollout），但持续学新分布 - **Offline RL (DPO/RFT)**: 数据效率高，但受限于 dataset 分布 - agent rollout 慢（含 tool I/O），online RL 训练吞吐低 - 实践：先 offline 起手（SFT + DPO），再 online refinement - 代表：AgentQ 是 offline（MCTS + DPO）；WebRL 是 online；SWE-RL 是 online 只说"online 慢"；不知道 agent rollout 含 tool I/O 是主要瓶颈。
### L3 顶级 lab 题（5 题）
Q21. 推导 GRPO advantage 公式 + token mask 的完整 loss，并解释 agent token mask 的两种等价放置方式。 1. **Group-relative advantage**: - rollout group $\{r_1, ..., r_G\}$ per prompt - $\mu = \frac{1}{G}\sum r_i$, $\sigma = \sqrt{\frac{1}{G}\sum (r_i - \mu)^2}$ - $\hat{A}_i = (r_i - \mu) / (\sigma + \epsilon)$ 2. **Trajectory-level broadcast**: $\hat{A}_{i,t} = \hat{A}_i$（所有 agent token 共享） 3. **Token-masked ratio + loss**： - 朴素 $\rho_{i,t} = \exp(\log\pi_\theta(a_{i,t} \mid s_{i,t}) - \log\pi_\text{old}(a_{i,t} \mid s_{i,t}))$ —— 在 observation 位置也会有数值（model 估算 env text 的概率） - **要点**：只要最终 objective / gradient 只覆盖 agent token，mask 放 ratio 内还是 loss 外都**数学等价**： - **Inside-ratio**：$\rho_{i,t} = \exp((\log\pi_\theta - \log\pi_\text{old}) \cdot m_{i,t})$ → obs 位置 $\rho=1$，进 clip 后 $\min(\cdot)$ 项 = $A_{i,t}$ 但乘以 $m_{i,t}=0$ 后归零（在 loss 外的 sum 中） - **Outside-ratio (mask loss only)**：保留 obs 位 $\rho_{i,t}$ 数值；最终 loss = $-\sum_t m_t \cdot \min(...)$，obs 位贡献 $m_t = 0$ 直接归零 - **两者梯度都只覆盖 agent token**（mask 是乘法，梯度对 obs 位都是 0） - 但实践上 **Inside-ratio 更安全**：避免 obs 位 $\rho$ 数值参与 clip 触发判断或被日志 / 监控（如 mean ratio）误读为异常。生产实现（verl / OpenRLHF）多用 inside-ratio 5. **Full loss**: $$L = -\frac{1}{G} \sum_i \frac{1}{\sum_t m_{i,t}} \sum_t m_{i,t} \cdot \Big(\min(\rho_{i,t} \hat{A}_i, \text{clip}(\rho_{i,t}, 1-\epsilon, 1+\epsilon) \hat{A}_i) - \beta \cdot \text{KL}_{i,t}\Big)$$ 不会推 step 4 (mask 位置影响 ratio 数值)；或公式背得对但不解释 mask 设计哲学。
Q22. GRPO 在 long-horizon agent 上比 PPO sample efficient 的根本原因？ **Trace-level reward 与 trace-level credit 的自然对齐**（不止是"省 critic"）： 1. **Sparse terminal reward 下 critic 学不动**：$V(s_t) \approx \gamma^{T-t} P(\text{success})$，gradient 极小；PPO 的 GAE-advantage 受 noisy critic 拖累 2. **GRPO 直接用 trace-level reward 当 advantage**：等价 sequence-level MC return，在 sparse reward 下是 unbiased estimator 3. **Group baseline 比 critic baseline 更稳**：同 prompt G rollouts → group mean 自动反映该 prompt 的难度，variance reduction 更精准 4. **PPO clipping + group size 联合限制更新幅度**：避免单 outlier reward 推飞 policy 5. **省 value model 显存** 是 secondary benefit，不是 primary reason 6. **Rule-based outcome reward 难被 RM hacked**：在 agent 上比 learned RM 稳 只说"省 critic"——不够；要说出 sparse reward 下 critic learn 不动是根因。
Q23. 如何设计一个 RL framework 同时支持 reasoning RL（R1）和 Agentic RL（ReSearch / WebRL）？ 抽象出五层： 1. **Data layer**: - reasoning: (prompt, ground_truth) tuples - agent: (task, env_spec, reward_fn) 三元组 - 统一为 `Task(prompt, verifier)`，verifier 是 callable 2. **Rollout layer**: - reasoning: 直接 generate - agent: 含 tool I/O 的 multi-step rollout (vLLM + sandboxed tool executor) - 统一为 `Trajectory(tokens, action_mask, reward)` 接口 3. **Reward layer**: - reasoning: rule-based (answer match / test pass) - agent: composite (outcome + format + tool_eff + length penalty) - 统一为 `Reward(traj) -> float` 4. **Loss layer**: - PPO with action_mask - GRPO with group_id + action_mask - DPO with chosen_mask / rejected_mask - 通过 `loss_fn(batch, model, ref_model) -> loss` interface 5. **Infra layer**: - vLLM rollout pool - Sandboxed tool executor (Docker + gVisor) - Trajectory replay buffer (FIFO + priority) - Async trainer / rollout 代表实现: **verl** (字节) 已支持 reasoning + agent；**OpenRLHF** 部分支持。 只列 PPO 不考虑 agent rollout infra；或不知道 verl / OpenRLHF 的当前支持范围。
Q24. Anthropic Computer-Use 训练方法 — 已知 vs 推测的清晰边界 **官方公开（system card / blog）**： - action space = 屏幕截图 (vision observation) + 鼠标 + 键盘 events - 能力持续迭代 Claude 3.5 (new) 2024-10-22 → 3.7 / 4.0 / 4.5 / Opus 4.x - 安全机制：constitutional AI 风格的护栏 + 红队 + prompt-injection 防御 - 训练涉及人工演示 + 合成数据（system card 一般性陈述） **未公开 / 完全保密**： - 具体 RL 算法（PPO? GRPO? Critic-free? 都没说） - Reward signal 形式（task completion grader? Pair-wise preference? Safety classifier 权重?） - Train data 规模 / 来源 / 演示 vs 合成比例 - 是否有专门的 screenshot RM / VLM-as-judge **社区合理推测**（**仅推测，不要在面试中说成事实**）： - 可能是 RLHF on screenshot trajectories（pair-wise 偏好 + task success outcome 混合） - 可能 critic-free（呼应 DeepSeek-R1 GRPO 等开源趋势） - 可能用 VLM-as-judge for screenshot 理解 - 可能 curriculum 简单 → 复杂 **面试时务必区分 "公开能力" vs "推测内部"**：说"Anthropic 用 GRPO + screenshot RM"是错的（无证据）；说"我推测可能用了 critic-free RL，因为 Anthropic 在其他场景倾向 GRPO/RLHF 风格"才是诚实的表述。这种区分能力是高级面试的加分项。
Q25. 如果让你设计 next-gen Agentic RL 算法，会怎么改进？ 可能方向（任答 3-4 个，每个要有 trade-off 讨论）： 1. **Lightweight critic for long-horizon**: 不用 full-size value model，但用小型 step-level critic 缓解 trace-level credit dilution。VAPO 已尝试。Trade-off: 加显存 vs 缓解 long-trajectory 信号稀释 2. **Hierarchical reward**: subgoal-level reward + outcome reward 组合。Trade-off: 需要 subgoal definition（人工 or planner LLM），boundary 错画风险 3. **Off-policy correction with V-trace / Retrace**: rollout 慢，让 stale samples 也能用。Trade-off: IS bias vs sample efficiency 4. **Trajectory hindsight relabeling + RL**: 失败 trajectory 自动改造为 alternative task 的成功 trajectory，扩 data。Trade-off: 适用 open-ended task，不适用 closed-form answer 5. **Multi-task reward normalization**: 每个 task domain (math/code/web) 独立归一化，避免 reward scale 不平衡 6. **Reward model uncertainty**: 多 RM ensemble，min/mean-std 防 over-optimization。Trade-off: 算力 7. **Async distributed rollout**: rollout 与 train 完全异步，trajectory queue + worker pool。已是 industry default (verl, OpenRLHF v0.5+) 8. **Self-curriculum + adaptive difficulty**: WebRL 思路 + R-Zero 的 learnability reward 结合，自动找 model success rate ~50% 的任务 9. **Multi-objective Pareto optimization**: 不再单一 scalar reward，task success + safety + efficiency 同时优化，输出 Pareto front 只罗列 "加 attention / 加更多模型" 没 trade-off；或不知道 DAPO / VAPO / CISPO 等近期工作；或忽略 infra 层面 (async rollout) 的重要性。
## §A 附录：参考文献清单 按方向分组，论文经 web 检索 + arXiv 验证作者 / 年份 / 会议。少数 2025-2026 会议归属未定的论文以 arXiv 记。 **Agent SFT / 基础** - Zeng et al. 2023 arXiv 2310.12823 *AgentTuning: Enabling Generalized Agent Abilities for LLMs* (THU) - Chen et al. 2024 ACL Findings arXiv 2403.12881 *Agent-FLAN: Designing Data and Methods of Effective Agent Tuning for LLMs* - Trung et al. 2024 ACL arXiv 2401.08967 *ReFT: Reasoning with Reinforced Fine-Tuning* **RL on agent / reasoning（基础算法）** - Schulman et al. 2017 arXiv 1707.06347 *Proximal Policy Optimization Algorithms* - Schulman et al. 2016 ICLR *High-Dimensional Continuous Control Using GAE* - Shao et al. 2024 arXiv 2402.03300 *DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models*（GRPO 提出） - DeepSeek-AI 2025 arXiv 2501.12948 *DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning* - Yu et al. 2025 ByteDance arXiv 2503.14476 *DAPO: An Open-Source LLM Reinforcement Learning System at Scale* **Tool-augmented RL** - Qian et al. 2025 arXiv 2504.13958 *ToolRL: Reward is All Tool Learning Needs* (arXiv preprint; no formal venue as of 2026-05) - Chen et al. 2025 arXiv 2503.19470 *ReSearch: Learning to Reason with Search for LLMs via Reinforcement Learning* (accepted to **NeurIPS 2025**) - Wang et al. 2025 arXiv 2504.20073 *Understanding Self-Evolution in LLM Agents via Multi-Turn Reinforcement Learning* (RAGEN; StarPO = **S**tate-**T**hinking-**A**ctions-**R**eward Policy Optimization) **Web / GUI agent RL** - Qi et al. 2024 ICLR-25 arXiv 2411.02337 *WebRL: Training LLM Web Agents via Self-Evolving Online Curriculum Reinforcement Learning* - Putta et al. 2024 arXiv 2408.07199 *Agent Q: Advanced Reasoning and Learning for Autonomous AI Agents* - Furuta et al. 2024 ICLR arXiv 2305.11854 *Multimodal Web Navigation with Instruction-Finetuned Foundation Models* (WebGUM) **Code agent RL** - Le et al. 2022 NeurIPS arXiv 2207.01780 *CodeRL: Mastering Code Generation through Pretrained Models and Deep Reinforcement Learning* - Shojaee et al. 2023 arXiv 2301.13816 *Execution-Based Code Generation Using Deep Reinforcement Learning* (PPOCoder) - Wei et al. 2025 Meta FAIR arXiv 2502.18449 *SWE-RL: Advancing LLM Reasoning via Reinforcement Learning on Open Software Evolution* **Embodied / robot agent** - Baker et al. 2022 NeurIPS arXiv 2206.11795 *Video PreTraining (VPT): Learning to Act by Watching Unlabeled Online Videos* - Kim et al. 2024 arXiv 2406.09246 *OpenVLA: An Open-Source Vision-Language-Action Model* **Self-rewarding / exploration** - Yuan et al. 2024 ICML arXiv 2401.10020 *Self-Rewarding Language Models* - Andrychowicz et al. 2017 NeurIPS arXiv 1707.01495 *Hindsight Experience Replay* **RLHF / DPO 基础（cross-reference）** - Ouyang et al. 2022 NeurIPS *Training Language Models to Follow Instructions with Human Feedback* - Rafailov et al. 2023 NeurIPS *Direct Preference Optimization* - Bai et al. 2022 Anthropic arXiv 2212.08073 *Constitutional AI* - Lee et al. 2023 Google arXiv 2309.00267 *RLAIF: Scaling RLHF with AI Feedback* **Reward model / verification** - Lightman et al. 2024 ICLR arXiv 2305.20050 (OpenAI 2023) *Let's Verify Step by Step* (PRM800K) - Wang et al. 2024 ACL arXiv 2312.08935 *Math-Shepherd: Verify and Reinforce LLMs Step-by-Step without Human Annotations* - Coste et al. 2024 ICLR *Reward Model Ensembles Help Mitigate Overoptimization* **Infrastructure / framework** - TRL (HuggingFace): https://github.com/huggingface/trl —— 标准 PPO / DPO / GRPO trainer - OpenRLHF: https://github.com/OpenRLHF/OpenRLHF —— PPO / GRPO / RLOO 工业化实现 - verl (ByteDance): https://github.com/volcengine/verl —— GRPO / DAPO / agent RL 主流框架 - ReaLHF / AReaL (Ant Group + Tsinghua, async RL system, arXiv 2505.24298) **SOTA benchmarks (2024-2026)** - Jimenez et al. 2024 ICLR arXiv 2310.06770 *SWE-bench: Can Language Models Resolve Real-World GitHub Issues?* - Yao et al. 2024 arXiv 2406.12045 *τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains* - Xie et al. 2024 NeurIPS arXiv 2404.07972 *OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments* - Zhou et al. 2024 ICLR arXiv 2307.13854 *WebArena: A Realistic Web Environment for Building Autonomous Agents* - Mialon et al. 2024 ICLR *GAIA: A Benchmark for General AI Assistants* - Chan et al. 2024 arXiv 2410.07095 *MLE-bench: Evaluating Machine Learning Agents on Machine Learning Engineering* (OpenAI) **Anthropic Computer-Use（公开知识）** - Claude 3.5 Sonnet (new) 2024-10-22 Computer Use beta launch (Anthropic blog + system card) - Claude 3.7 / 4.0 / 4.5 / Opus 4.x system cards (Anthropic 公开) 代码框架建议： - 起步用 TRL（HF）的 GRPOTrainer + 自写 verifier - 工业化用 verl（GRPO/RLOO/DAPO 都支持，含 agent rollout） - 自研 multi-turn 用 OpenRLHF v0.5+ 的 agent example + 加 tool sandbox