Paper Notes

Efficient Agentic Reasoning Through Self-Regulated Simulative Planning

作者Mingkai Deng, Jinyu Hou, Lara Sá Neves, Varad Pimpalkhute, Taylor W. Killian, Zhengzhong Liu, Eric P. Xing
机构Institute of Foundation Models (IFM), Carnegie Mellon University
发表arXiv · 2026
参考论文: arxiv.orgGitHub项目: sailing-lab.github.ioHF Paper

22分钟阅读

Efficient Agentic Reasoning Through Self-Regulated Simulative Planning

Paper: arXiv:2605.22138 Code: sailing-lab/sr2am Code reference: main @ 6f4ac782 (2026-05-21)

1. Motivation (研究动机)

这篇论文要解决的问题不是“让 LLM 想得更短”这么简单，而是：一个 Agent 应该如何决定什么时候规划、规划成什么结构、规划多远，然后什么时候停止规划并直接行动。现有 Agentic LLM 往往把 Agent 写成 reactive policy：每一步都生成 unconstrained Chain-of-Thought，再决定是否调用工具或给答案。这样做有三个具体问题：

  • 规划没有显式结构：长期目标、当前 belief state、候选 action、future state prediction 都混在普通 CoT 里，外部很难分析哪一段是在模拟未来，哪一段只是局部推理。
  • 规划没有调度机制：模型通常只能通过“多想一点 / 少想一点”隐式调节计算量，无法显式决定本 turn 是否需要 plan、是否沿用旧 plan、需要 1 步还是多步 horizon。
  • token 成本不可控：论文指出，训练后的 agentic reasoning 很容易显著增加 reasoning token，但更长的 reasoning 并不保证更高准确率；在 web、table、science 等需要工具交互的任务中，这会直接拖慢推理并推高上下文溢出的风险。

作者把这个问题放在 long-horizon planning 的历史目标下理解：如果 planning 只是被期待“自然涌现”在 CoT 中，那么 Agent 没有真正的 internal agency 去管理自己的 planning process。解决它的价值在于：小模型可以通过结构化的 planning 和工具使用接近大模型系统的性能，同时把 reasoning token 增长限制在可控范围内。

更具体地说，论文认为现有方法缺少的是“可干预的中间层”。例如 ReAct / WebSailor 类方法虽然能边想边搜，但每一步为什么要搜、搜之前是否需要模拟多个 future states、已有 plan 是否已经失效，都没有显式变量；effort-adaptive 方法可以控制 thinking budget，却不控制 thinking 的语义类型；workflow distillation 可以蒸馏固定流程，但往往牺牲 free-form reasoning 的灵活性。SR²AM 试图把这些能力重新组合：保留自由推理，加入显式的 state-action-future-state plan，并让模型学会按 task uncertainty 和 progress 来调用 plan。

这个问题值得研究的另一个原因是 evaluation setting 本身很现实：math/science 可以靠内部推理，tabular analysis 需要 Python 或结构化计算，web information seeking 还要处理搜索、网页摘要、证据不完整和环境变化。一个统一 planner 如果能跨这四类任务工作，就说明 simulative planning 不只是某个 domain-specific workflow，而可能是 Agentic LLM 的通用 reasoning control mechanism。

2. Idea (核心思想)

核心 insight 是：把 Agent 的内部决策拆成 System I / II / III，而不是把所有计算都塞进一条 undifferentiated CoT。System I 做 reactive execution 和局部动作，System II 做 simulative reasoning，即通过 world model 预测未来 state，System III 做 self-regulation，即决定当前是否需要规划以及规划多深。

SR²AM 的关键创新是把“是否规划”和“规划 horizon”变成可学习、可观察的中间变量。它不是像 ReAct / WebSailor 那样让模型自由思考并调用工具，也不是像 mode routing 那样只在任务开头选模式；它在每一步都让 configurator 先判断，再让 planner 在需要时生成 state-action-future-state 结构，最后由 actor 执行工具或输出答案。

