TMAS: Scaling Test-Time Compute via Multi-Agent Synergy

Paper: arXiv:2605.10344 Code: IQuestLab/tmas Code reference: master @ 426dbbcd (2026-05-14)

1. Motivation (研究动机)

当前方法的问题

Test-time scaling (TTS) 的基本想法是：推理时给模型更多计算量，让模型生成更长的 chain-of-thought、更多候选解、或更多轮 refine，从而提高数学/推理任务的正确率。早期方法主要在单条轨迹内加深思考；后续方法开始做多轨迹、多轮 refinement、verification feedback，例如 Self-Refine、Verify-Refine、PaCoRe、RSE、DeepSeek-Math-V2、Nemotron-Cascade 2 等。

这篇论文认为现有 structured TTS 的瓶颈不是“有没有更多 rollouts”，而是“多条 rollout 之间有没有有效协作”。典型问题有两类：

• 并行轨迹弱耦合：Verify-Refine 类系统可以并行生成、验证、修正多个候选解，但不同候选解之间通常缺少可复用的信息流；一个分支发现的局部正确结论或错误模式，不一定会被其他分支及时利用。
• 历史信息使用太粗糙：PaCoRe / RSE 一类方法会把历史轨迹或经验喂回模型，但如果不显式区分“应该复用的低层可靠结论”和“已经尝试过、下次应避免重复的高层策略”，历史上下文会同时带来噪声、冗余和 context rot。

本文要解决的问题

TMAS 要解决的是：如何把 test-time compute 从“多采样/多轮修正”扩展成一个有分工、有记忆、有探索-利用平衡的 multi-agent inference system。具体目标不是训练一个新的基础模型，而是在推理阶段组织多个 agent：生成候选解、验证候选解、总结验证反馈、维护低层 experience bank、维护高层 guideline bank，并让这些信息跨 rollout、跨 iteration 传递。

为什么值得研究

如果这个问题解决得好，小模型可以通过更有效的推理时计算接近大模型表现。论文在 full IMO-AnswerBench 上给出的直观结果是：Qwen3-30B-A3B-Thinking-2507 从 64.9% 提升到 77.2% Pass@1；Qwen3-4B-Thinking-2507 配合 TMAS + Hybrid-RL 从 53.5% 提升到 73.5%。这说明 test-time compute 的收益不只来自“采样更多”，还来自“把每次采样产生的局部知识结构化地传给后续采样”。

Figure 1 解读：这张图把原始 Qwen3 backbone、TMAS-enhanced backbone 与若干 frontier model 的 IMO-AnswerBench Pass@1 放在一起比较。关键不是说 4B 模型已经超过所有闭源大模型，而是说明 TMAS 把小模型的推理时计算组织成可累积、可复用的协作过程后，能显著缩小与大模型的绝对性能差距。

2. Idea (核心思想)

TMAS 的核心洞察是：多轨迹 TTS 中真正稀缺的不是更多候选答案，而是“哪些局部结论值得复用、哪些高层策略已经尝试过应避免重复”的结构化记忆。它把 reasoning rollout 产生的信息分成两层：experience bank 负责低层、可直接复用的 verified anchors / error-avoidance heuristics；guideline bank 负责高层、已探索过的策略方向，用来推动后续 rollout 做非冗余探索。

关键创新可以概括为三点：第一，推理过程由五个 agent 分工完成，而不是一个模型反复自我修正；第二，experience bank 和 guideline bank 分别服务 exploitation 与 exploration，避免把所有历史轨迹混成一段长上下文；第三，Hybrid-RL 不只奖励最终答案正确，还奖励模型会使用 experience、会产生新的高层策略。

与 PaCoRe / RSE 相比，TMAS 的根本差异在于它不只是把历史轨迹聚合后喂回模型，而是显式维护两种语义不同的 memory bank。与 Verify-Refine 相比，TMAS 不把 verifier feedback 限制在当前候选解的局部修正里，而是通过 summary / experience / guideline agent 把 feedback 转换成后续 iteration 可共享的系统状态。

3. Method (方法)

