Reinforcing Recursive Language Models

Blog: Reinforcing Recursive Language Models Code: NovaSky-AI/SkyRL, PR #1596 Code reference: main @ ecdaa946 (2026-05-20)；博客链接的 PR #1596 已合并，PR head 为 rlms@66027d6c。 Published: 2026-05-13

1. Motivation（研究动机）

这篇 alphaXiv 博客讨论的是一个很具体的工程问题：Recursive Language Model（RLM）作为一种 inference-time scaling / agent scaffold 很有潜力，但如果只靠提示词和 frontier model，它的 latency、稳定性、成本和 prompt-tuning 负担都不适合生产化；如果换成小模型，4B 级别模型又很难天然掌握“在 REPL 中递归分解任务、调用子 RLM、汇总结果”的行为。因此作者尝试用 RL fine-tuning 让 Qwen3.5-4B 这类小模型变成 task-specific、native 的 RLM policy。

RLM 的基本思想是：不要把所有长上下文直接塞进 LM context window，而是把 context 作为外部对象放在 programmatic environment 里。模型每一轮写代码，REPL 执行代码，再把 print() 或工具结果作为下一轮消息返回。模型可以用代码搜索、切片、抽取上下文，也可以通过 rlm_query 或 rlm_query_batched 递归调用同一个模型，派生出 child RLM 去处理子任务。这样，RLM 不只是“会调用工具的 LLM”，而是把 code execution 当作主要接口，让模型以程序化方式管理 long-context 和可并行任务。

生产难点在于，RLM 的行为不是普通 chat model 通过一段 prompt 就能稳定掌握的。模型要学会多轮 REPL 语法、变量管理、何时 FINAL、何时 FINAL_VAR、如何把 root task 分解为 child prompts、如何处理 child answers，再把它们聚合为最终答案。大型模型如 Claude Sonnet 4.6 可以通过 detailed strategy prompt 做到，但 rollout 慢且昂贵；小模型即使有工具说明和 prompt，初始 pass@16 也可能是 0，因为 RLM tasks 对小模型来说在“edge of competence”之外。

本文要解决的具体目标是：能否用 RL 训练一个 4B 共享 policy，让它同时扮演 root decomposer 与 child sub-agent，而不是分别训练 parent policy 和 child policy？如果能做到，就可以用一个便宜模型在同一 RLM harness / REPL environment 中完成 evidence selection，并接近 frontier model 的效果。

这个问题值得研究有三个原因。第一，RLM 的优势不只来自 long context，还来自 parallel decomposition：即使上下文本身不极长，只要任务可拆分，root RLM 派发多个 child RLM 就可以减少 wall-clock latency，并避免 sequential reasoning 的 prefix trap。第二，现代 reasoning model 的经验表明，CoT / ReAct 等提示策略真正大规模起飞往往需要 RL，而不只是 prompting；如果 RLM 是下一类 inference scaling 形态，就需要回答“怎么训练 RLM-native models”。第三，reward assignment 在 recursive tree 中并不显然：root 做 paper selection，child 做 evidence extraction，最终 reward 只在整棵树上可见，如何把这个 reward 传给 child trajectories 是本文的方法核心。

2. Idea（核心思想）

核心思想是：不要把 root RLM 和 child RLM 当作两个模型训练，而是让同一个 policy 在同一个 REPL/RLM scaffold 中同时学习 parent 和 child 角色；训练时只对 root rollout 计算任务 reward，再让 child rollouts 继承 parent 的 group-relative advantage。这样，child 没有单独 reward label 也能被训练，因为 child 的行为是否有用会通过 parent 最终答案的 reward 反映出来。

作者的方法可以看作“把 GRPO 扩展到 RLM tree”。对每个 query，采样一组 root rollouts；每个 root rollout 可能通过 rlm_query / rlm_query_batched 产生若干 child prompts，child rollouts 也由同一个 old policy 采样。root rollouts 得到 rubric-based reward 后，在 group 内归一化成 advantage $A_g$；属于 root rollout $g$ 的每个 child rollout 都继承这个 $A_g$。为了避免一个 root 因为派发了很多 child 就在梯度里被过度加权，child losses 会按 child 数量 $k_g$ 平均。

