wanshuiyin--auto-claude-code-research-in-sleep/docs/tutorials/agentic_rl_tutorial.md

§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 函数。

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——例如不写 <think> 块就直接 Action: answer(42)。Format reward 给一个轻量的格式约束信号：

def format_reward(trajectory) -> float:
    """
    检查 trajectory 是否符合预期格式 schema
    返回 [0, 1] 的连续 score
    """
    score = 0.0

    # 必须有 <think>...</think> 块
    if "<think>" in trajectory.text and "</think>" 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

给"调对工具"奖励、给"调错工具 / 重复调用"惩罚：

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：

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 版本：

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（State-Thinking-Actions-Reward 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 收集）

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=["</action>"],
            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>{obs}</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

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。

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（甚至包括 <obs> 标签本身）mask = 0
• 必须 cover all padding：右 pad 的位置 mask = 0
• separator token（如 <action>, </thought>）算 agent token，mask = 1
• multi-turn batch 里不同 trajectory 的 mask pattern 不同，必须 per-sample 算

7.4　GRPO group-relative reward on agent trajectories

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

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）

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，不只是 <think>
• 代表性工作 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

4. 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 = State-Thinking-Actions-Reward 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