3.1 Overall framework：五类 agent + 两级 memory bank

Figure 2 解读：图中每个 iteration 都包含两条互补路径。左侧 exploitation branch 使用 previous rollouts 和 experience bank 来改进已有推理路径；右侧 exploration branch 使用 guideline bank 记录的“已经尝试过的高层策略”，要求 solution agent 避免复读这些策略，从而探索新路线。每条候选 solution 都由多个 verification agent 独立打分和给反馈，再由 summary agent 汇总；experience agent 抽取低层可复用结论，guideline agent 抽取高层策略记忆。这里的 synergy 不是让 agent 互相聊天，而是把每轮 rollout 变成后续 rollout 的结构化状态。

TMAS 的五个 agent 分工如下：

Agent	输入	输出	作用
Solution Agent ${\mathcal{A}}_{\text{sol}}$	问题 $Q$，上一轮 rollouts / experience 或 guideline	候选解 $c_{t,i}$	生成 exploit 或 explore 分支的 candidate solution
Verification Agent ${\mathcal{A}}_{\text{ver}}$	$Q$ 与候选解 $c_{t,i}$	$M$ 个 verification outputs + score	给出正确、部分正确、致命错误等反馈
Summary Agent ${\mathcal{A}}_{\text{sum}}$	候选解与 $M$ 个验证结果	rollout summary $s_{t,i}$	把多次验证压缩成可复用摘要
Experience Agent ${\mathcal{A}}_{\text{exp}}$	当前 rollouts ${\mathcal{R}}_t$ 与旧 experience bank	新 experience bank ${\mathcal{E}}_t$	提取 verified anchors、局部技巧、错误规避规则
Guideline Agent ${\mathcal{A}}_{\text{guide}}$	当前 rollouts ${\mathcal{R}}_t$ 与旧 guideline bank	新 guideline bank ${\mathcal{G}}_t$	记录已探索过的高层策略，帮助后续非冗余探索

直觉上，experience bank 更像“这道题已经验证过的局部事实库”，例如某个中间结论、边界条件、常见错误；guideline bank 更像“解题路线日志”，例如已经尝试过 induction / generating function / case split 等。把两者混在一起会导致 exploitation 与 exploration 互相干扰：低层事实应该被复用，高层路线却常常应该被避开以扩大搜索。

3.2 Multi-agent inference：epsilon-greedy 的探索/利用调度