和已有方法的差异可以概括为：unregulated deliberation 只有 System I 的长 CoT；workflow distillation / mode routing 只有部分 regulation；一些 world-model 方法会强制每步 simulation。SR²AM 的目标是同时具备三点：free-form reasoning、可选择的 simulative planning、以及可学习的 planning 调度。

一个有用的直觉是：SR²AM 不是把 CoT 改写成 rigid planner，而是在 CoT 内部插入“自我管理协议”。当任务简单或已有 plan 足够时，System III 可以让模型直接执行，避免无谓展开；当 observation 表明当前 state 有歧义或下一步 action 会影响后续搜索空间时，它让 System II 先写出可能 action 与 future state。这样，planning 不再是 token 越多越好，而是只有在能减少未来不确定性、发现潜在错误或保持长期目标一致时才值得花费。

v0.1 和 v1.0 的区别也体现了这篇论文的核心路线：v0.1 用外部分工模块“演示”三系统分解可以工作；v1.0 则从强 reasoning LLM 的 traces 中反向重建 planner/configurator 标注，让结构化规划可以被 SFT 和 RL 学进单个模型里。也就是说，最终目标不是部署一个多模块 pipeline，而是训练一个能在单条 reasoning stream 中自我调节的 Agentic LLM。

3. Method (方法)

3.1 Overall framework：System I + II + III

Figure 1 解读：图中把一次 web information-seeking trajectory 拆成三层。Configurator（System III）先读当前 observation / history，决定是跳过 planning、继续旧 plan，还是启动新的 simulative plan；Planner（System II）在需要时写出当前 state、下一步 action、以及预期 future state；Actor（System I）再执行 search / visit / Python / final answer。这个图的重点不是工具本身，而是每个 turn 都有一个可学习的“规划开关”和“规划深度”。

形式化上，智能体无法直接访问真实 state ，只能从 observation 形成 belief state 。如果有 world model ，理想的 simulative planner 可以近似求： 实际中精确优化不可行，因此 planner 输出一个结构化 plan： 传统 reactive CoT 可以写成： 其中 是不受约束的 latent deliberation。SR²AM 则把 action distribution 拆成三段： 这里 是 configurator 的 planning decision， 是 planner 生成的 plan， 是执行具体 tool call / final answer 的 actor。这个分解让“规划是否发生”和“规划内容”都能被监督数据和 RL 单独塑形。

3.2 Environment and tools

每个时间步 ，模型接收 observation ，其中包含之前的 reasoning context、action、tool outputs。它最多执行 个 actions，最后根据 trajectory 和 final answer 计算 reward。论文使用三个工具：

  • web_search：通过 SerpAPI（默认）或 Serper.dev 做批量 web search。
  • visit_tool：访问网页并用 LLM summarizer 总结页面内容；released code 默认把网页截断到 28K tokens，并使用 OpenAI-compatible summarizer endpoint。
  • python_repl_tool：通过 SandboxFusion 执行 stateless Python，用于计算、表格处理或数据分析。

released code 中这些工具位于 tools/websailor_tools_fast.py。主循环在 agent_base.py::generate_response_agent：它把 user question 放入 messages，循环调用 model，解析 tool calls，执行工具，再把 tool result 追加回 messages，直到模型完成或达到 max_turns。

3.3 Supervised data construction v0.1：Multi-Module Inference

v0.1 是 feasibility 版本。作者用 prompted LLM modules 显式实现 configurator 和 planner ，再加上一些辅助模块，例如 belief formation、user intent interpretation、problem solving。Configurator 可以自由调用这些模块：如果还需要 planning，就调用相应能力；如果 planning 完成，就选择下一步 action。

具体细节：v0.1 主要用 o4-mini 收集 traces；每条 trajectory 最多 actions，最多 retry 3 次直到得到 final answer；之后按 answer correctness 和 minimum reasoning complexity 过滤。Web tasks 还额外用 GPT-4.1 补充 configurator reasoning，使 action selection 前的状态解释更充分。这个版本最后得到 4,845 条 supervised examples，共 20.7M tokens。

3.4 Supervised data construction v1.0：Plan Reconstruction

