Agentic RL 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

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 表述

      ┌──────────────────────────────┐
      │   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 邻居的关系

• (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()。

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$。

• 省 value model（一份显存）
• 省 per-token credit assignment（trace-level advantage）
• 省 reward shaping（rule-based terminal 就够）
• 省 hyperparameter（$c_v, \lambda$ 都不需要）

• 长 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

面试 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

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]

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 思路）

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

经典做法：

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% 的任务（最有学习信号）

§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%。

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(),
    }

• 必须 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

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 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 群像

§9 Failure modes & 工程经验

9.1　Agentic RL 的"七宗罪"

9.2　Online vs offline RL trade-off

实践建议：从 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 题）

L2 进阶题（10 题）

L3 顶级 lab 题（5 题）

§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