与原始 RLM 论文中“root 用可训练模型、sub-call 用 frozen model”的方案不同，这里 child 也是同一个可训练 policy。作者认为这很关键：既然 SFT 后的 4B 模型无法稳定完成 child evidence-selection task，仅训练 root 而冻结 child 不够；必须让模型在 root 和 child 两种状态分布上都接受 on-policy RL。

与普通 agent RL 的根本差异是，RLM rollout 不是一条平坦 trajectory，而是一棵 execution tree。root 的每个 REPL turn 可能注册多个 child rollouts，child 自己也可以继续调用更深层 child。本文实验只形式化到 max depth 1，但给出可递归扩展的 subtree loss。更深层的情形下，每个 node 的 loss 加上 children subtree losses 的平均，就形成一棵递归训练目标。

3. Method（方法）

3.1 RLM scaffold：REPL 是主要交互界面

RLM 被放在 Python REPL 环境中。每一轮模型输出一个 fenced code block，REPL 执行代码，环境把执行结果作为下一轮 observation。与“tool call 是聊天模型的附属功能”不同，RLM 把 code / variables / programmatic search 作为 context interaction 的主路径。博客中列出三个核心 RLM 内置函数：

• FINAL(answer) / FINAL_VAR(variable_name)：结束 rollout。前者直接把字符串作为最终答案，后者从 REPL 变量表中取值作为最终答案。
• rlm_query(prompt, context=None)：生成一个 child RLM rollout，child 使用同一 policy 和新的 agent loop，返回 child final answer。
• rlm_query_batched(prompts, context_list=None)：并行派发多个 child RLM，每个 prompt 对应一个 context，返回一组 child answers。

在 evidence selection 环境中，又额外暴露四个 paper-aware tools：

• list_papers(ctx)：列出 context dict 中所有 paper 的 ID、title、abstract。
• search(text, keyword, window=300, bidirectional=True)：按关键词搜索单篇或多篇 paper，返回 sentence-aligned snippets。
• extract_section(snippet, start_phrase, end_phrase)：从 snippet 中按 start/end phrase 精确抽取可引用证据 span。
• get_paper_abstract(ctx, paper_id)：取单篇 paper 的 ID、title、abstract，用于给 child prompt 贴上明确 paper identity。

Figure 1 解读：原博客这张图展示了 RLM 的核心执行方式：parent RLM 不把长上下文一次性塞进模型，而是在 REPL 中通过程序操作读取、搜索、整理外部 context；当任务可以分解时，parent 会生成 sub-queries 并派发给 child RLM。每个 child 也运行在自己的 REPL 环境中，因此递归结构不是普通 tool call，而是一棵由同一类 agent loop 组成的执行树。

这些工具使 evidence selection 任务可以自然拆成 root + child：root 先用 list_papers、search(context, ...) 粗筛相关 paper，再用 rlm_query_batched 给每个 child 一个 paper text，让 child 只负责从自己的 paper 中抽取证据，最后 root flatten child results 并 FINAL_VAR("evidence")。

3.2 Evidence Selection 任务与数据构造

任务输入是一个 question 和一组 arXiv papers，目标是返回能回答问题的原文 snippets。单篇情形下，模型可以搜索关键词、扩展上下文、抽取最相关段落；多篇情形下，root RLM 需要判断哪些 papers 值得深入，再派发 child RLM 到对应 papers 上抽取 evidence。

Figure 2 解读：这张图给出 evidence selection 的单篇 paper 版本：问题是询问论文使用了哪些 baselines，RLM 先用 search("baseline") 找候选命中，再观察局部 slice，最后用 extract_section 抽取两个 gold snippets。它说明任务目标不是返回固定 top-k chunks，而是返回可变数量、可变长度、可直接引用的原文 span。

数据是合成生成的。作者先在 alphaXiv 上随机选择一篇 paper，再检索最多 9 篇语义相似 paper 形成 group，并偏好 high-upvoted papers。之后用 OCR 模型把每篇 paper 拆成 paragraphs，再让 frontier model 生成 questions 并从部分 papers 中选择 relevant paragraphs。注意不是每篇 paper 都有相关段落。OCR 只用于构造 clean ground-truth evidence；测试时模型看到的是 PDF parsing library 的 noisy text，以模拟生产设置，因为对每个新文档都跑 OCR 既贵又麻烦。最终数据规模是 1000 queries，每个 group 最多 10 papers，每个 group 最多 3 queries。