v1.0 是论文的主版本，避免每次都跑复杂 multi-module prompted system。作者先用 DeepSeek-V3.2 生成 thinking-acting trajectories： 再让 annotator LLM 从整条 trace 中重建每一步的 configurator decision 和 planner content。对每个 step ，annotator 先输出： 表示是否需要 planning。如果 ，则输出结构化 plan： 其中 是 planning-relevant condition， 是 proposed action， 是 predicted future state。一个 planning step 可以覆盖多个 real-time tool steps，也可以只覆盖一个 step 的一部分，所以 horizon 是可层级化的。Web-browsing 问题因为环境不确定性高，训练数据中把 plan 截断到最多 2 steps。

Appendix C 给出的 v1.0 collection 设置是：DeepSeek-V3.2 thinking mode，128K context， steps，最多 retry 5 次直到正确；plan annotation 也用 DeepSeek-V3.2 thinking mode，在整条 trajectory 上 single-pass 完成。v1.0 在 v0.1 数据基础上加入 MegaScience、WebDancer、WebShaper、TaskCraft、ASearcherLRM35k 等数据，最终得到 10,787 条 supervised examples，共 39.5M tokens。

3.5 Reinforcement learning refinement

SFT 之后，作者用 RL 让三套系统围绕 task success 协同。对任务 ，agent 生成 trajectory： Reward 是三个 binary signals 的 piecewise 组合：answer correctness、trajectory structure compliance、final-answer format compliance。 这些 reward values 在所有实验中固定，没有调参。优化目标是 adapted GRPO：对每个 initial observation 采样 条 trajectories，用 group-level z-score reward 得到 token-level advantage： 最终最大化 asymmetric clipping 的 surrogate objective： 作者强调所有 model updates 保持 on-policy；对 30B 及以上模型，会过滤掉因 truncation 终止的 trajectories，避免 malformed negatives 破坏格式学习。

3.6 Data filtering and training hyperparameters

RL 数据使用 difficulty-based filtering：用 pre-RL checkpoint 对问题 rollout 次，仅保留 Pass@ 的题目，使 sampled trajectories 产生非零 advantage。对 web-heavy 任务，则用强 instruct LLM 采样 个答案，用 Pass@ 近似筛掉太容易的问题。

  • SR²AM-v0.1-8B：base model 是 Qwen3-8B；SFT 用 Axolotl / FSDP，global batch size 32，max context 32,768，Adam lr ，warmup ratio 0.1，cosine decay 到 ，weight decay 0.01，4 epochs。RL 用 Slime，rollout batch size 128，每 prompt 8 samples，max response 8,192，max context 40,960，temperature 0.8，max 40 action steps，，，Adam constant lr ，weight decay 0.1，400 steps / 51.2K examples。SFT 用 8 Hopper GPUs 约 3 小时，RL 用 32 Hopper GPUs 约 3.3 天。
  • SR²AM-v1.0-30B：base model 是 Qwen3-30B-A3B-Thinking-2507；SFT 用 ms-swift / Megatron，global batch size 32，max context 131,072，sample packing，MoE auxiliary loss 0.01，Adam lr ，warmup fraction 0.05，cosine decay 到 ，weight decay 0.01，4 epochs。RL 与 v0.1 同一 GRPO 配置，但 max response 16,384，max context 122,880，temperature 1.0，top-p 0.95，max 100 tool steps；训练 200 steps / 25.6K examples，其中前 160 steps 后用 intermediate checkpoint 重新过滤数据，剩下 40 steps 用更匹配当前能力的难题。SFT 用 32 Hopper GPUs 约 1.5 小时，RL 约 6 天。
  • released code 对训练配置的覆盖：sailing-lab/sr2am 当前 commit 主要发布 inference / evaluation / reproduction scripts，没有 SFT、plan reconstruction annotation、GRPO training launch config。因此上面训练超参来自论文 Appendix E.3；released code 可验证的是 inference/evaluation 配置，例如 scripts/run_inference_local.sh 对 8B 默认 max_turns=50, temperature=0.8, context=40960，对 30B 默认 max_turns=100, temperature=1.0, context=131072，并统一 max_completion_tokens=16384。