对问题 $Q$，TMAS 运行 $T$ 个 iteration。每轮生成 $N$ 条候选轨迹，并对每条轨迹做 $M$ 次独立验证。第 $t$ 轮第 $i$ 条候选解按 epsilon-greedy 方式采样： $c_{t,i}\sim \{\begin{array}{ll}{\mathcal{A}}_{\text{sol}}(Q,{\mathcal{R}}_{t-1},{\mathcal{E}}_{t-1}),& \text{with probability }1-ϵ,\\ {\mathcal{A}}_{\text{sol}}(Q,{\mathcal{G}}_{t-1}),& \text{with probability }ϵ.\end{array}$ 第一支路是 exploitation：看上一轮 rollouts 与 experience bank，修补已有思路；第二支路是 exploration：只给 guideline constraint，要求模型避开已记录的高层路线。每条候选解的 verification set 为： ${\mathcal{V}}_{t,i}={\left\{{\mathcal{A}}_{\text{ver}}^{(m)}(Q,c_{t,i})\right\}}_{m=1}^M.$ summary agent 将验证结果压缩为： $s_{t,i}={\mathcal{A}}_{\text{sum}}(Q,c_{t,i},{\mathcal{V}}_{t,i}),$ 并把 rollout 定义为 $r_{t,i}=(c_{t,i},s_{t,i})$，当前轮集合为 ${\mathcal{R}}_t=\{r_{t,i}{\}}_{i=1}^N$。然后两个 memory update agent 并行更新： ${\mathcal{E}}_t={\mathcal{A}}_{\text{exp}}(Q,{\mathcal{R}}_t,{\mathcal{E}}_{t-1}),{\mathcal{G}}_t={\mathcal{A}}_{\text{guide}}(Q,{\mathcal{R}}_t,{\mathcal{G}}_{t-1}).$ Released code 的主流程在 code/inference.py::HighComputeSearch.run_single_problem 中实现。它为每道题创建 PersistentMemory(..., file_suffix="experience") 和 PersistentMemory(..., file_suffix="guideline")，每轮用 random.random() < epsilon 决定每个 solution 是否走 guideline branch，然后 asyncio.gather 并发运行所有 solution、verification、summary、experience update 和 guideline update。

async def tmas_inference(problem, cfg, memory_dir):
    question = problem["question"]
    n_candidates = cfg.get("n_candidates", 8)
    n_verifications = cfg.get("n_verifications", 8)
    max_iterations = cfg.get("max_iterations", 20)
    epsilon = cfg.get("epsilon", 0.2)
 
    experience_bank = PersistentMemory(problem["problem_id"], memory_dir, "experience", threshold=0.7)
    guideline_bank = PersistentMemory(problem["problem_id"], memory_dir, "guideline", threshold=0.7)
    await experience_bank.load_from_file()
    await guideline_bank.load_from_file()
 
    prev_rollouts = []
    best_candidate = None
    for iter_idx in range(max_iterations):
        use_guideline = [random.random() < epsilon for _ in range(n_candidates)]
        current_rollouts = await asyncio.gather(*[
            process_one_solution(
                question=question,
                prev_rollouts=prev_rollouts,
                experiences=experience_bank.items,
                guidelines=guideline_bank.items,
                use_guideline=use_guideline[i],
                n_verifications=n_verifications,
            )
            for i in range(n_candidates)
        ])
        current_rollouts = [r for r in current_rollouts if r is not None]
        if not current_rollouts:
            continue
 
        best_candidate = max(current_rollouts, key=lambda r: r.candidate.average_score).candidate
        new_experiences, new_guidelines = await asyncio.gather(
            experience_extractor.evolve_experience_bank(current_rollouts, question, experience_bank.items),
            guideline_manager.update_guideline_bank(current_rollouts, question, guideline_bank.items),
        )
        experience_bank.items = new_experiences or experience_bank.items
        guideline_bank.items = new_guidelines or guideline_bank.items
        await experience_bank.save_to_file()
        await guideline_bank.save_to_file()
        prev_rollouts = current_rollouts
 
    return best_candidate

3.3 Solution generation：rollout/experience branch 与 guideline branch 的提示词差异

code/generation.py 把 solution prompt 分成两个模式：

• exploitation mode (generate_with_rollouts)：如果存在 previous rollouts，就使用 REFINE_GENERATION_PROMPT，追加 rollout context；如果存在 experience bank，就把 Anchor: 条目格式化为 verified anchors，把 Heuristic: 条目格式化为 error-avoidance heuristics。
• exploration mode (generate_with_guideline)：当 use_guideline=True 时，代码会清空前面组装的 rollout/experience prompt，只保留基础 proof generation prompt 与 guideline constraint。这与论文中 ${\mathcal{A}}_{\text{sol}}(Q,{\mathcal{G}}_{t-1})$ 的设定一致：探索分支不直接继承上一轮具体解，而是被要求避开既有策略。

def build_solution_prompt(question, prev_rollouts, experiences, guidelines, use_guideline, max_rollouts=None):
    if max_rollouts is not None and len(prev_rollouts) > max_rollouts:
        prev_rollouts = random.sample(prev_rollouts, max_rollouts)
 
    if use_guideline:
        prompt = PROOF_GENERATION_PROMPT.format(question=question)
        if guidelines:
            prompt += "\n\n" + GUIDELINE_CONSTRAINT_TEMPLATE.format(
                tried_list="\n".join(f"- {g}" for g in guidelines)
            )
        return prompt
 
    prompt = REFINE_GENERATION_PROMPT.format(question=question) if prev_rollouts else PROOF_GENERATION_PROMPT.format(question=question)
    if prev_rollouts:
        prompt += "\n\n" + ROLLOUT_CONTEXT_HEADER + format_rollouts(prev_rollouts)
    if experiences:
        prompt += "\n\n" + format_experience_bank(experiences)
    return prompt

3.4 Verification 与 summary：多次独立判断压缩成 rollout summary

code/verification.py::Verifier.verify_batch 为每个 candidate 补齐到 n_verifications 个验证结果。每个 verification prompt 包含原问题和候选 proof，调用 verifier model 后用 utils.extract_score 解析数值分数；随后 summarize_verifications 把所有 evaluations 及 score 拼成 VERIFICATION_SUMMARY_TEMPLATE，生成一个自然语言 summary。

async def verify_and_summarize(candidate, question, n_verifications):
    tasks = []
    for _ in range(n_verifications - len(candidate.verifications)):
        prompt = VERIFY_TEMPLATE.format(question=question, proof=candidate.proof_text)
        tasks.append(call_llm(prompt, mode="verification", temperature=1.0))
 
    for response in await asyncio.gather(*tasks):
        score = extract_score(response)
        if score is not None:
            candidate.verifications.append(VerificationResult(analysis=response, score=score))
 
    evaluations = "\n\n".join(
        f"[Evaluation {i+1} - Score: {v.score}]\n{v.analysis}"
        for i, v in enumerate(candidate.verifications)
    )
    summary = await call_llm(
        VERIFICATION_SUMMARY_TEMPLATE.format(
            question=question,
            solution=remove_think_block(candidate.proof_text),
            n_verifications=len(candidate.verifications),
            evaluations=evaluations,
        ),
        mode="verification_summary",
        temperature=0.6,
    )
    return Rollout(candidate=candidate, verification_summary=summary)

实现上，Candidate.average_score 是所有 verification scores 的均值；Candidate.is_fully_verified(threshold=8) 要求验证数量至少 threshold - 2 且所有已有分数等于 1.0。这意味着在 API 失败导致少数 verification 缺失时，released code 允许 6/6 全 1.0 被视为 solved，而不是严格要求 8/8。

3.5 Experience bank 与 guideline bank：一个提低层事实，一个提高层路线

code/experience.py::ExperienceExtractor.evolve_experience_bank 会把当前轮 rollouts 格式化为 solution + verification summary，要求 LLM 输出 JSON。输出中的 verified_anchors 被写成 Anchor: ...，error_avoidance_heuristics 被写成 Heuristic: ...。如果 n_verifications=0，代码会跳过 experience evolution，以避免无监督生成 hallucinated experience。

code/guideline.py::GuidelineManager.update_guideline_bank 则要求 LLM 管理 high-level strategy list。论文 prompt appendix 明确要求 guideline bank 是 append-only：记录已尝试过的 conceptual approach / proof strategy，不记录低层计算细节；重复策略不新增。这让 guideline bank 可以作为 exploration constraint：后续 exploration branch 不是“沿着这个策略继续”，而是“不要复用这些策略”。

async def update_memory_banks(question, current_rollouts, experience_bank, guideline_bank):
    experience_input = [
        {
            "solution": remove_think_block(r.proof_text),
            "verification_summary": r.verification_summary,
            "avg_score": r.avg_score,
        }
        for r in current_rollouts
    ]
    experience_json = await call_llm(
        EXPERIENCE_EVOLUTION_FROM_ROLLOUTS_TEMPLATE.format(
            question=question,
            existing_experiences=split_anchors_and_heuristics(experience_bank),
            rollouts=experience_input,
        ),
        mode="experience_evolution",
        temperature=0.6,
    )
    new_experience_bank = [f"Anchor: {x}" for x in experience_json["verified_anchors"]]
    new_experience_bank += [f"Heuristic: {x}" for x in experience_json["error_avoidance_heuristics"]]
 
    guideline_json = await call_llm(
        GUIDELINE_UPDATE_FROM_ROLLOUTS_TEMPLATE.format(
            question=question,
            existing_guidelines=guideline_bank,
            rollouts=experience_input,
        ),
        mode="guideline_update",
        temperature=0.6,
    )
    return new_experience_bank, guideline_json["updated_guidelines"]

论文公式与 released code 实现差异：论文和 prompt appendix 把 guideline bank 描述为 append-only，但 GuidelineManager.update_guideline_bank 在代码层面直接用 LLM 返回的 updated_guidelines 替换旧列表；append-only 约束主要依赖 prompt 执行，而不是由 Python 代码强制检查。另一个实现差异是，论文讨论了 Hybrid-RL 训练，但公开 repo 当前只包含 inference/evaluation pipeline 与 RL-training-data.parquet，没有发布 verl GRPO 训练脚本；因此 Hybrid-RL 的 reward 伪代码只能依据论文公式和 appendix training settings，而不是 released training code。

3.6 Hybrid Reward RL：让模型学会使用 experience 与探索新策略

论文在 GRPO / RLVR 框架上训练 Qwen3-4B-Thinking-2507。GRPO 目标保持不变，只改 rollout-level reward ${\tilde{r}}_i$： $J_{\mathrm{GRPO}}(\theta )={\mathbb{E}}_{Q,\{o_i\}}\left[\frac{1}{{\sum }_i|o_i|}{\sum }_{i=1}^N{\sum }_{t=1}^{|o_i|}\min \left({\rho }_{i,t}{A}_i,\mathrm{clip}({\rho }_{i,t},1-{ϵ}_{\mathrm{low}},1+{ϵ}_{\mathrm{high}})A_i\right)\right],$ 其中 ${\rho }_{i,t}={\pi }_{\theta }(o_{i,t}\mid Q,o_{i,<t})/{\pi }_{{\theta }_{\mathrm{old}}}(o_{i,t}\mid Q,o_{i,<t})$，$A_i=({\tilde{r}}_i-\mu )/(\sigma +\delta )$。三类 reward 是：

1. Standard Correctness Reward：答案正确给 $+1$，错误给 $-1$，保留基础数学推理能力。
2. Experience Utilization Reward：把 rollouts 分成 Base group 与 Bank group；Base 只看问题和历史轨迹，Bank 额外看 experience bank。若 Bank group 的正确 rollout 解决了 Base group 难以解决的问题，则奖励更高： $p_{\mathrm{base}}=\frac{1}{|{\mathcal{B}}_{\mathrm{base}}|}{\sum }_{i\in {\mathcal{B}}_{\mathrm{base}}}\mathbb{I}[r_i=1],$ ${\tilde{r}}_i=\{\begin{array}{ll}{r}_i+\beta (1-p_{\mathrm{base}}),& i\in {\mathcal{B}}_{\mathrm{bank}},r_i=1,\\ r_i,& \text{otherwise}.\end{array}$
3. Novel Strategy Exploration Reward：同时看答案正确性 $r_i$ 与 guideline-level novelty $n_i$： ${\tilde{r}}_i=\{\begin{array}{ll}+1.0,& r_i=+1,n_i=1,\\ +0.2,& r_i=+1,n_i=0,\\ -0.5,& r_i=-1,n_i=1,\\ -1.0,& r_i=-1,n_i=0.\end{array}$ 这个 reward 的偏好很明确：正确性仍然最重要；在正确解之间，新策略优于重复策略；在错误解之间，新策略的惩罚也比重复无效策略轻，因为它至少扩展了搜索空间。

def hybrid_reward(batch, beta=0.6):
    rewards = []
    if batch.objective == "standard_correctness":
        for rollout in batch.rollouts:
            rewards.append(1.0 if rollout.final_answer_correct else -1.0)
 
    elif batch.objective == "experience_utilization":
        base = [r for r in batch.rollouts if r.group == "base"]
        p_base = sum(r.final_answer_correct for r in base) / max(len(base), 1)
        for rollout in batch.rollouts:
            r = 1.0 if rollout.final_answer_correct else -1.0
            if rollout.group == "bank" and rollout.final_answer_correct:
                r = r + beta * (1.0 - p_base)
            rewards.append(r)
 
    elif batch.objective == "novel_strategy_exploration":
        for rollout in batch.rollouts:
            correct = rollout.final_answer_correct
            novel = guideline_judge(rollout.solution_guideline, batch.existing_guidelines)
            if correct and novel:
                rewards.append(1.0)
            elif correct and not novel:
                rewards.append(0.2)
            elif (not correct) and novel:
                rewards.append(-0.5)
            else:
                rewards.append(-1.0)
    return group_normalize(rewards)

3.7 Code-to-paper mapping

Code reference: master @ 426dbbcd (2026-05-14) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
End-to-end TMAS inference loop	code/inference.py	HighComputeSearch.run_single_problem
Solution generation / epsilon branch	code/generation.py, code/inference.py	SolutionGenerator.generate_from_rollouts, process_one_solution
Verification and summary agent	code/verification.py	Verifier.verify_batch, Verifier.summarize_verifications
Experience bank evolution	code/experience.py, code/memory.py	ExperienceExtractor.evolve_experience_bank, PersistentMemory
Guideline bank evolution	code/guideline.py, code/memory.py	GuidelineManager.update_guideline_bank, PersistentMemory
Candidate / rollout scoring	code/structures.py	Candidate.average_score, Candidate.is_fully_verified, Rollout
Inference hyperparameters	run.sh, code/main.py	N_CANDIDATES=8, N_VERIFICATIONS=8, MAX_ITERATIONS=20, EPSILON=0.2, MAX_TOKENS=128000
Prompt templates	code/prompts.py, paper appendix supplementary/prompts.tex	proof generation, refine generation, verification, experience evolution, guideline update
Hybrid-RL training	paper appendix supplementary/experimental_details.tex; no released training script found	reward design described in paper; repo contains RL-training-data.parquet but no verl training entrypoint

4. Experimental Setup (实验设置)

Datasets and scale

• IMO-AnswerBench-50：从原始 400 题 IMO-AnswerBench 中筛选。作者用 Qwen3-4B-Thinking-2507 对每题做 8 次独立推理，保留 8 次中正确少于 2 次的难题池，再选 50 题做主实验。
• HLE-Math-100：采用 RSE 发布的 Human’s Last Exam 数学子集，共 100 题。
• Full IMO-AnswerBench：完整 400 题，用于检验 hard subset 上的增益是否能泛化。
• AIME26 / HMMT-25-Nov：补充评估，作者认为这些 benchmark 对所用 base model 相对较容易，因此不作为主结果。

Baselines

论文比较了五类 test-time scaling baseline：MV@64（majority vote）、Self-Refine、Verify-Refine (V-R)、PaCoRe、RSE。Self-Refine 使用 8 条并行 solution 并独立 refine；V-R 先生成 solution，再用 verifier 判断并由 corrector 修正；PaCoRe 和 RSE 使用其官方实现，并把输入格式改到对应数据集。为公平比较，PaCoRe 的 num_responses_per_round=8、N_COMPLETIONS=8，与 TMAS 的 8 条并行 solution budget 对齐。

Metrics

主指标是 Pass@1 accuracy (%)。每个生成解由 DeepSeek-V3.2 做 4 次独立 LLM-as-Judge，与 reference answer 判断等价性，得到 4 个 binary correctness labels。第 $r$ 次 judge 的 Pass@1 为： ${\text{Pass@1}}^{(r)}=\frac{1}{|\mathcal{P}|}{\sum }_{i=1}^{|\mathcal{P}|}\frac{c_i^{(r)}}{n_i},$ 最终报告为： $\text{Pass@1}=\frac{1}{R}{\sum }_{r=1}^R{\text{Pass@1}}^{(r)}.$

Inference and training config

Inference config 来自 released run.sh / code/main.py：每题 $N=8$ 条 parallel candidate solutions，$M=8$ 个 verification agents，最多 20 iterations，$ϵ=0.2$，最大输出长度 128K tokens，temperature=1.0，top_p=0.95，NO_PROOF=true，INCLUDE_PAST_SOLUTIONS=true，默认 MAX_ROLLOUTS 为空即使用上一轮所有 rollouts。run.sh 还把 CONCURRENCY=800、MAX_CONCURRENT_PROBLEMS=100 作为大规模评测参数。

Hybrid-RL training config 来自论文 appendix（released repo 未提供 verl training script）：backbone 为 Qwen3-4B-Thinking-2507；每个 prompt 采样 16 rollouts；每个 response 最多 80K output tokens；训练使用 256 张 NVIDIA H20 GPU；batch size 128；learning rate $1\times 10^{-6}$；训练 190 steps；启用 dynamic batching、optimizer offloading、activation recomputation；rollout generation 使用 SGLang，并在 rollout generation 中使用 FP8 quantization；clipping range 为 $[0.20,0.255]$，clipping coefficient 10.0；entropy coefficient 0；reward 不使用 KL regularization；Experience Utilization Reward 的最大 bonus coefficient 为 $\beta =0.6$。

冷启动训练数据由 DAPO 与 Skywork-OR1 等开源 RL 数据出发，用 DeepSeek-V3.2 作为 teacher 模拟 TMAS-style iterative inference。最终数据包含 1.6K 条 Experience Utilization、0.6K 条 Novel Strategy Exploration、2.2K 条 Standard Correctness Reward 训练实例。

5. Experimental Results (实验结果)

5.1 Main results：TMAS 的迭代收益更稳定

在 Qwen3-30B-Thinking-2507 上，TMAS 在 IMO-AnswerBench-50 的 It19 达到 40.50，超过 RSE 的 38.00、V-R 的 31.06、PaCoRe 的 30.31、Self-Refine 的 24.19；在 HLE-Math-100 的 It19 达到 35.38，也超过 RSE 的 31.75、PaCoRe 的 32.78、V-R 的 30.41、Self-Refine 的 27.12。早期 PaCoRe 在 It1/It3 可能更强，但后期 TMAS 持续爬升，说明 hierarchical memories 更适合利用更长 iteration budget。

在 Qwen3-4B-Thinking-2507 上，未训练的 TMAS 在 IMO-AnswerBench-50 It19 为 17.06，HLE-Math-100 It19 为 17.41；加入 Hybrid-RL 后分别提升到 30.88 和 28.16。论文特别强调，It19 时 4B 与 30B TMAS 的差距从 IMO 上的 23.44 点缩小到 9.62 点，在 HLE 上从 17.97 点缩小到 7.22 点，对应相对缩小 59.0% 和 59.8%。

Figure 3 解读：这张图比较 No RL、Vanilla-RL 和 Hybrid-RL 的迭代曲线。Vanilla-RL 只奖励最终正确性，能提高早期能力，但后期容易饱和或回落；Hybrid-RL 额外奖励 experience utilization 与 novel strategy exploration，因此随着 iteration 增加仍能利用 memory bank 继续改进。

5.2 Full IMO-AnswerBench：小 backbone 接近 frontier 系统

完整 IMO-AnswerBench 有 400 题。Qwen3-30B-A3B-Thinking-2507 用 TMAS 从 64.9% 提升到 77.2%，增益 12.3 点；Qwen3-4B-Thinking-2507 用 TMAS + Hybrid-RL 从 53.5% 提升到 73.5%，增益 20.0 点。作者将这些结果与 DeepSeek-V3.2、Kimi-K2.5、Opus-4.6 Max 等报告值放在一起，说明 TMAS 的价值主要体现在用 test-time compute 弥补模型规模差距。

5.3 Ablation：experience 与 guideline 贡献互补

组件消融在 Qwen3-30B-Thinking-2507 + IMO-AnswerBench-50 上进行。完整 TMAS 从 It0 的 10.88 提升到 It11 的 37.81；移除 guideline 后 It11 为 35.75；移除 experience 后 It11 为 33.44；两者都移除后 It11 为 33.16。早期去掉 guideline 的伤害更明显，例如 It1 从 22.06 掉到 10.88，说明 guideline 对快速避开重复策略重要；后期去掉 experience 的伤害更持续，说明低层 verified anchors 对长期 refinement 更关键。

Figure 4 解读：Figure 4a–4f 分别分析 $ϵ$、verification count、parallel solution count 对 IMO-AnswerBench-50 与 HLE-Math-100 的影响。$ϵ=0$ 太保守，$ϵ=1.0$ 太发散，$ϵ=0.2$ 最平衡；verification count 从 0 提到 8 明显有益，但 16 会引入冗余或不一致反馈；parallel solutions 太少限制多样性，过多则难以被系统有效整合，8 条是主实验采用的折中点。

5.4 Supplementary benchmarks and exploration analysis

Figure 5 解读：AIME26 与 HMMT-25-Nov 上，不同方法差距较小。作者把它们放在 appendix，是因为这些题对 Qwen3-30B-A3B-Thinking-2507 相对容易，不能充分体现 test-time compute 在高难任务上的边际收益。

Figure 6 解读：随着 exploration coefficient $ϵ$ 变大，unique solution guidelines 数量上升，说明 guideline branch 确实增加了策略多样性。但 Figure 4 已经说明，多样性不是越多越好；太高的 $ϵ$ 会削弱对已有正确轨迹和 experience 的利用。

5.5 Verification paradox：verifier 与 generator 共享能力边界

Figure 7 解读：论文把 IMO-AnswerBench-50 题目分成 ever-correct 与 never-correct 两组。基础模型中，never-correct 题反而长期得到更高 verification scores，说明 verifier 在 hardest unsolved problems 上也会误判；Hybrid-RL 后两个组的 verification score 都上移且差距变小，但 verifier 仍不是完美判别器。

Figure 8 解读：基础模型中 never-correct 题的平均 verification score 比 ever-correct 高 $\Delta =+0.110$，且 $p=0.00622$，这很反直觉；Hybrid-RL 后差距变成 $\Delta =+0.056$，$p=0.448$，不再显著。作者据此指出：进一步强化 verifier，或者引入更专门的 verifier model，是 TMAS 后续提升的重要方向。

5.6 Case study：experience bank 如何把一次正确 rollout 变成后续可复用知识

Figure 9 解读：case study 是 HLE-Math-100 的 Problem 720：用 $2\times 1$、$2\times 2$、$2\times 4$ tiles 铺 $2\times 4$ board。错误路线假设 $2\times 1$ 只能竖放，得到 $T(2)=2$ 与 $T(4)=6$；正确路线允许 $2\times 1$ 横放，得到 $T(2)=3$、递推 $T(n)=T(n-1)+2T(n-2)+T(n-4)$，最终 $T(4)=12$。TMAS 的 experience bank 会保存 $T(2)=3$、$T(3)=5$、正确递推式和“不要假设只能竖放”的 avoidance heuristic，使后续 rollouts 从局部正确发现中受益。

Table 11 中的 experience entries 说明 experience bank 存的是低层、可操作的事实：verified anchors $T(2)=3$、$T(3)=5$，structural rule $T(n)=T(n-1)+2T(n-2)+T(n-4)$，以及避免 vertical-only assumption 的 heuristic。Table 12 显示 TMAS 的正确 rollouts 数从 iteration 0/1 的 0/8，到 iteration 5 的 1/8，iteration 10 的 4/8，iteration 11 和 15/19 的 7/8；无 experience baseline 在这些采样点始终是 0/8。这个例子清楚展示了 TMAS 的核心机制：一次正确轨迹不会只作为最终答案候选存在，而会被转写成后续轨迹能直接利用的局部知识。

5.7 Limitations

论文在 conclusion 和 appendix 中强调的主要限制是 verification capability。TMAS 依赖 verifier feedback 来生成 summary、experience 和 guideline；如果 verifier 与 generator 共享同一能力边界，最难题上的错误解可能也得到高分，导致 memory bank 污染或 refinement 方向偏移。作者提出的后续方向包括：让 verifier 针对 ground-truth correctness 更直接地训练、使用更强或更专门的 verifier model、改进 verification signal 与 generation capability 的协同扩展。

整体结论是：TMAS 证明了 test-time scaling 的一个更细粒度方向——不是简单增加 rollouts，而是把 rollouts 产生的信息组织成跨 agent、跨轨迹、跨 iteration 的结构化记忆。Hybrid-RL 则进一步让模型学会何时利用这些记忆、何时跳出已有策略。