作者特别指出，RAG 对这个任务不是很合适。原因不是 RAG 完全不能用，而是 evidence selection 要返回数量和长度都不固定的 verbatim spans，不是固定 top-k chunks。RAG index 可以作为 REPL 的一个额外工具，但如果目标是动态规划搜索路径、抽取精确片段、并行分配 papers，RLM 的程序化上下文操作更贴合。

3.3 Cold-start SFT：先让小模型学会 RLM 语法

原始 RLM paper 用 Qwen3-Coder-480B-A35B-Instruct 生成 RLM-like trajectories，再 SFT Qwen3-8B，目的主要是教模型如何操作 REPL、如何提交答案、如何发起 sub-LM calls，而不是针对某个具体任务训练。本文延续这个思想：对于 Qwen3.5-4B，直接 RL 之前必须有 cold-start SFT。

作者观察到，即使有 good prompt 和 predefined tools，不经过 SFT 的 Qwen3.5-4B 在 single-paper evidence selection 上 pass@16 为 0。失败模式包括：用错提交 final answer 的语法；过度 reasoning；乱调用工具；生成大量无效 turns，导致 context window 膨胀。SFT phase 使用 Qwen3.5-397B-A17B 作为 teacher 生成 RLM rollouts，并过滤掉包含 REPL errors 或 character-span F1 为 0 的 rollouts。SFT dataset 只取 RL dataset 的 small held-out portion，约几十个 examples；作者还发现，如果用整个 RL training dataset 做 SFT，即使数据不大，也会导致 entropy collapse 和后续 RL instability。

这与上一篇 SFT/RL/OPD distributional lens 博客可以连起来看：SFT 适合 cold-start 行为格式，但过量 SFT 会把模型分布拉得太窄；RL 则更适合在模型已经能跑起来的 scaffold 上提升 task performance。因此本文 pipeline 是先小规模 SFT 教会 RLM harness，再 RL fine-tune task-specific behavior。

Figure 3 解读：左图是 policy KL，右图是 average raw reward。full training set SFT 经过 4 epochs 后在后续训练中出现明显 KL spikes 和 reward collapse；small held-out SFT subset 则更稳定。这支持作者的经验判断：SFT 对 RLM syntax / REPL 操作是必要 cold-start，但用太多 task data 做 imitation 会导致 entropy collapse 和 RL instability。

3.4 Stepwise RL：每个 turn 是独立训练样本

RLM scaffold 的一个细节是 successive turns 不共享完整 prefix。用户原始 query 不作为 persistent chat history 一路累积，而是在每一轮重新 append 到末尾，避免任务说明被埋在深层 context 中。这样做对 inference 有利，但对训练提出限制：不能把整个 rollout 当成单一 training example，因为不同 turns 的 prompt prefix 不同。一个 $N$ turns 的 rollout 必须拆成 $N$ 个 samples。

advantage calculation 只对 trajectory 最后一步对应的 rollout 放进 GRPO group；之前 turns 的 samples 会广播继承该 rollout 的 advantage。这和后文 child advantage inheritance 是同一种思想：reward 是 sequence / trajectory 级的，但训练信号需要作用到每个 turn、每个 token，因此要把同一个 advantage 分配到相关 samples 上。

Figure 4 解读：图中对比了 typical chat RL 与 stepwise RLM training。普通 chat RL 可以把一次多轮交互看作一条连续 sequence；但 RLM 每轮都会重新组织 SYS + repl history + user q + new action，所以一个 rollout 会拆成多个 separate sequences。这样做能持续提醒模型原始 query，但也要求把最终 trajectory-level advantage 回传给前面各 turn 的训练样本。

3.5 Reward：rubric-based LLM judges 而非纯 F1

作者最初尝试用 selected snippets 与 gold evidence snippets 的 F1 作为 verifiable reward，但发现噪声很大。例如问题是“哪个方法在 X baseline 上最好”，可能有多种文本片段都能正确回答，但 labels 只包含其中一些。纯 F1 会把合理但未标注的 evidence 打低分。为绕过这个问题，作者用 rubric-based LLM judges：judge 输入原始 query、ground-truth text 和 predicted text，输出 reward，同时相关文献表明 rubric-based rewards 对 reward hacking 更稳健。

single-paper 实验中，RL fine-tuning 让 Qwen3.5-4B 的 eval judge score 从约 0.6 提升到约 0.8。这里 0.6 的起点来自 SFT model，而不是 base model，进一步说明 cold-start SFT 的必要性。