3.7 Code-grounded pseudocode

下面伪代码只覆盖 released implementation 中可运行的 inference / evaluation 部分；训练与 annotation pipeline 在当前 public repo 中未发布。

async def sr2am_tool_loop(client, model, question, tools, system_prompt, max_turns):
    instance_id = None
    for tool in tools.values():
        instance_id = await tool.create(instance_id=instance_id)
 
    messages = [{"role": "system", "content": system_prompt},
                {"role": "user", "content": question}]
    cumulative_reward = 0.0
 
    for _ in range(max_turns):
        response = await client.chat.completions.create(
            model=model,
            messages=messages,
            tools=[tool.get_openai_tool_schema().model_dump() for tool in tools.values()],
            max_completion_tokens=16384,
        )
        assistant = response.choices[0].message.model_dump()
        messages.append(assistant)
 
        tool_calls = assistant.get("tool_calls")
        if not tool_calls:
            break
 
        for call in tool_calls:
            fn_name = call["function"]["name"]
            fn_args = json.loads(call["function"]["arguments"])
            result, reward, metrics = await tools[fn_name].execute(
                instance_id=instance_id,
                parameters=fn_args,
            )
            cumulative_reward += reward
            messages.append({
                "role": "tool",
                "content": result,
                "reward": reward,
                "metrics": metrics,
                "tool_call_id": call["id"],
            })
 
        if cumulative_reward <= -0.5:
            break
 
    for tool in tools.values():
        await tool.release(instance_id=instance_id)
    return messages, messages[-1].get("content", "")
async def filtering_eval_question(question, row, run_agent, judge_answer, num_retries):
    results, num_corrects, num_wrongs = [], 0, 0
    for rep_idx in range(num_retries):
        messages, answer = await run_agent(question)
        judge = await judge_answer(row, answer)
        correct = judge["score"] == 1.0
        results.append({
            "question": question,
            "messages": messages,
            "answer": answer,
            "correct": correct,
            "judge_result": judge,
            "rep_idx": rep_idx,
        })
        num_corrects += int(correct)
        num_wrongs += int(not correct)
        if num_corrects > 0 and num_wrongs > 0:
            break
    return results
def build_agent_system_prompt(dataset, fix_datetime=False):
    if fix_datetime:
        current_time = "Sun Aug 31 2025 23:34:17"
    else:
        current_time = datetime.now().strftime("%a %b %d %Y %H:%M:%S %z")
    base = (
        f"CURRENT_TIME: {current_time}\n"
        "You are K2-Researcher, a reasoning assistant with the ability "
        "to perform web searches, browse web pages, and execute Python code."
    )
    return base + "\n\nYou should follow the answer format described in the question."
def count_reasoning_tokens(output_rows, tokenizer, source="think"):
    total = 0
    for row in output_rows:
        for message in row["messages"]:
            if message.get("role") != "assistant":
                continue
            text = extract_assistant_text(message, source=source)
            if "</think>" in text:
                text = text.split("</think>", 1)[0]
            else:
                text = ""
            total += len(tokenizer.encode(text))
    return total

论文中的 v1.0 plan reconstruction 与 GRPO update 可以概念化为下面两段，但它们不是当前 released repo 的可运行代码：

def reconstruct_self_regulated_trace(trajectory, annotator_llm, max_web_horizon=2):
    annotated_steps = []
    previous_plans = []
    for step in trajectory.steps:
        need_plan = annotator_llm.predict_planning_decision(
            full_trajectory=trajectory,
            current_step=step,
            previous_plans=previous_plans,
        )
        if need_plan:
            plan = annotator_llm.reconstruct_plan(
                full_trajectory=trajectory,
                current_step=step,
                previous_plans=previous_plans,
            )
            if trajectory.is_web_task:
                plan = plan.truncate(horizon=max_web_horizon)
        else:
            plan = None
        annotated_steps.append((step.free_form_reasoning, need_plan, plan, step.action))
        previous_plans.append(plan)
    return annotated_steps
