Agentic Search + RL ：打通从RL原理到实际训练全流程

目录

结论

[一、先把传统 RL 和 Agentic Search 对上号](#一、先把传统 RL 和 Agentic Search 对上号)

[二、一次真正的 Agentic Search RL Rollout 是怎么发生的](#二、一次真正的 Agentic Search RL Rollout 是怎么发生的)

[三、然后 Reward 到底奖励谁？](#三、然后 Reward 到底奖励谁？)

[Credit Assignment](#Credit Assignment)

[四、Reward 并不是直接"加到模型参数上"](#四、Reward 并不是直接“加到模型参数上”)

[如果不 mask 会怎样？](#如果不 mask 会怎样？)

[五、现在来看 GRPO，你会容易很多](#五、现在来看 GRPO，你会容易很多)

[Trajectory A](#Trajectory A)

[Trajectory B](#Trajectory B)

[Trajectory C](#Trajectory C)

[Trajectory D](#Trajectory D)

[Group Relative Policy Optimization](#Group Relative Policy Optimization)

[六、所以 Group Size 是个什么东西？](#六、所以 Group Size 是个什么东西？)

[七、为什么必须 Sample 多条 Rollout？](#七、为什么必须 Sample 多条 Rollout？)

Exploration

[八、这里就出现第一个真正的 RL 工程难点：没有 Positive Rollout](#八、这里就出现第一个真正的 RL 工程难点：没有 Positive Rollout)

[Exploration Failure](#Exploration Failure)

[九、这就是为什么 SFT Cold Start 经常放在 RL 前面](#九、这就是为什么 SFT Cold Start 经常放在 RL 前面)

[十、但是 R1-Searcher 为什么能不做 SFT？](#十、但是 R1-Searcher 为什么能不做 SFT？)

[两阶段 Reward Curriculum](#两阶段 Reward Curriculum)

[Stage 1](#Stage 1)

[Stage 2](#Stage 2)

十一、这两个方案哪个更适合实际项目？

[推荐方案：SFT Cold Start + GRPO](#推荐方案：SFT Cold Start + GRPO)

[备选：Pure RL + Curriculum Reward](#备选：Pure RL + Curriculum Reward)

[十二、你现在需要掌握的 Agentic RL 核心名词](#十二、你现在需要掌握的 Agentic RL 核心名词)

[十三、你尤其需要真正理解 Advantage](#十三、你尤其需要真正理解 Advantage)

[十四、KL 又是在干什么？](#十四、KL 又是在干什么？)

[KL 太小](#KL 太小)

[KL 太大](#KL 太大)

[十五、Entropy 又是什么？](#十五、Entropy 又是什么？)

[高 entropy](#高 entropy)

[entropy collapse](#entropy collapse)

[十六、为什么仅看 Train Reward 完全不够？](#十六、为什么仅看 Train Reward 完全不够？)

[Reward--Metric Misalignment](#Reward–Metric Misalignment)

[十七、甚至 Accuracy 上升也不一定证明"Reasoning 能力增强"](#十七、甚至 Accuracy 上升也不一定证明“Reasoning 能力增强”)

[十八、因此判断 RL 是否有效，至少分成三层](#十八、因此判断 RL 是否有效，至少分成三层)

[十九、第一层：Training Health------RL 有没有正常训练](#十九、第一层：Training Health——RL 有没有正常训练)

[二十、一个典型的 Reward Hacking 现象](#二十、一个典型的 Reward Hacking 现象)

[二十一、所以生产 Agent 更合理的 Reward 长这样](#二十一、所以生产 Agent 更合理的 Reward 长这样)

[Trajectory A](#Trajectory A)

[Trajectory B](#Trajectory B)

[二十二、但 Cost Reward 也不能随便加](#二十二、但 Cost Reward 也不能随便加)

[Pareto Frontier](#Pareto Frontier)

[二十三、第二层：Policy Quality------模型到底学会搜索了吗？](#二十三、第二层：Policy Quality——模型到底学会搜索了吗？)

[Search Trigger](#Search Trigger)

[Query Quality](#Query Quality)

[二十四、Search Efficiency 指标非常重要](#二十四、Search Efficiency 指标非常重要)

[二十五、Stop Decision 是 Agentic Search 特有的重要指标](#二十五、Stop Decision 是 Agentic Search 特有的重要指标)

[二十六、第三层：End-to-End Utility](#二十六、第三层：End-to-End Utility)

[二十七、Agentic Search 的评估我建议分成五组](#二十七、Agentic Search 的评估我建议分成五组)

[二十八、真正证明"RL 有用"要怎么设计实验？](#二十八、真正证明“RL 有用”要怎么设计实验？)

[二十九、至少做这几个 Ablation](#二十九、至少做这几个 Ablation)

[三十、Outcome Reward 和 Process Reward 怎么选？](#三十、Outcome Reward 和 Process Reward 怎么选？)

[Outcome Reward](#Outcome Reward)

[Sparse Reward](#Sparse Reward)

[三十一、Process Reward 就是在中间打分](#三十一、Process Reward 就是在中间打分)

[三十二、推荐的 Reward 演进路线](#三十二、推荐的 Reward 演进路线)

三十三、一个完整实际训练项目会长这样

三十四、训练代码从工程视角大概长什么样

三十五、例如一个看起来不大的配置

[三十六、最后给你一个非常实用的"判断 RL 有没有训好"的 Dashboard](#三十六、最后给你一个非常实用的“判断 RL 有没有训好”的 Dashboard)

三十七、最重要的是看"能力---成本曲线"

[Search Policy Improvement](#Search Policy Improvement)

[三十八、再进一步用 Pass@k 判断 RL 到底"学会了"还是"把已有能力强化了"](#三十八、再进一步用 Pass@k 判断 RL 到底“学会了”还是“把已有能力强化了”)

[Before RL](#Before RL)

[After RL](#After RL)

[三十九、你现在可以把 Agentic Search RL 记成下面五句话](#三十九、你现在可以把 Agentic Search RL 记成下面五句话)

1.

2.

3.

4.

5.

[如果你要真正做一个 Agentic Search RL 项目](#如果你要真正做一个 Agentic Search RL 项目)

---

结论

你已经知道 RL 的基本概念后，理解 Agentic Search + RL 最关键的一步，是把视角从：

模型输出答案→Reward→更新参数\text{模型输出答案}\rightarrow Reward\rightarrow 更新参数

切换成：

模型执行一整条搜索轨迹→环境反馈→评价整条轨迹→强化更好的搜索策略\boxed{ \text{模型执行一整条搜索轨迹} \rightarrow \text{环境反馈} \rightarrow \text{评价整条轨迹} \rightarrow \text{强化更好的搜索策略} }

这里真正训练的不是"答案"，而是一个 Search Policy：

什么时候搜索、搜什么、看到结果以后下一步做什么、是否换 Query、是否继续搜索、什么时候停止并回答。

因此一个实际 Agentic Search RL 项目，核心可以归纳成：

Task
  ↓
Policy Model
  ↓
Rollout
  ↓
Search Environment
  ↓
Trajectory
  ↓
Reward / Verifier
  ↓
Advantage
  ↓
GRPO / PPO
  ↓
Policy Update

Search-R1 已经把这个问题明确建模成"LLM 与 Search Engine 交互产生 trajectory，然后对 LLM 自己生成的 token 做 policy optimization"；搜索引擎返回的 observation 不属于模型动作，因此训练时要 mask 掉。(arXiv)

---

一、先把传统 RL 和 Agentic Search 对上号

你以前学 RL 时可能是：

Agent
  ↓
State
  ↓
Action
  ↓
Environment
  ↓
Reward

放到 Agentic Search 里：

RL 名词	Agentic Search 中是什么
Agent	LLM
Policy πθ\pi_\theta	当前 LLM 参数决定的行为策略
State sts_t	Question + 当前推理 + 历史 Search Result
Action ata_t	Think / Search(query) / Browse / Answer
Environment	Retriever / Search Engine / Browser / Web
Observation	搜索返回文档、网页、snippet
Trajectory τ\tau	一整条 Think→Search→Observe→...→Answer
Episode	一道问题从开始到最终回答
Reward RR	最终答案、证据、工具效率等评价
Policy Update	PPO / GRPO 等更新 LLM 参数

所以：

πθ(at∣st)\pi_\theta(a_t|s_t)

在这里可以理解成：

给定"当前已经知道的信息"，LLM 下一步应该干什么？

例如：

State:

Question:
《哈利波特》作者丈夫创办的公司总部在哪里？

当前信息：
J.K. Rowling 的丈夫是 Neil Murray

↓

Policy：

<Search>
Neil Murray company founder
</Search>

这里：

<Search>...</Search>

本身就是 Action。

搜索结果则是：

<information>
...
</information>

它是：

Environment Observation

而不是 Policy 自己生成的内容。

这个区别后面训练时非常重要。

---

二、一次真正的 Agentic Search RL Rollout 是怎么发生的

这是你现在最应该真正理解的部分。

假设训练样本：

{
  "question": "Which university did the founder of company X graduate from?",
  "answer": "Stanford University"
}

当前模型开始 rollout：

Question
   ↓
<think>
I need to identify the founder first.
</think>

<search>
company X founder
</search>

程序检测到：

</search>

于是暂停 LLM generation。

调用：

docs = search_engine("company X founder")

把搜索结果插进去：

<information>
Company X was founded by Alice Smith...
</information>

注意：

这段不是模型生成的。

然后继续：

<think>
The founder is Alice Smith.
Now I need her educational background.
</think>

<search>
Alice Smith education university
</search>

环境再返回：

<information>
Alice Smith graduated from Stanford University...
</information>

继续：

<think>
Now I have enough evidence.
</think>

<answer>
Stanford University
</answer>

最终得到：

τ=(s0,a0,o1,s1,a1,o2,...,aT)\tau = (s_0,a_0,o_1,s_1,a_1,o_2,\dots,a_T)

也就是一整条 Trajectory。

Search-R1 的 rollout 就是这种机制：模型生成 <search> 后暂停，调用搜索引擎，把结果插入 <information>，再继续生成；直到产生 <answer> 或达到最大 action budget。(arXiv)

---

三、然后 Reward 到底奖励谁？

假设最终答案正确：

Stanford University

最简单：

R=1R=1

错误：

R=0R=0

Search-R1 就使用过这种非常简单的 Outcome Reward：

R=EM(apred,agold)R = EM(a_{pred},a_{gold})

也就是最终答案 Exact Match。(arXiv)

问题来了：

最终 Reward 是 1，但前面可能生成了 500 个 token，究竟哪些 token 做得好？

这就是：

Credit Assignment

强化学习里的核心问题之一。

---

四、Reward 并不是直接"加到模型参数上"

实际流程更接近：

Trajectory
     ↓
Reward
     ↓
Advantage
     ↓
Token Log Probability
     ↓
Policy Gradient
     ↓
更新参数

例如模型产生：

<think>...</think>
<search>company X founder</search>
<think>...</think>
<search>Alice Smith university</search>
<answer>Stanford University</answer>

这些都是：

Policy generated tokens

所以可以优化。

但是：

<information>
Alice Smith graduated...
</information>

是搜索引擎生成的。

所以：

loss_mask = 0

Search-R1 专门提出 Retrieved Token Loss Masking ：只计算 LLM 自己生成 token 的 RL loss，搜索结果 token 不参与梯度更新。(arXiv)

工程上可以理解成：

loss_mask = [
    1,1,1,1,  # think
    1,1,1,    # search query

    0,0,0,0,0,0,  # search result

    1,1,1,1,  # think
    1,1,1      # answer
]

如果不 mask 会怎样？

模型会被要求：

"提高搜索引擎返回的这些 token 的概率。"

但这些 token 根本不是模型生成的。

于是梯度语义就是错的，还会干扰训练。

---

五、现在来看 GRPO，你会容易很多

你之前可能看到 GRPO：

Ai=Ri−μRσRA_i = \frac{R_i-\mu_R}{\sigma_R}

不知道实际有什么意义。

放到 Search Agent 就很直观了。

对于同一道题：

Question Q

让模型 rollout 4 次：

Trajectory A

不搜索
直接猜答案
Wrong

Reward = 0

Trajectory B

Search 1次
Query很差
Wrong

Reward = 0

Trajectory C

Search 2次
合理拆解
Correct

Reward = 1

Trajectory D

Search 4次
最终Correct

Reward = 1

GRPO：

Group:

[0, 0, 1, 1]

平均：

μ=0.5\mu=0.5

于是大体上：

A → negative advantage
B → negative advantage

C → positive advantage
D → positive advantage

含义就是：

同一道题里，C 和 D 的策略比 A/B 好。

于是训练：

增加 C / D trajectory 中 action 的概率

降低 A / B trajectory 中 action 的概率

这就是：

Group Relative Policy Optimization

GRPO 不一定需要 PPO 那个单独的 critic/value model，而是用同一问题多个 rollout 的组内 reward 作为 baseline。Search-R1 同时实验了 PPO 和 GRPO：报告中 GRPO 收敛更快，但他们的实验里 PPO 更稳定，GRPO 长训练可能出现 reward collapse；两者最终结果相近。(arXiv)

---

六、所以 Group Size 是个什么东西？

假设：

group_size = 8

意味着：

每一道 Question，同一个当前 Policy rollout 8 条不同轨迹。

例如：

                Question
                   │
     ┌─────┬─────┬─────┬─────┐
     ↓     ↓     ↓     ↓     ↓
    τ1    τ2    τ3    ...    τ8
     ↓     ↓     ↓            ↓
    0     1     0.7          0

GRPO比较：

哪条 trajectory 比同组平均水平好？

而不是单纯：

reward 是否 > 0

---

七、为什么必须 Sample 多条 Rollout？

因为强化学习的核心之一就是：

Exploration

同一个问题：

What company...

模型可能：

Trajectory 1:
直接回答

Trajectory 2:
先搜人物

Trajectory 3:
先搜公司

Trajectory 4:
搜完整问题

Trajectory 5:
分解multi-hop

Trajectory 6:
搜索→验证→搜索

...

RL 的本质就是：

让模型自己探索这些策略，然后通过 reward 判断哪些策略值得提高概率。

---

八、这里就出现第一个真正的 RL 工程难点：没有 Positive Rollout

假设模型很弱。

一道题 rollout 8 次：

Reward:

0
0
0
0
0
0
0
0

GRPO：

Ri−Rˉ=0R_i-\bar R = 0

于是：

Ai≈0A_i\approx0

模型得到的信息基本就是：

我不知道谁好谁坏。

这就是现在 LLM RL 很重要的问题：

Exploration Failure

或者：

zero-reward problem

---

九、这就是为什么 SFT Cold Start 经常放在 RL 前面

工程上我更推荐：

Base Model
     ↓
Trajectory SFT
     ↓
模型至少会：
  Search
  Tool Calling
  Basic Reasoning
     ↓
RL
     ↓
学习更好的 Search Policy

WebDancer 的训练 pipeline 就是：

Browsing Data Construction
        ↓
Trajectory Sampling
        ↓
SFT Cold Start
        ↓
RL

(arXiv)

原因非常实际：

如果没有 SFT：

Base Model
 ↓
根本不会生成正确 <search>
 ↓
Search Engine没被调用
 ↓
所有 rollout 错误
 ↓
Reward全0
 ↓
RL学不到东西

而 SFT 后：

8 rollouts

0
0
1
0
1
0
0
1

GRPO终于有：

positive vs negative

可以学习。

---

十、但是 R1-Searcher 为什么能不做 SFT？

这是一个很好的对比例子。

R1-Searcher 采取：

两阶段 Reward Curriculum

Stage 1

先不要求答案正确。

只奖励：

你有没有正确调用 Search？

例如：

Rretrieval={0.5,search≥10,search=0R_{retrieval}= \begin{cases} 0.5,& search\ge1\\ 0,& search=0 \end{cases}

再加格式 reward。

模型先学会：

"原来我可以搜索"

Stage 2

把 retrieval reward 去掉。

改成：

Answer Reward
+
Format Reward

开始要求：

搜索不是目的，最终解决问题才是目的。

R1-Searcher 就是利用这种两阶段 outcome-based RL，不依赖 SFT cold start。(arXiv)

---

十一、这两个方案哪个更适合实际项目？

推荐方案：SFT Cold Start + GRPO

Trajectory Data
 ↓
SFT
 ↓
GRPO

优点：

• 稳定

• rollout positive rate 高

• 工具格式容易学

• RL 可以专注于"策略优化"

代价：

• 要有 trajectory 数据

• SFT 可能把模型限制在 teacher 的行为分布附近

---

备选：Pure RL + Curriculum Reward

类似 R1-Searcher：

Stage 1
学会 Search

↓

Stage 2
学会用 Search 解决问题

适合：

• 想研究 RL emergence

• 不想依赖 teacher trajectory

• 有足够算力做探索

问题：

• 更容易训练不起来

• reward engineering 更重要

• rollout 成本更大

对于普通工程项目，我不会优先 Pure RL。

---

十二、你现在需要掌握的 Agentic RL 核心名词

下面这张表建议真正搞懂。

名词	实际含义	Agentic Search 示例
Policy	当前模型行为策略	LLM 决定搜还是答
Reference Policy	RL 前模型	SFT checkpoint
Rollout	模型自己跑一次任务	一条完整搜索轨迹
Trajectory	状态+动作+观察序列	Think→Search→Result→Answer
Environment	Agent 所交互环境	Search Engine
Action	Agent 控制的行为	Search Query
Observation	Environment 返回的信息	Search Results
Reward	行为评价信号	Answer correctness
Advantage	这次表现比 baseline 好多少	GRPO group-relative score
Policy Gradient	增强好行为，削弱坏行为	提升好 Search query 概率
KL Divergence	新 Policy 离旧 Policy 多远	防止 RL 把模型训坏
Entropy	Policy 行为多样性	是否还会探索不同搜索路径
On-policy	用当前模型产生 rollout	当前 checkpoint 在线搜索
Off-policy	用其他模型/旧模型数据训练	Teacher trajectory
Outcome Reward	只评价最终结果	Final answer EM
Process Reward	评价中间步骤	Query质量、证据质量
Sparse Reward	大部分步骤没有反馈	直到最终答案才知道对错
Credit Assignment	功劳应该归哪个 action	哪次 Search 真正有用
Reward Hacking	钻 Reward 规则漏洞	疯狂 Search 提高命中率
Curriculum	从简单任务逐渐变难	先学调用Search再学multi-hop
Verifier	判断结果好坏的系统	EM / Rule / LLM Judge
Action Budget	最大工具调用次数	最多 Search 8 次

---

十三、你尤其需要真正理解 Advantage

Reward：

这条轨迹总体有多好。

Advantage：

这条轨迹比"正常表现"好多少。

这两个不要混。

例如：

R = 0.8

不意味着一定增强。

假如同组：

0.95
0.92
0.90
0.80

那么：

0.80

其实是组里最差。

所以：

A<0A<0

反而要降低概率。

这就是 GRPO 的"Relative"。

---

十四、KL 又是在干什么？

假设 RL 发现：

疯狂搜索

可以提高 reward。

模型可能从：

Search 2次

慢慢变成：

Search 15次

甚至语言能力开始退化。

所以通常有：

L=LRL+βDKL(πθ∥πref)L = L_{RL} + \beta D_{KL}( \pi_\theta \Vert \pi_{ref} )

其中：

πθ = 当前RL模型
πref = RL之前模型

KL 的意思：

可以学新的 Search Policy，但别突然把整个语言模型分布推得太远。

KL 太小

可能：

Policy Drift
Reward Hacking
语言退化
格式异常

KL 太大

模型：

"我被绑死了，根本学不到新策略。"

---

十五、Entropy 又是什么？

可以简单理解：

模型还愿不愿意尝试不同策略。

例如：

高 entropy

Search A
Search B
Search C
直接回答
验证Search
...

很多可能。

entropy collapse

变成：

不管什么问题：

Search → Search → Search → Answer

模型学成一个固定模板。

这也是 RL 很危险的一种现象。

---

十六、为什么仅看 Train Reward 完全不够？

这是你评估强化学习时最需要记住的一点：

Training Reward ↑ 并不能证明能力 ↑。

例如：

Before RL:

Accuracy = 70%
Search = 2.1 calls


After RL:

Accuracy = 74%
Search = 13.7 calls

Reward 如果只看 accuracy：

RL成功！

但产品上：

Latency × 5
Search cost × 6
Token × 4

可能根本不可接受。

这就是：

Reward--Metric Misalignment

---

十七、甚至 Accuracy 上升也不一定证明"Reasoning 能力增强"

这是现在 RLVR 研究中一个值得注意的结论。

2025 年 NeurIPS 的一项系统研究发现，在其研究的 math/code/vision reasoning 设置中，RLVR 经常主要提高：

从原有模型分布中采到正确 reasoning path 的概率。

也就是：

Before:

正确路径 probability = 5%

After RL:

正确路径 probability = 40%

不一定意味着模型真正发现了 base model 原来完全不存在的新 reasoning pattern。该工作通过比较 pass@1 与大 kk 的 pass@k 等方式提出，当前 RLVR 很大程度可能是在做 distribution sharpening 。(NeurIPs Papers)

这个观察放到 Agentic Search 非常有价值。

---

十八、因此判断 RL 是否有效，至少分成三层

我建议实际项目永远分：

① Training Health

② Policy Quality

③ End-to-End Utility

不要混在一起。

---

十九、第一层：Training Health------RL 有没有正常训练

首先看训练本身有没有坏。

核心指标：

Metric	看什么
Mean Reward	总体训练信号
Reward Std	rollout 是否有区分度
Positive Rollout Rate	有多少轨迹成功
Zero Reward Rate	是否大量任务完全学不到
KL	Policy drift
Entropy	Exploration
Response Length	是否长度膨胀
Search Count	是否疯狂搜索
Invalid Action Rate	Tool syntax 是否异常
Clip Fraction	PPO/GRPO update 是否过猛
Gradient Norm	是否训练不稳定

尤其要关注：

Reward ↑
同时

KL ↑↑
Entropy ↓↓
Length ↑↑
Search Count ↑↑

这种情况很可能不是能力真正提高。

---

二十、一个典型的 Reward Hacking 现象

假设 reward：

R=AnswerCorrectR=AnswerCorrect

模型发现：

Search 1次 → 65%正确

Search 5次 → 75%

Search 20次 → 80%

于是 RL 很自然会学：

Search as much as possible

这不是 RL 出 bug。

相反：

它非常忠实地优化了你给它的目标。

有问题的是 reward。

---

二十一、所以生产 Agent 更合理的 Reward 长这样

不是：

R=RanswerR=R_{answer}

而是：

R=Ranswer+λ1Revidence+λ2Rcitation+λ3Rinstruction−λ4Csearch−λ5Ctoken−λ6Clatency\boxed{ R = R_{answer} + \lambda_1R_{evidence} + \lambda_2R_{citation} + \lambda_3R_{instruction} - \lambda_4C_{search} - \lambda_5C_{token} - \lambda_6C_{latency} }

例如：

reward = (
    1.0 * answer_correct
    + 0.3 * evidence_quality
    + 0.2 * citation_correctness
    - 0.03 * search_calls
    - 0.00001 * total_tokens
)

于是：

Trajectory A

Correct
2 searches

R = .94

Trajectory B

Correct
10 searches

R = .70

RL 就会偏向 A。

---

二十二、但 Cost Reward 也不能随便加

假设：

reward -= 0.2 * search_count

惩罚太强。

模型可能学成：

"不搜索最省钱。"

最终：

Search Count ↓↓↓

Accuracy ↓↓↓

所以实际不是找：

max⁡Accuracy\max Accuracy

而更像寻找：

Pareto Frontier

          Accuracy
             ↑
             │            ●
             │       ●
             │    ●
             │ ●
             └────────────────→ Cost

你希望得到：

在相同 Accuracy 下更便宜；

或者：

在相同 Cost 下 Accuracy 更高。

---

二十三、第二层：Policy Quality------模型到底学会搜索了吗？

这一层非常容易被忽略。

最终答案正确不能证明 Search Policy 好。

需要单独检查：

Search Trigger

模型什么时候选择 Search？

可以定义：

SearchPrecisionSearchPrecision

例如：

需要 Search 的问题：

100题

模型真正 Search：

92

同时简单问题不必要 Search：

100题中只Search 15题

这才说明：

when-to-search

学得不错。

---

Query Quality

例如模型搜索：

"tell me everything about Apple"

和：

"Apple FY2025 Greater China revenue annual report"

完全不是一个质量。

可以看：

Recall@K
Hit@K
MRR
nDCG

以及最终 evidence coverage。

---

二十四、Search Efficiency 指标非常重要

至少建议记录：

Avg Search Calls
Median Search Calls
P95 Search Calls

Success@1 Search
Success@3 Search
Success@5 Search
Success@10 Search

比如：

模型	EM	Avg Search
SFT	61%	4.2
RL-A	69%	11.8
RL-B	67%	4.5

我反而可能更喜欢：

RL-B

因为：

+6 Accuracy
+0.3 Search

工程性好很多。

---

二十五、Stop Decision 是 Agentic Search 特有的重要指标

一个 Search Agent 还必须学：

什么时候够了。

可以记录：

premature_stop_rate

还没证据就结束。

以及：

over_search_rate

证据已经充分还继续搜。

这两个其实分别对应：

Under-search
Over-search

理想是：

Need info → Search

Enough info → Stop

这正是 Search Policy 的关键。

---

二十六、第三层：End-to-End Utility

最后才看最终业务指标。

对于 QA 型 Agentic Search：

Exact Match
F1
Accuracy
LLM-as-Judge

Search-R1 主要使用 EM；R1-Searcher 在训练阶段使用 answer F1，并在评估中使用 Cover Exact Match 和 LLM-as-Judge。(arXiv)

但 Deep Research 类型应该增加：

Evidence Coverage
Citation Correctness
Citation Completeness
Source Quality
Factuality
Report Completeness
Instruction Following

而不能只看 short-answer EM。

---

二十七、Agentic Search 的评估我建议分成五组

这是实际项目比较成熟的一套方式：

维度	Metric
Answer	EM / F1 / Judge Accuracy
Retrieval	Recall@K / nDCG / Evidence Recall
Policy	Search Trigger / Stop Accuracy / Repetition
Efficiency	Tool Calls / Tokens / Latency / Cost
Robustness	OOD / Noisy Retrieval / Online Web

最终形成：

Score=f(Quality,Search,Evidence,Cost,Robustness)Score = f( Quality, Search, Evidence, Cost, Robustness )

而不是：

Reward ↑ = success

---

二十八、真正证明"RL 有用"要怎么设计实验？

这里很重要。

至少应该有：

Base Model
        ↓

SFT Model
        ↓

SFT + RL

三组。

并且保证：

Same Backbone
Same Retriever
Same Corpus
Same Search Top-K
Same Tool Budget
Same Prompt
Same Evaluation Set

Search-R1 的主要比较就特别控制了 retriever、retrieved documents、corpus、training data 和 pretrained LLM 等变量。(arXiv)

否则：

RL模型用了更强Retriever

Baseline用了旧Retriever

得到：

+10 accuracy

根本不能说明 RL 有效。

---

二十九、至少做这几个 Ablation

假设：

SFT = 60
SFT + RL = 70

不要就结束。

继续：

① SFT
60

② SFT + RL
70

③ SFT + RL without search
62

④ SFT + RL answer reward only
68

⑤ SFT + RL answer + cost
69

⑥ SFT + RL process reward
71

这样才能知道：

增益到底来自 Search、RL、Reward，还是单纯多生成 token。

---

三十、Outcome Reward 和 Process Reward 怎么选？

这是 Agent RL 现在非常核心的争论。

Outcome Reward

只看：

Final Answer

例如：

R=EMR=EM

优点：

简单
便宜
客观
不容易引入中间标注偏见

Search-R1 就证明简单 outcome reward 已经可以学出不错的多轮搜索能力。(arXiv)

问题：

Sparse Reward

假设：

Search A
 ↓
Search B
 ↓
Search C
 ↓
Search D
 ↓
Wrong Answer

最终：

Reward=0

但：

Search A可能很好
Search B也很好
Search C错了

Outcome reward 完全不知道。

---

三十一、Process Reward 就是在中间打分

例如：

Query Generation
       ↓
reward = 0.8

Evidence Retrieval
       ↓
reward = 1

Reasoning
       ↓
reward = 0.6

Final Answer
       ↓
reward = 1

于是：

R=Rquery+Revidence+Rreasoning+RanswerR = R_{query} + R_{evidence} + R_{reasoning} + R_{answer}

优势：

Credit Assignment 容易很多。

ReasonRAG 这类工作就专门研究了 Agentic RAG 中 process reward 对 query generation、evidence extraction 和 answer generation 的细粒度监督，并报告了较好的数据效率。(NeurIPs Papers)

但问题是：

谁来判断 intermediate step 是对的？

你又需要：

PRM
Verifier
LLM Judge
Rule
Ground Truth Evidence

复杂度迅速增加。

所以工程上我不会一开始就做复杂 PRM。

---

三十二、推荐的 Reward 演进路线

比较稳：

V0

Answer Reward

先证明：

RL pipeline works

然后：

V1

Answer
+
Format

然后：

V2

Answer
+
Search Cost

然后：

V3

Answer
+
Evidence
+
Search Cost

最后才考虑：

V4

Process Reward
+
Rubric Reward
+
Verifier

不要一上来搞：

8个reward
+ PRM
+ LLM judge
+ dynamic weights

最后连模型为什么变好都解释不出来。

---

三十三、一个完整实际训练项目会长这样

现在把前面的东西合起来。

                    Training Dataset
                          │
                          ↓
                  Question + GT Answer
                          │
                          ↓
                    Policy Model
                          │
            ┌─────────────┴─────────────┐
            ↓                           ↓
        rollout 1                   rollout G
            │                           │
            ↓                           ↓
        reasoning                   reasoning
            │                           │
            ↓                           ↓
          search                       search
            │                           │
            └─────────┐       ┌─────────┘
                      ↓       ↓
                   Search Environment
                         │
                         ↓
                    Observation
                         │
                         ↓
                Continue Generation
                         │
                         ↓
                     Answer
                         │
                         ↓
                Reward Function
                         │
                         ↓
              Group Relative Reward
                         │
                         ↓
                    Advantage
                         │
                         ↓
                  GRPO Objective
                         │
          ┌──────────────┴──────────────┐
          ↓                             ↓
    Policy Gradient                    KL
          │                             │
          └──────────────┬──────────────┘
                         ↓
                  Model Update
                         │
                         ↓
                   New Policy

然后不断重复：

Rollout
→ Reward
→ Update
→ Rollout
→ Reward
→ Update

这才是"Agent RL training loop"。

---

三十四、训练代码从工程视角大概长什么样

不是完整实现，但你应该能理解结构：

for batch in dataloader:

    trajectories = []

    for question in batch:

        group = []

        for _ in range(group_size):

            traj = rollout(
                policy=model,
                question=question,
                environment=search_engine,
                max_actions=8
            )

            reward = reward_fn(
                trajectory=traj,
                ground_truth=question.answer
            )

            group.append((traj, reward))

        trajectories.append(group)

    advantages = compute_group_advantage(
        trajectories
    )

    loss = grpo_loss(
        model=model,
        old_policy=old_model,
        ref_policy=ref_model,
        trajectories=trajectories,
        advantages=advantages,
        mask_environment_tokens=True
    )

    loss.backward()

    optimizer.step()

这里真正费钱的往往不是：

loss.backward()

而是：

rollout()

因为一次 rollout 中可能：

LLM generate
Search
LLM generate
Search
LLM generate
Search
LLM generate

再乘：

Batch
× Group Size

这就是 Agent RL 昂贵的根本原因之一。

---

三十五、例如一个看起来不大的配置

Batch = 64 questions

GRPO Group Size = 8

Average Search = 4

那么每一步：

64×8=51264\times8=512

条完整 Agent trajectories。

搜索请求：

512×4=2048512\times4=2048

次。

一次 optimizer step 就可能对应 2048 次 Search。

所以真实项目中：

Rollout Throughput
Search Environment Throughput
vLLM serving
Trajectory scheduling
Caching

会非常重要。

Search-R1 的实验中也专门使用 vLLM 做 rollout，并配置 action budget、group responses、retrieval passages 等参数；这已经体现了 Agent RL 与普通 SFT 在系统工程上的差异。(arXiv)

---

三十六、最后给你一个非常实用的"判断 RL 有没有训好"的 Dashboard

如果我做一个 Agentic Search RL 实验，我不会只画：

Train Reward

而至少同时监控：

                    RL Dashboard

Quality
├── Val EM / F1
├── OOD EM / F1
├── Evidence Recall
└── Citation Accuracy

Policy
├── Avg Search Calls
├── Valid Search Rate
├── Duplicate Query Rate
├── Premature Stop Rate
└── Over-search Rate

RL
├── Train Reward
├── Reward Std
├── Positive Rollout Rate
├── KL
├── Entropy
└── Clip Fraction

Efficiency
├── Output Tokens
├── Retrieved Tokens
├── Tool Calls
├── Latency
└── Cost / Correct Answer

Generalization
├── IID
├── OOD
├── Hard Tasks
├── Noisy Retrieval
└── Real Web

---

三十七、最重要的是看"能力---成本曲线"

最终我最建议比较：

Success@Budget\boxed{ Success@Budget }

例如：

Search Budget	SFT	SFT+RL
1	45%	52%
2	54%	63%
4	61%	72%
8	68%	75%

这比：

SFT: 68%
RL: 75%

有意义得多。

因为它说明：

RL 模型不是单纯靠多搜，而是在相同 Search Budget 下也更会搜。

这才是真正的：

Search Policy Improvement

---

三十八、再进一步用 Pass@k 判断 RL 到底"学会了"还是"把已有能力强化了"

例如：

Before RL

pass@1 = 25%
pass@8 = 75%

说明：

Base Model 其实能找到正确策略，只是经常选错。

After RL

pass@1 = 65%
pass@8 = 77%

那很可能：

RL 主要把已有的正确策略概率提高了。

即：

Distribution Sharpening

而如果：

Before:

pass@64 = 30%

After:

pass@64 = 70%

才更有理由怀疑：

Policy 的有效行为分布真正扩大了。

当然这仍然需要更严格分析，而不能单靠一个指标下结论。当前 RLVR 文献也在强调这种区分。(NeurIPs Papers)

---

三十九、你现在可以把 Agentic Search RL 记成下面五句话

这是我认为你现阶段应该建立的核心模型：

1.

Trajectory 是 RL 真正的数据单位。

不是：

Question → Answer

而是：

Question
→ Think
→ Search
→ Observation
→ Think
→ Search
→ Answer

---

2.

Rollout 是 RL 最核心、也最昂贵的计算过程。

SFT：

给定标准答案 → 算 loss

RL：

模型自己探索 → 调环境 → 得结果 → 打 reward → 再算 loss

---

3.

Reward 决定模型最终学会什么，而不是你希望它学会什么。

你奖励：

Accuracy

模型可能学：

疯狂搜索

你奖励：

Search少

模型可能学：

不搜索

所以 reward 本质是：

把产品目标数学化。

---

4.

GRPO 的核心不是公式，而是"同一道题多个 rollout 相互比较"。

Question

→ τ1
→ τ2
→ τ3
→ τ4

↓

谁比平均表现好？

↓

提高对应行为概率

---

5.

判断 RL 成功，绝不能只看 Reward。

至少要证明：

Quality↑+Efficiency↓̸+OOD↑\boxed{ Quality\uparrow \quad + \quad Efficiency\not\downarrow \quad + \quad OOD\uparrow }

最好进一步证明：

Success@SameBudget↑\boxed{ Success@SameBudget\uparrow }

---

如果你要真正做一个 Agentic Search RL 项目

我会推荐第一版直接采用：

Qwen / Llama Base or Instruct
        ↓
Trajectory SFT
        ↓
Frozen Local Search Environment
        ↓
GRPO
        ↓
Outcome Reward
        ↓
Answer + Search Cost Reward
        ↓
OOD Evaluation

先不要上 Real Web RL、PRM、复杂 Rubric、多 Agent RL。

第一阶段真正应该验证的实验只有一个：

在完全相同 backbone、retriever、corpus 和 search budget 下，SFT + RL 是否比 SFT 获得更高的 Success@Budget。

如果这个实验成立，你才能说：

RL 确实优化了 Agent 的搜索策略。

如果只是：

Train Reward 0.3 → 0.8

或者：

Accuracy 60 → 70
Search 3 → 15

都还不足以证明这件事。

下一层你就可以继续深入到 "GRPO 在 Agentic Search 中的一次参数更新究竟怎么算：从 8 条 rollout 的 reward → advantage → token logprob → loss → backward"。把这一层真正算一遍之后，GRPO、PPO、RLVR、trajectory 这些概念基本就会连起来。