Figure 5 解读：这张曲线展示 single-paper evidence-selection 上的 eval reward：Qwen3.5-4B RLM 从约 $0.46$ 逐步爬升到约 $0.80$，接近 Claude Sonnet 4.6 baseline。它强调 RL 的作用不是教模型“语法”，而是在 SFT 冷启动后把任务策略和工具使用行为推到可用性能。

3.6 Multi-paper RLM：parent advantage inheritance

multi-paper 设置是真正 recursive 的部分。root RLM 要筛 paper，child RLM 要从对应 paper 抽取 snippets。最直接但麻烦的做法是训练两个 policy：一个 root policy，一个 child policy；这需要两个 reward system，也让 training pipeline 很复杂。另一个选择是冻结 child，只训练 root；但由于 4B SFT model 做不好 child task，这也不够。本文选择单一共享 policy，并用 parent advantage 训练 child。

Figure 6 解读：这张图把 multi-paper evidence selection 拆成 root 和 child 两层。parent REPL 先列出 paper ids 和 titles，triage 出相关 paper，再为每篇 paper 派发 child RLM；child RLM 在自己的 REPL 中搜索 baseline、抽取 section，并用 FINAL_VAR(ev) 返回 evidence spans。训练目标的难点正来自这里：最终 reward 出现在 parent answer 上，但有用工作分散在多个 child trajectories 里。

形式化地，对 batch 中每个 query $x$，采样 $G$ 个 root rollouts： $\{y_g{\}}_{g=1}^G\sim {\pi }_{{\theta }_{\text{old}}}(\cdot \mid x)$ 每个 root rollout $y_g$ 通过 rlm_query 或 rlm_query_batched 确定性地产生 child prompts： $\varphi (y_g)=\{x_{g,i}{\}}_{i=1}^{k_g}$ children 也从同一个 old policy 中采样： $y_{g,i}\sim {\pi }_{{\theta }_{\text{old}}}(\cdot \mid x_{g,i}),i=1,\dots ,k_g$ 只有 root rollout 得到任务 reward： $r_g=R(x,y_g)$ 在同一 query 的 $G$ 个 root rollouts 内计算 group-relative advantage： $A_g=\frac{r_g-\mathrm{mean}(\{r_{g^{\prime }}{\}}_{g^{\prime }=1}^G)}{\mathrm{std}(\{r_{g^{\prime }}{\}}_{g^{\prime }=1}^G)}$ 每个 child 继承 parent advantage： $A_{g,i}:=A_g,\forall i=1,\dots ,k_g$ 设 token-level importance ratio 为 ${\rho }_{\theta }$（按 PPO/GRPO 常规定义理解为新旧 policy 概率比），root clipped surrogate 为： ${\mathcal{L}}_g^{\text{root}}(\theta )=\frac{1}{|y_g|}{\sum }_{t=1}^{|y_g|}\min \left({\rho }_{\theta }(y_g^{(t)})A_g,\mathrm{clip}({\rho }_{\theta }(y_g^{(t)}),1-ϵ,1+ϵ)A_g\right)$ child surrogate 同理： ${\mathcal{L}}_{g,i}^{\text{child}}(\theta )=\frac{1}{|y_{g,i}|}{\sum }_{t=1}^{|y_{g,i}|}\min \left({\rho }_{\theta }(y_{g,i}^{(t)})A_{g,i},\mathrm{clip}({\rho }_{\theta }(y_{g,i}^{(t)}),1-ϵ,1+ϵ)A_{g,i}\right)$ 整棵 depth-1 RLM tree 的目标为： $J(\theta )={\mathbb{E}}_{x,\{y_g\},\{y_{g,i}\}}\left[\frac{1}{G}{\sum }_{g=1}^G\left({\mathcal{L}}_g^{\text{root}}(\theta )+\frac{1}{k_g}{\sum }_{i=1}^{k_g}{\mathcal{L}}_{g,i}^{\text{child}}(\theta )\right)\right]-\beta D_{KL}[{\pi }_{\theta }\Vert {\pi }_{\text{ref}}]$ 关键是 $\frac{1}{k_g}$。如果不除以 child 数量，派发更多 child 的 root 会在 loss 中占更大权重，训练会偏向“多调用 child”而不是“调用有用 child”。更深的递归可以写成： ${\mathcal{L}}_{\text{subtree}}(y,A)={\mathcal{L}}_{\text{node}}(y,A)+\frac{1}{k_y}{\sum }_{i=1}^{k_y}{\mathcal{L}}_{\text{subtree}}(y_i,A)$ 其中 $\{x_i{\}}_{i=1}^{k_y}$ 是 node $y$ 派发的 child prompts，children rollout 为 $y_i\sim {\pi }_{{\theta }_{\text{old}}}(\cdot \mid x_i)$。作者也提到一种更快但噪声更大的替代：如果 child rollouts 高度重复，可以随机采样一个 child 参与梯度，而不是平均所有 children。