def grpo_update(policy, prompts, reward_fn, eps_low=0.2, eps_high=0.28, group_size=8):
    trajectories = [policy.rollout(prompt) for prompt in prompts for _ in range(group_size)]
    rewards = torch.tensor([reward_fn(tau) for tau in trajectories])
    grouped = rewards.view(len(prompts), group_size)
    advantages = (grouped - grouped.mean(dim=1, keepdim=True)) / grouped.std(dim=1, keepdim=True)
 
    loss = 0.0
    for tau, adv in zip(trajectories, advantages.flatten()):
        ratio = torch.exp(policy.logprob(tau) - policy.old_logprob(tau))
        clipped = torch.clamp(ratio, 1 - eps_low, 1 + eps_high)
        loss -= torch.min(ratio * adv, clipped * adv).mean()
    loss.backward()
    policy.optimizer.step()

3.8 Code-to-paper mapping

Code reference: main @ 6f4ac782 (2026-05-21) — pseudocode and mapping based on this commit

Paper ConceptSource FileKey Class/Function
Public implementation repoREADME.mdModel download, tool setup, paper reproduction commands, 8219-row evaluation set
Website/project repo pointersailing-lab/sr2am-self-regulated-planning/README.mdPoints from project page repo to implementation repo sailing-lab/sr2am
Agent multi-turn loopagent_base.pyAgent, generate_response_agent, process_questions, process_single_question
Thinking-mode model wrapperrun_agent.pyVLLMModelThinkAgent, VLLMModelConfiguratorAgent, VLLMModelInstructAgent
Inference CLI and tool wiringrun_agent.py--agent_type, --max_turns, --max_completion_tokens, TOOL_CFGS, TOOL_CLS
Reproduction defaultsscripts/run_inference_local.sh8B/30B defaults for TP/DP, context length, max turns, temperature
System prompt / fixed timesystem_prompts.pyAGENT_SYSTEM_PROMPT, FIXED_DATETIME, get_agent_system_prompt
Web search / browser / Python sandbox toolstools/websailor_tools_fast.pyWebSailorMiroflowMultiWebSearchToolFast, WebSailorMultiVisitToolFast, SandboxFusionCodeTool
Full benchmark builderevaluation/prepare_test_data.pycreate_test_dataset_full, dataset loaders, repeat schedule
Scoring / pass rateevaluation/compute_rep_results.py, evaluation/run_judge_results.pyPass@K aggregation, post-hoc judging
Reasoning-token accountingavg_tokens_before_think_close.pyTHINK_CLOSE, configurator/reasoning text extraction, per-dataset breakdown

论文公式与 released code 实现差异：当前 released code 没有发布 SFT data construction、plan reconstruction annotator、GRPO/Slime training loop 或 Axolotl/ms-swift launch configs；它主要覆盖 inference/evaluation harness。因此，训练超参不能从 released launch config 复核，note 中的训练数值以论文 Appendix E.3 为准；code-grounded 部分只锚定可运行的 inference/evaluation path。

4. Experimental Setup (实验设置)

4.1 Benchmarks and scale

论文评测 11 个 benchmark，分成四类。released reproduction script evaluation/prepare_test_data.py 会构建 8219 rows 的 full test set；为了降低方差，AIME-24/AIME-25 重复 ，GPQA-Diamond/GAIA/XBench-DeepSearch 重复 ，其他 benchmark 重复 。

CategoryBenchmarksScale / source stated in paper or code
MathAIME-24, AIME-25, MATH-500AIME 源文件为 *_repeated_8x_240.parquet，builder 去重后再 ；MATH-500 为 500 题
ScienceGPQA-Diamond, SuperGPQA, HLEGPQA-Diamond 源文件 198 题并 ；SuperGPQA 源文件 1K；HLE 用 500-question subset
TabularFinQA, MultiHierFinQA 源文件约 1.1K；MultiHier 源文件 336
WebBrowseComp, GAIA-103, XBench-DeepSearchBrowseComp 用 AFM browsecomp.json；GAIA 为 103 题并 ；XBench-DeepSearch 用 decrypted CSV 并

4.2 Baselines