3.7 实现伪代码（基于公开 SkyRL 代码结构）

Code reference: main @ ecdaa946 (2026-05-20) — pseudocode and mapping based on this commit

下面伪代码不是逐行复刻，而是根据 SkyRL 的 RLM generator、environment 和 multi-paper evidence env 抽象出的训练逻辑。

def root_rollout(policy, env, query, context):
    obs = env.reset(query=query, context=context)
    child_records = []
    for turn in range(env.max_turns):
        code = policy.generate(obs)
        repl_result = env.execute_repl(code)
 
        # rlm_query / rlm_query_batched 在 REPL 内注册 child prompts
        for child_prompt, child_context in repl_result.child_calls:
            child_answer = child_rollout(policy, env.child_env(), child_prompt, child_context)
            child_records.append(child_answer)
 
        obs = env.format_observation(repl_result)
        if repl_result.final_answer is not None:
            break
    reward = env.judge_reward(query, repl_result.final_answer)
    return repl_result.trajectory, child_records, reward
 
 
def rlm_tree_grpo_update(policy, ref_policy, batch, group_size):
    all_losses = []
    for query, context in batch:
        roots = [root_rollout(policy.old, env, query, context) for _ in range(group_size)]
        rewards = torch.tensor([r.reward for r in roots])
        advantages = (rewards - rewards.mean()) / (rewards.std() + 1e-8)
 
        for root, advantage in zip(roots, advantages):
            root_loss = clipped_grpo_loss(policy, root.trajectory, advantage)
            child_losses = []
            for child in root.child_records:
                child_losses.append(clipped_grpo_loss(policy, child.trajectory, advantage))
 
            if child_losses:
                subtree_loss = root_loss + torch.stack(child_losses).mean()
            else:
                subtree_loss = root_loss
            all_losses.append(subtree_loss)
 
    kl = kl_to_reference(policy, ref_policy, batch)
    loss = -torch.stack(all_losses).mean() + beta * kl
    loss.backward()
    optimizer.step()

3.8 Code-to-paper mapping

Paper / Blog Concept	Source File	Key Class / Function
RLM REPL environment，FINAL / FINAL_VAR / code execution	skyrl-gym/skyrl_gym/envs/rlm/env.py, skyrl-gym/skyrl_gym/envs/rlm/repl.py	BaseRLMEnv, PersistentREPL, _find_final_answer, _format_execution_result
RLM rollout generator，root/child rollout bookkeeping	examples/train/rlm/rlm_generator.py	RLMGymGenerator, _RLMRolloutContext
Evidence selection multi-paper environment	examples/train/rlm/multi_paper_env/evidence_rlm_env.py	EvidenceRLMEnv, MultipaperEvidenceRLMEnv
Paper search / extract tools	examples/train/rlm/multi_paper_env/paper_tools.py	make_tools, search, extract_section, get_paper_abstract
Rubric / evidence reward and span metrics	examples/train/rlm/multi_paper_env/evidence_rewards.py	judge_reward, compute_metrics, compute_child_rlm_metrics
Synthetic multi-paper dataset conversion	examples/train/rlm/rlm_dataset_synthetic_multi.py	build_context, convert, main
Training entrypoint and config	examples/train/rlm/main_rlm.py, examples/train/rlm/rlm_config.py	RLMPPOExp, RLMGeneratorConfig
Published training script	examples/train/rlm/run_multi_paper_rlm.sh	generator.max_turns=6, trainer.algorithm.advantage_estimator="grpo", trainer.policy.optimizer_config.lr=1.0e-6