Baselines 分三组：

  • Reference Systems：pretrained LLMs，不做 agentic training。包括 text-only reasoning LLMs（GPT-5.4-xhigh、DeepSeek-V3.2、K2-Think-V2-high、Qwen3-30B-A3B-Thinking-2507）和同一 tool harness 下的 pretrained LLMs + Tools（GPT-5.4-xhigh、Kimi-K2.5、DeepSeek-V3.2、GLM-4.6、GPT-OSS-120B-high、Qwen3-8B/30B/235B 等）。
  • Unregulated Deliberation：训练成自由 CoT + tool interaction 的 agentic LLMs，包括 Tongyi-DeepResearch、MiroThinker-v1.5-30B、WebSailor-7B/32B、ASearcher-Web、SimpleTIR、WebExplorer-8B。
  • Partially-Regulated Deliberation：只实现部分 System I+II+III 分解的系统，包括 Mode Routing 的 A²FM，以及 Workflow Distillation 的 AFM-Web-7B-RL / AFM-Code-7B-RL。

4.3 Metrics and inference config

主指标是 overall Pass@1，按 11 个 datasets 的 Pass@1 做 unweighted average；可用时也报告 Pass@3。效率指标是 average reasoning tokens per trajectory，released code 用 avg_tokens_before_think_close.py 统计 </think> 之前的 assistant reasoning tokens，或从 Responses API usage 中读取 reasoning token counts。

论文 reproduction 使用 SerpAPI 作为默认 search provider，并固定 system prompt datetime 为 Sun Aug 31 2025 23:34:17。Released README 中 30B reproduction 使用 SR2AM-v1.0-30B、8 GPUs（TP=4, DP=2）、--fix_datetime、--code_concurrency 128、--visit_concurrency 64、--search_concurrency 128、--shuffle_questions；8B reproduction 使用 8 GPUs（TP=1, DP=8）。run_inference_local.sh 默认 8B 为 temperature=0.8, max_turns=50, context=40960，30B 为 temperature=1.0, max_turns=100, context=131072，两者默认 max_completion_tokens=16384。

5. Experimental Results (实验结果)

5.1 Main performance and reasoning efficiency

Figure 2 解读：横轴是 parameter size（log scale），纵轴是 overall Pass@1，颜色表示 reasoning token 数。SR²AM-v0.1-8B 在 8B 规模上达到 57.0 overall Pass@1；SR²AM-v1.0-30B 达到 71.3，接近或竞争于更大模型的 tool-use 系统。图的核心证据是：SR²AM 的点在性能-规模趋势上方，同时颜色没有像许多 unregulated agent 那样变红，说明它没有靠无限拉长 reasoning trace 换准确率。

Figure 3 解读：点表示 Pass@1，柱表示 average reasoning tokens（log scale），按 task category 分解 30/32B agentic LLMs。SR²AM-v1.0-30B 在 overall Pass@1 71.3 的同时只用 5,517.7 reasoning tokens；相比 MiroThinker-v1.5-30B 的 11,295.2 tokens，token 少 51.2%，但 Pass@1 仍然接近（71.3 vs. 74.2）。论文总结为：在 overall Pass@1 ≥ 60 的强 30/32B agentic baselines 中，SR²AM-v1.0-30B 少用 25.8–95.3% reasoning tokens。

ModelSizeReasoning TokensOverall Pass@1Comment
Qwen3-30B-A3B + Tools30B5,410.153.1同 tool harness，无 agentic training
A2FM32B23,424.851.4Mode Routing，partially regulated
MiroThinker-v1.530B11,295.274.2最强 30B unregulated baseline 之一
DeepSeek-V3.2 + Tools685B3,011.573.2大模型 reference system
Kimi-K2.5 + Tools1024B6,413.170.91T 级 reference system
SR²AM-v0.1-8B8B3,697.657.08B feasibility version
SR²AM-v1.0-30B30B5,517.771.3主方法，性能接近大模型 / 强 30B baseline，token 更少