公开脚本中的重要配置包括：DATA_DIR=$HOME/data/rlm-synthetic-multi，generator.max_turns=6，trainer.train_batch_size=4，trainer.eval_batch_size=16，trainer.algorithm.advantage_estimator="grpo"，trainer.algorithm.use_kl_loss=true，trainer.policy.optimizer_config.lr=1.0e-6，generator.sampling_params.temperature=1.0，generator.sampling_params.top_p=1.0。博客正文报告最终 multi-paper runs 使用 SFT Qwen3.5-4B、单个 8×H200 node、batch size 16、每 prompt 8 samples；公开 shell 默认 TRAIN_GPUS=4，因此实际复现实验时应显式检查环境变量覆盖，而不要只读脚本默认值。

4. Experimental Setup（实验设置）

4.1 模型与 harness

核心模型是 Qwen3.5-4B，先经过 cold-start SFT，再做 RL fine-tuning。比较对象包括同一 RLM scaffold 下的 Claude Sonnet 4.6，以及 SFT model / RL fine-tuned model 的不同阶段。环境是 Python REPL-based RLM harness，工具包括 FINAL、FINAL_VAR、rlm_query、rlm_query_batched，以及 evidence selection 的 list_papers、search、extract_section、get_paper_abstract。

4.2 数据集

数据集是 1000 个 synthetic queries。每个 query 对应一个最多 10 篇 arXiv papers 的 group，每个 group 最多产生 3 个 queries。构造流程是：随机选 alphaXiv paper → 找最多 9 篇语义相似且高 upvote paper → OCR 切 paragraphs → frontier model 生成 question 并选择 relevant paragraphs。测试时用 noisy PDF parsing text，而不是 clean OCR text。

4.3 训练设置

single-paper 阶段先验证 4B 模型能否在无 child sub-calls 的 evidence selection 上被 RL 提升。重要设置包括 explicit task strategy prompt：要求模型用多个 keyword variants 调 search，用 refined search 扩展 promising snippets，再用 extract_section 提交最终 evidence，通常 5–7 turns。这个策略 prompt 会显著影响 latency：即使是 Sonnet 4.6，没有策略时 rollout 约 90 秒，有策略时约 30 秒。

multi-paper 阶段训练真正 RLM：root 选择相关 papers 并派发 child RLM，child 从指定 paper 中抽 evidence。最终 multi-paper training 在 SFT Qwen3.5-4B 上做，博客报告使用单个 8×H200 node、batch size 16、每 prompt 8 samples、最多每 parent 4 个 child RLMs，因此 generation 峰值可达 512 concurrent rollouts。这个并发量一开始暴露了 child RLM REPL timeout 的 race conditions，修复后 reward curve 稳定。

4.4 Reward 与评价

reward 使用 rubric-based LLM judges，而不是纯 F1。judge 输入 query、ground-truth text、predicted text，输出 reward / score。single-paper 中 eval judge score 从约 0.6 提升到约 0.8。multi-paper 中训练集平均 rubric score 从 0.3 提升到 0.6。最终 eval 把 fine-tuned 4B RLM 与 frontier models 放在相同 RLM scaffold 中比较；博客强调 4B 模型接近 Claude Sonnet 4.6，但 latency 从 Sonnet RLM 的 60+ 秒降到单节点约 7 秒。

5. Experimental Results（实验结果）

5.1 Single-paper：RL 在 SFT 冷启动后显著提升

single-paper 结果说明，SFT 是必要但不充分的。SFT 让 Qwen3.5-4B 从完全不会 RLM syntax / final answer submission，变成可以开始在 REPL harness 中完成基本任务；但 task-specific capability 主要来自 RL。作者报告 eval judge score 从约 0.6 到约 0.8，且初始 reward 从 0.6 而不是 0 开始，正是因为 RL 是在 SFT model 上进行。

这一点的实践含义是：对复杂 scaffold，不能直接把“RL 能自我发现能力”理解成完全不需要 SFT。小模型必须先进入任务 scaffold 的有效 support；否则 RL rollout 质量太差、reward 太稀疏、语法错误太多，训练无法启动。SFT 的最佳角色是小剂量 cold-start，而不是覆盖整个 RL dataset 的行为克隆。

5.2 Multi-paper：共享 policy 能同时学 root 与 child

multi-paper 实验的关键结果是：单一 Qwen3.5-4B policy 可以通过 advantage inheritance 同时学会 root decomposer 与 child extractor。root 的 reward 来自最终 answer 的 judge score，child 不需要单独 reward；child trajectories 继承 parent advantage 后，仍然能在同一 loss 中训练。这让训练 pipeline 比双 policy / 多 reward 系统简单很多。

训练效果上，博客报告 multi-paper training 让训练集 average rubric score 从 0.3 提升到 0.6。在 eval 上，RL fine-tuned 4B RLM 与 Claude Sonnet 4.6 使用同一 harness 时效果接近；虽然未超过 Sonnet 的 0.607 average rubric score，但该 4B RLM 的 query wall-clock 约 7 秒，而 Sonnet-based RLM 超过 60 秒。这说明 RL fine-tuned 小模型的价值不只是“分数接近”，还包括成本和 latency 的数量级优势。

Figure 7 解读：multi-paper recursive evidence-selection 的 eval reward 从约 $0.30$ 上升到约 $0.60$，逐渐接近 Claude Sonnet 4.6 的 dashed baseline（约 $0.65$）。这张图对应的是带 child sub-calls 的真实 RLM setting，因此比 single-paper 曲线更能说明 parent advantage inheritance 的训练效果。

Figure 8 解读：平均 rubric eval score 中，Claude Sonnet 4.6 为 $0.607$，RL fine-tuned Qwen3.5-4B 为 $0.583$，高于 Gemini-3-Flash 的 $0.566$ 和 GPT-5.4-mini 的 $0.533$。结合 wall-clock latency（Qwen RLM 约 7 秒，Sonnet RLM 超过 60 秒），作者想强调小模型 RLM 的 deployment tradeoff：略低于 Sonnet，但成本和速度更适合生产。

5.3 Prompt ablation：短 prompt 更不稳定，但指向长期目标

作者还做了一个 prompt ablation。训练默认保持原 RLM paper 的 scaffold：用户 query 在多轮中移动到 conversation history 末尾，并保留很长的 strategy prompt（约 1500 tokens）。作者尝试把 prompt 缩短到约 200 tokens，并把 query 放在 system prompt 后面。这个设置收敛略低且更不稳定，作者认为可能可用 curriculum learning 修复。

Figure 9 解读：full prompt（约 1500 tokens）比 simplified prompt（约 200 tokens）更稳定、收敛更高。这个 ablation 说明当前 4B 模型仍依赖明确的 RLM task strategy；如果 prompt 只描述高层任务和 sub-call 能力，模型尚不能稳定发现最佳 decomposition / evidence-selection 策略。

这个 ablation 的意义不只是“长 prompt 更好”。更深层的结论是，当前模型还不是 native RLM，所以需要详细策略提示解释如何拆任务、如何使用 tools、如何组织 child calls。真正的 RLM training 长期目标，是让模型内部学会 RLM role，使 prompt 只需描述 sub-call 能力和 high-level task，而不需要人工写 decomposition recipe。

5.4 局限与下一步

第一，任务范围仍然窄。evidence selection 是 alphaXiv 自身生产需求驱动的任务，虽然代表了 scientific document QA、parallel evidence retrieval 和 verbatim span extraction，但不能直接证明 RLM RL 对所有 long-context / agentic tasks 都有效。

第二，reward assignment 仍然粗。children 继承 parent advantage 是简单有效的估计器，但不是最精细的 credit assignment。更好的方案可能是 multi-tier reward：root 用选中 papers 的 F1 或 coverage 计分，child 用 LM judge 对 snippets 计分，再把这些 reward 融合到 RLM tree 中。这样可能更快收敛，但也更复杂、更依赖任务。

第三，explicit task strategy 仍然是拐杖。本文训练仍依赖环境特定 tips：告诉模型如何 search、如何 batch child calls、如何 flatten final evidence。作者认为更大规模的 RLM-native training 应该让模型自己发现策略，而不是始终依赖人类写好的 decomposition prompt。这个方向类似 CoT 的发展：prompting 可以揭示能力形态，但大规模稳定能力最终往往来自 RL fine-tuning。

我的读后判断是：这篇博客最重要的贡献不是“RLM evidence selection 分数多高”，而是提出了一个可实施的 RLM RL training recipe：小 SFT 冷启动 + stepwise RL + shared root/child policy + parent advantage inheritance + child loss normalization。它把 RLM 从“frontier model + prompt scaffold”的昂贵推理技巧，推进到“可训练、可部署的小模型行为模式”。如果未来 RLM 真成为 CoT/ReAct 之后的新 inference scaling paradigm，那么本文的 reward inheritance 与 tree-structured GRPO 可能会是一个早期、简单但很实用的训练模板。