SR²AM-v1.0-30B 的 per-benchmark Pass@1 是：AIME-24 96.2，AIME-25 91.1，MATH-500 99.2，GPQA-Diamond 77.3，SuperGPQA 73.0，HLE 30.4，FinQA 73.4，MultiHier 65.5，BrowseComp 22.5，GAIA 76.0，XBench-DeepSearch 80.0。SR²AM-v0.1-8B 则是：83.8，74.2，96.2，60.9，58.0，14.2，73.6，64.6，4.8，46.1，50.5。

5.2 Component ablation

Configuration# Reasoning TokensPass@1Pass@3
SR²AM-v1.0-30B (SFT)4,92566.679.4
− Free-form Reasoning (System I)1,18846.866.1
− Simulative Planning (System II)4,60265.278.5
− Selective Planning (System III)5,45165.278.8
− Plan Horizon Control (System III)4,82965.377.3
Original Teacher CoT (SFT)3,84465.378.5
SR²AM-v1.0-30B (SFT + RL)5,41472.882.4

Ablation 的最重要结论是：System I 的 free-form reasoning 不能去掉，去掉后 Pass@1 从 66.6 掉到 46.8；这说明结构化 plan 不是要替代所有 CoT，而是作为可调度的 planning scaffold。System II / III 的 ablation 单项下降看似较小（66.6 → 65.2/65.3），但完整分解比 original teacher CoT SFT 更好（66.6 vs. 65.3），并且提供了更适合 RL 的 substrate，RL 后升到 72.8。

5.3 RL changes planning horizon, not planning frequency

Figure 4 解读：左图比较 RL 前后 planning horizon 分布：2-step 和 3+-step plans 的占比从 5.3% 增到 14.9%，而 unplanned turns 基本稳定（15.6% → 13.6%）。右图按 task category 展示 average plan horizon 的变化：science 增幅最大（32.7%），web 增幅最小（20.9%），符合 web 环境不确定性更高、可安全规划 horizon 更短的直觉。关键不是“更频繁规划”，而是“当决定规划时规划得更远”。

Figure 5 解读：v0.1 上的 400-step RL 对比显示，unregulated deliberation 的 token 从约 4,100 持续增加，但 pass rate 在 step 200 后反而下降，并伴随 22.4% context overflow；SR²AM-v0.1-8B 的 token 从约 2,100 增到 3,600，仍然稳定更低，且 step 400 时 reasoning tokens 少 34.1%，Pass@1 更高（56.2 vs. 47.6）。这支持作者关于“RL 优化 planning quality，而不是只奖励更长 CoT”的解释。

Figure 6 解读：在 Qwen3-8B 上比较不同 SFT 数据构造方式。相同 teacher LLM（o4-mini）下，SR²AM 的 structured System I+II+III data 在 800–3,200 examples 的所有规模上都优于 unregulated reasoning reconstruction：Pass@1 高 1.2–3.5%，Pass@3 高 1.5–3.4%。当 teacher 换成 Qwen3-Coder-480B-A35B-Instruct，数据规模从 1,600 到 3,200 时 Pass@1 从 60.9 升到 72.9，说明结构化分解能随数据质量和 teacher 能力放大。

5.4 Limitations and takeaways

作者明确给出三类限制。第一，实验只覆盖 language-based interactive reasoning，尚未验证 embodied 或 multi-agent 场景；后者有更复杂的 state representations 和 coordination constraints。第二，SR²AM 把 LLM 当作 language-space world model，这在物理世界和社会互动中的 predictive power 可能不足；未来需要 multimodal world model 来预测 perceptual next states。第三，论文主要评估整体 task accuracy 和 reasoning efficiency，还没有单独评估 configurator 的 planning-decision accuracy 或 world-model future-state prediction accuracy。

整体结论是：SR²AM 证明了“Agent 不一定要通过更长 CoT 获得更强能力”。把 reactive execution、simulative planning、self-regulation 拆开后，RL 学到的是更深的 planning horizon 和更好的 planning usage，而不是简单增加 token。当前 released code 已足够复现 inference/evaluation path，但训练与 annotation pipeline 尚未开源，因此工程复现仍依赖论文 Appendix 中的超参描述。