ARISE: Agent Reasoning with Intrinsic Skill Evolution in Hierarchical Reinforcement Learning

Paper: arXiv:2603.16060 Code: Skylanding/ARISE Code reference: main @ 2d6f65dd (2026-05-19)

1. Motivation (研究动机)

现有 verifiable reward RL（例如 GRPO / DAPO / GSPO）能让 LLM 通过多次 rollout 和答案验证提升数学推理，但它们通常把每个题目当成一次性的独立训练样本：rollout 结束后，成功轨迹里出现的可复用策略不会被沉淀下来，也不会在后续问题中被策略本身主动检索。这样会带来三个具体瓶颈：第一，训练会反复探索相同的解题套路，样本效率低；第二，模型很难把在 AMC/AIME/MATH 中学到的高层启发式迁移到 Omni-MATH 这类更强 OOD 奥赛题；第三，如果用外部 memory/retriever 来补救，检索和总结通常不在 policy gradient 的闭环里，策略并不知道“选哪个 skill 会带来更高 advantage”。

ARISE 想解决的核心问题是：如何让“技能库”不只是外部检索组件，而是 RL 状态的一部分，并让同一个策略同时学会 选择技能、使用技能解题、总结新技能。这把 agent 推理从“单题试错”改成“训练中持续积累可复用 skill，再把 skill 反哺给后续 rollout”。

Figure 1 解读：这张总览图把 ARISE 的收益分成四类证据：七个 benchmark 的 Pass@1、DeepScaleR 训练 reward 动态、训练过程中的 skill utilization，以及相对 GRPO 的 token overhead。它强调的不是单纯“多塞 context”，而是在较小 prompt overhead（论文补充表给出 ARISE 总 token 约 3,254、相对 GRPO +3.0%）下，让 policy 学会在合适时机使用技能。

2. Idea (核心思想)

ARISE 的核心 insight 是：成功 reasoning trace 中的“解题策略”应该被视为 agent state 的内生可演化部分，而不是离线日志或外部 memory。Manager 在执行前用当前 policy 对候选 skill 做条件 log-probability scoring；Worker 在 skill-conditioned prompt 下生成解答；执行后同一个 policy 再根据正 advantage trace 总结新 skill，形成 policy 和 library 的共同演化。

与 SimpleMem / EvolveR / SkillRL 这类 memory-augmented 方法相比，ARISE 的关键差别是 skill selection 本身由 $π_{θ}$ 评分并进入 RL 闭环；外部 retriever 不再决定“检索什么”。与 vanilla GRPO/DAPO/GSPO 相比，ARISE 不是只优化 token-level solution policy，而是在 Evolving-Skill MDP 中把技能库 $M_{t}$ 纳入状态，让 skill 的 ADD / UPDATE / EVICT / LOAD / DELETE 成为训练动态的一部分。

3. Method (方法)

3.1 总体框架：Evolving-Skill MDP + Manager/Worker 共享策略

ARISE 定义 Evolving-Skill MDP： $⟨ Q, M, A, T, R ⟩,$ 其中 $Q$ 是 query distribution， $M$ 是 skill library configuration space， $A$ 是 skill management action space， $T : M \times A \to M$ 是 library transition， $R : Q \times M \times A \to {r_{0}, r_{1}, r_{2}}$ 且 $r_{2} > r_{1} > r_{0}$ 。训练步 $t$ 的 augmented state 是 $s_{t} = (q_{t}, M_{t})$ ，每个 library entry $e_{k} = (m_{k}, u_{k})$ 包含结构化 skill document 和 utility estimate。

Figure 2 解读：ARISE 用同一个 $π_{θ}$ 扮演两种角色：高层 Skills Manager 和低层 Worker。执行前，Manager 从 cache 中对每个 skill 打分并选择一个 skill 注入 prompt（Download）；Worker 基于 query + selected skill 生成 $G$ 条 solution rollout；reward/advantage 计算后，额外的 $O_{G + 1}$ skill generation rollout 把正 advantage traces 总结成新 skill（Upload）。cache 是 active selection pool，reservoir 是更大的 archive；五个操作 ADD / UPDATE / EVICT / LOAD / DELETE 维持两层库。

整体 joint probability 被分解为三段： $π_{θ} (a_{t}, τ_{t} ∣ q_{t}, M_{t}) = π_{θ}^{mgr} (z_{t} ∣ q_{t}, M_{t}) \cdot π_{θ}^{wkr} (τ_{t} ∣ q_{t}, \tilde{m}_{z_{t}}) \cdot π_{θ}^{lib} (a_{t}^{lib} ∣ q_{t}, M_{t}, τ_{t}) .$ 这里 $z_{t}$ 是 selected skill index， $\tilde{m}_{z_{t}}$ 是注入到 prompt 的 skill 文档， $a_{t}^{lib}$ 是库更新动作。直觉上，这个分解把“选 skill → 用 skill 解题 → 从成功轨迹中生成新 skill”放进同一个可优化闭环；如果移除其中任一环，skill 要么无法影响 policy gradient，要么无法随着训练质量提升而变好。

3.2 Policy-driven skill selection

对 cache 中每个 candidate skill $m_{k}$ ，ARISE 用当前策略计算 skill text 在 query 条件下的 token log-probability： $s_{k} = \sum_{l = 1}^{∣ m_{k} ∣} lo g π_{θ} (m_{k}^{(l)} ∣ q_{t}, m_{k}^{(< l)}) .$ 随后用 temperature softmax 得到选择概率： $p_{k} = \frac{e x p ( s _{k} / σ )}{\sum _{j} e x p ( s _{j} / σ )}, z_{t} \sim (1 - ε) \cdot δ_{a r g m a x_{k} p_{k}} + ε \cdot Uniform (M_{t}) .$ 论文补充中还给出 confidence gate：若 $max_{j} p_{j} < δ$ ，Manager 选择 no-skill branch $z_{t} = \emptyset$ ，避免把低相关 skill 强行注入。

released code 对应 verl/workers/arise/skill_manager.py：score_with_callable() 对每个 LibraryEntry.document.to_json() 计算 sum log-prob 并做 length normalization；softmax() 用 temperature=1.0；select() 在 max_prob < confidence_threshold 时返回 entry=None，否则按 $ε$ -greedy 选择 argmax 或随机 skill；inject() 只在有 selected skill 时 prepend SKILL: prefix。

def select_skill(query, cache, log_prob_fn, token_count_fn, sigma=1.0, eps=0.1, delta=0.35):
    scores = []
    for entry in cache:  # code: SkillLibrary.iter_candidates() returns active cache only
        skill_text = entry.document.to_json()
        lp = float(log_prob_fn(query, skill_text))
        n = token_count_fn(skill_text) if token_count_fn else len(skill_text.split())
        scores.append(lp / max(n, 1))
 
    probs = torch.softmax(torch.tensor(scores) / sigma, dim=0)
    if len(probs) == 0 or probs.max().item() < delta:
        return None, query
 
    if torch.rand(()) < eps:
        idx = torch.randint(len(cache), ()).item()
    else:
        idx = int(torch.argmax(probs).item())
    skill = cache[idx].document
    return skill, skill.to_prompt_prefix() + query

3.3 Skill generation rollout $O_{G + 1}$ 与结构化 skill document

在 $G$ 条 solution rollout 完成后，ARISE 取正 advantage traces： $τ^{+} = {τ_{i} ∣ \hat{A}_{i} > 0},$ 再用同一个 policy 做额外 inference-only rollout $O_{G + 1}$ ，生成新 skill： $M_{t + 1}^{c}, M_{t + 1}^{r} = T (M_{t}^{c}, M_{t}^{r}, m^{new}), m^{new} \sim π_{θ} (\cdot ∣ q_{t}, τ^{+}) .$ skill document 采用统一 schema：skill_name、problem_type、key_insight、method、check。统一格式的目的不是美观，而是让 log-prob scoring 更像语义相关性评分，而不是被不同格式长度/表面模式干扰。

released code 对应 verl/workers/arise/skill_conclusion.py：SkillConcluder.build_prompt() 最多取 2 条 positive traces，每条截断 400 characters；生成参数由 recipe/论文给出 temperature 0.7、top-p 0.95、max new tokens 192；validate_and_parse() 失败时会用 trace_abstract_fallback() 从第一条成功 trace 兜底。

def conclude_skill(question, positive_traces, generate_fn, max_traces=2, trace_clip_chars=400):
    if not positive_traces:
        return None
    selected = positive_traces[:max_traces]
    traces_block = "\n".join(
        f"[SUCCESS #{i+1}] {trace[:trace_clip_chars]}" for i, trace in enumerate(selected)
    )
    prompt = SUMMARY_PROMPT_TEMPLATE.format(
        question=question,
        traces_block=traces_block,
        max_chars=350,  # released recipe / skill_document effective cap
    )
    raw = generate_fn(prompt)
    doc = validate_and_parse(raw)
    if doc is None:
        doc = trace_abstract_fallback(selected[0])
    return doc

论文公式与 released code 实现差异：论文 Table 3 / Appendix C.1 写 Max skill document length = 220 chars，但 released code 中 verl/workers/arise/skill_document.py 明确把 MAX_DOCUMENT_CHARS = 350，注释说明论文 Figure 3 示例和 seed skills 已超过 220；两个 recipe config（recipe/arise/config/arise_qwen3_4b.yaml 与 arise_phi4_mini.yaml）也设置 summary_max_chars: 350。因此复现实验时应以 config/code 的 350 为准，而不是只看论文表格的 220。

3.4 两层 skill library 与维护操作

library 被分成 cache $M^{c}$ 和 reservoir $M^{r}$ ：cache capacity $C_{c} = 10$ ，是 Manager 每步真正评分和选择的 active pool；reservoir capacity $C_{r} = 100$ ，保存暂时未在 cache 中的 surplus skills。released code 的 SkillLibrary.step() 固定执行：UPDATE -> ADD -> EVICT -> LOAD -> DELETE。

UPDATE：对 selected skill 的 utility 做 EMA： $u_{z} \leftarrow β u_{z} + (1 - β) R_{t}$ ，代码默认 $β = 0.9$ 。
ADD：把 $O_{G + 1}$ 新生成且未重名的 skill 加入 cache。
EVICT：当 cache 超过 $C_{c}$ 时，把 utility 最低的 cache entry 溢出到 reservoir。
LOAD：若 reservoir 中最高 utility entry 优于 cache 中最弱 entry，则 swap 回 cache。
DELETE：删除 reservoir 中 utility 低于 percentile 且从未被选中过的 stale entries，并按 $C_{r}$ 做硬上限裁剪。

def maintain_library(library, selected_name, selected_reward, new_doc, new_utility):
    if selected_name is not None:
        entry = library.get(selected_name)
        entry.utility = 0.9 * entry.utility + 0.1 * float(selected_reward)
        entry.usage_count += 1
 
    if new_doc is not None and not library.has(new_doc.skill_name):
        library.cache[new_doc.skill_name] = LibraryEntry(new_doc, utility=new_utility)
 
    if len(library.cache) > 10:
        weakest = min(library.cache.values(), key=lambda e: e.utility)
        move(library.cache, library.reservoir, weakest.name)
 
    if library.reservoir:
        best_r = max(library.reservoir.values(), key=lambda e: e.utility)
        weakest_c = min(library.cache.values(), key=lambda e: e.utility)
        if best_r.utility > weakest_c.utility:
            swap(library.cache, library.reservoir, best_r.name, weakest_c.name)
 
    delete_low_utility_unused_reservoir_entries(library, capacity=100)

3.5 Hierarchical reward 与两阶段训练

Phase I 是 warm-up：前 $N_{w} = 500$ steps 禁用 skill selection，只用 binary task reward $r^{task} \in {0, 1}$ 训练 Worker，同时仍然运行 skill conclusion 以填充早期 library。Phase II 从 step 501 开始启用 skill selection 和 hierarchical reward： $R = r^{task} + r^{skill} \in {0, 1, 2},$ 其中 $r^{skill} = 1$ 仅当 trajectory 同时“使用了 selected skill”且“答案正确”。这避免了模型为了拿 bonus 而滥用 skill：skill 用了但答错仍然是 0。

GRPO advantage 采用 group-relative normalization： $\hat{A}_{i} = \frac{r _{i} - μ _{G}}{σ _{G} + ϵ}, μ_{G} = \frac{1}{G} \sum_{i = 1}^{G} r_{i},$ Phase I 中 $r_{i} = r_{i}^{task}$ ，Phase II 中 $r_{i} = R_{i}$ 。released code 中 AriseReward.trajectory_reward() 实现 $r^{task}$ 和 $r^{skill}$ 的组合，PhaseScheduler.decide() 在 step $1.. N_{w}$ 返回 score_skills=False/use_hierarchical_reward=False/conclude_skills=True，从 $N_{w} + 1$ 开始全部启用。

def arise_train_step(step, batch, policy, library, reward_model, generate_skill):
    decision = phase_scheduler.decide(step)
    all_rollouts, all_rewards = [], []
 
    for query in batch:
        if decision.score_skills:
            skill, conditioned_query = select_skill(query, library.cache, policy.log_prob)
        else:
            skill, conditioned_query = None, query
 
        traces = policy.generate(conditioned_query, n=8, max_new_tokens=4096)
        task_correct = [reward_model.verify(query, trace) for trace in traces]
        rewards = [
            (1 if ok else 0) + (1 if decision.use_hierarchical_reward and skill and ok else 0)
            for ok in task_correct
        ]
        advantages = group_relative_advantage(torch.tensor(rewards, dtype=torch.float32))
 
        positive_traces = [t for t, adv in zip(traces, advantages) if adv > 0]
        new_doc = conclude_skill(query, positive_traces, generate_skill) if decision.conclude_skills else None
        new_utility = classify_marginal_skill_reward(task_correct, verification_outcome=bool(new_doc))
        maintain_library(library, skill.name if skill else None, max(rewards), new_doc, new_utility)
 
        all_rollouts.extend(traces)
        all_rewards.extend(rewards)
 
    loss = grpo_clipped_loss(policy, all_rollouts, all_rewards, clip_ratio=0.2)
    loss.backward()
    optimizer.step()
    return loss.item(), library.stats()

3.6 Code-to-paper mapping

Code reference: main @ 2d6f65dd (2026-05-19) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
ARISE step composer / shared Manager-Worker hooks	`verl/trainer/ppo/arise_trainer.py`	`AriseConfig`, `AriseStep.begin_step`, `select_skill`, `compose_rewards`, `conclude_and_maintain`
Policy-driven skill scoring and injection	`verl/workers/arise/skill_manager.py`	`SkillManager.score_with_callable`, `select`, `score_and_select`, `inject`
Cache + reservoir library kernel	`verl/workers/arise/skill_library.py`	`SkillLibrary.seed`, `update`, `add`, `evict`, `load`, `delete`, `step`
Structured skill document parsing/validation	`verl/workers/arise/skill_document.py`	`SkillDocument`, `validate_and_parse`, `trace_abstract_fallback`, `MAX_DOCUMENT_CHARS`
Skill generation rollout $O_{G + 1}$	`verl/workers/arise/skill_conclusion.py`	`SkillConcluder.build_prompt`, `conclude`
Hierarchical reward and marginal skill quality	`verl/workers/arise/reward.py`	`AriseReward.trajectory_reward`, `classify_rs`, `marginal_skill_reward`
Two-phase warm-up / skill-augmented schedule	`verl/workers/arise/phase_scheduler.py`	`PhaseScheduler.decide`, `PhaseDecision`
Launch/config for Qwen3-4B and Phi-4-mini	`recipe/arise/run_arise_qwen3_4b.sh`, `recipe/arise/config/*.yaml`	`python -m verl.trainer.main_ppo --recipe arise`, config overrides

4. Experimental Setup (实验设置)

4.1 数据集与 benchmarks

训练集是 DeepScaleR，约 40K problem-answer pairs，来源包括 AMC、AIME、MATH、OlympiadBench。评估分成两组：in-distribution competition benchmarks 包含 AMC 2023、AIME 2024、AIME 2025，它们与训练集问题类型相近但无时间重叠；out-of-distribution benchmark 是 Omni-MATH，共 4,428 个 Olympiad-level problems，覆盖 Algebra、Number Theory、Combinatorics、Geometry 四个 domain。

4.2 Baselines 与指标

主实验比较两类 baseline：GRPO Family（GRPO、Dr.GRPO、DAPO、GSPO）和 Memory/Skill-Augmented methods（EvolveR + GRPO、SimpleMem + GRPO；论文文字也讨论 SkillRL-style skill augmentation，但主表展示 EvolveR/SimpleMem）。所有方法都使用 GRPO group size $G = 8$ ，指标是 average Pass@1 accuracy (%)，每项报告 32 independent runs 的平均。

4.3 模型、硬件与训练配置

使用两个 instruction-tuned base models：Qwen3-4B-Instruct-2507 和 Phi-4-mini-instruct-3.8B。论文 Appendix A.1 报告训练 2,000 optimization steps，8×A100-80GB GPUs，per-device batch size 4，gradient accumulation 2，有效 batch 64 queries/update；AdamW，learning rate $1 \times 1 0^{- 6}$ ，weight decay 0.01，cosine schedule，50 warm-up steps；solution rollout 的 max generation length 是 4,096 tokens；skill conclusion prompt 使用 temperature 0.7、top-p 0.95、max new tokens 192；clip parameter $ϵ_{c} = 0.2$ 。

训练配置来自 released code 的实际 launch/config 文件，而不是 verl/trainer/config/ppo_trainer.yaml 默认值：recipe/arise/run_arise_qwen3_4b.sh 和 run_arise_phi4_mini.sh 设置 8 GPUs 并调用 python -m verl.trainer.main_ppo --config recipe/arise/config/<model>.yaml --recipe arise；recipe/arise/config/arise_qwen3_4b.yaml / arise_phi4_mini.yaml 明确覆盖 total_steps: 2000、per_device_train_batch_size: 4、gradient_accumulation_steps: 2、effective_batch_size: 64、group_size: 8、learning_rate: 1.0e-6、warmup_steps: 50、max_new_tokens: 4096、clip_ratio: 0.2、dynamic_sampling: true，并把 ARISE-specific 参数设为 temperature=1.0、exploration_eps=0.10、confidence_threshold=0.35、cache_capacity=10、reservoir_capacity=100、ema_beta=0.9、max_summary_traces=2、summary_trace_clip_chars=400、summary_max_chars=350、warmup_steps=500、skill_bonus=1、rs_values=[-1.0,0.0,0.5,1.0]。

5. Experimental Results (实验结果)

5.1 主结果：ARISE 在两个 base model 上均优于 GRPO-family 与 memory baselines

Base model	Method	AMC23	AIME24	AIME25	Omni Algebra	Omni Num.Thy	Omni Combin.	Omni Geometry	Omni Avg.
Qwen3-4B	GRPO	72.9	54.1	46.5	33.5	24.3	15.1	22.8	23.9
Qwen3-4B	DAPO	74.2	55.3	47.6	35.2	25.7	16.3	23.9	25.3
Qwen3-4B	GSPO	73.8	54.9	48.5	34.8	25.4	16.1	25.8	25.5
Qwen3-4B	EvolveR + GRPO	73.6	54.8	46.3	34.5	25.1	15.4	23.5	24.6
Qwen3-4B	SimpleMem + GRPO	73.1	54.5	46.9	33.9	24.6	16.5	23.1	24.5
Qwen3-4B	ARISE + GRPO	75.4	56.4	48.3	37.0	27.2	17.6	25.5	26.8
Phi-4-mini	GRPO	42.7	10.3	4.7	13.2	9.5	6.0	8.8	9.4
Phi-4-mini	DAPO	44.1	11.5	6.1	14.6	10.7	7.0	9.5	10.5
Phi-4-mini	GSPO	43.6	11.8	5.0	14.2	10.3	6.7	9.8	10.2
Phi-4-mini	EvolveR + GRPO	43.2	10.9	5.0	14.0	10.1	6.2	9.4	9.9
Phi-4-mini	SimpleMem + GRPO	43.0	10.7	4.9	13.6	9.8	6.4	9.0	9.7
Phi-4-mini	ARISE + GRPO	45.3	12.6	5.9	15.9	11.5	7.7	10.6	11.4

论文最强调 Omni-MATH 的 OOD 提升：相对 GRPO，ARISE 在 Qwen3-4B 的 Omni Avg. 从 23.9 提到 26.8（+2.9），在 Phi-4-mini 从 9.4 提到 11.4（+2.0，正文称约 +1.9）。Algebra 的增益最大，说明 skill library 中积累的通用代数模式最容易跨题迁移。

5.2 消融：hierarchical reward 是最大贡献项

Variant (Qwen3-4B, Pass@1 %)	AIME24	AIME25	Omni
ARISE full	56.4	49.1	28.0
Binary reward	54.7	47.1	25.7
Random select.	55.1	47.8	26.3
w/o $O_{G + 1}$	55.0	47.5	26.0
w/o confidence gate	56.0	48.7	27.4

Binary reward 造成最大掉点，并让 skill utilization 从 73% 降到 31%，说明“答对 + 正确使用 skill”这个额外奖励不是装饰项，而是驱动 policy 真正采用 skill 的关键。Random selection 保持较高使用率但会降准确率，说明只把 skill 放进 prompt 不够，必须让 policy 学会相关性选择。移除 $O_{G + 1}$ 会把 library 固定在 seed/早期 skills 附近，对 Omni-MATH 影响最大，因为静态 heuristics 很难覆盖奥赛题多样性。移除 confidence gate 掉点最小但 utilization 推到 91%，表明 gate 主要承担噪声过滤作用。

Figure 3 解读：左侧展示 skill library statistics，右侧展示 policy-library co-evolution。Phase II 激活后，ARISE 的曲线开始与 GRPO 拉开；library size 在后期趋于饱和，但 accuracy 继续上升，说明后期收益更多来自 policy 对现有技能的选择变好，而不是无限增加技能数量。这也解释了为什么 cache/reservoir curation 比“越多 memory 越好”更重要。

5.3 额外分析与局限

补充实验给出 token overhead：GRPO 总 token 3,159；DAPO 3,215（+1.8%）；GSPO 3,183（+0.8%）；EvolveR + GRPO 3,410（+7.9%）；ARISE + GRPO 3,254（+3.0%）。这支持论文的效率论点：ARISE 并不是用很大的 prompt memory 换准确率，而是用 compact skill document 和 cache selection 控制上下文成本。

作者明确的局限是：当前实验只覆盖 mathematical reasoning。将 ARISE 扩展到 multi-tool agent tasks 和 code generation 是未来方向；在这些任务里，skill 可能不再是自然语言 heuristic，而是可执行 procedure 或 tool-use macro，这会让 skill validation、library transition 和 reward attribution 都更复杂。另一个实践 caveat 是 released code 中对 skill document 长度采用 350 chars，而论文表中写 220 chars；复现时应记录这一差异，否则可能无法通过 seed skills / published example 的 validation。

Paper Notes

探索

ARISE: Agent Reasoning with Intrinsic Skill Evolution in Hierarchical Reinforcement Learning

ARISE: Agent Reasoning with Intrinsic Skill Evolution in Hierarchical Reinforcement Learning

1. Motivation (研究动机)

2. Idea (核心思想)

3. Method (方法)

3.1 总体框架：Evolving-Skill MDP + Manager/Worker 共享策略

3.2 Policy-driven skill selection

3.3 Skill generation rollout $O_{G + 1}$ 与结构化 skill document

3.4 两层 skill library 与维护操作

3.5 Hierarchical reward 与两阶段训练

3.6 Code-to-paper mapping

4. Experimental Setup (实验设置)

4.1 数据集与 benchmarks

4.2 Baselines 与指标

4.3 模型、硬件与训练配置

5. Experimental Results (实验结果)

5.1 主结果：ARISE 在两个 base model 上均优于 GRPO-family 与 memory baselines

5.2 消融：hierarchical reward 是最大贡献项

5.3 额外分析与局限

目录

Paper Notes

探索

ARISE: Agent Reasoning with Intrinsic Skill Evolution in Hierarchical Reinforcement Learning

ARISE: Agent Reasoning with Intrinsic Skill Evolution in Hierarchical Reinforcement Learning

1. Motivation (研究动机)

2. Idea (核心思想)

3. Method (方法)

3.1 总体框架：Evolving-Skill MDP + Manager/Worker 共享策略

3.2 Policy-driven skill selection

3.3 Skill generation rollout OG+1​ 与结构化 skill document

3.4 两层 skill library 与维护操作

3.5 Hierarchical reward 与两阶段训练

3.6 Code-to-paper mapping

4. Experimental Setup (实验设置)

4.1 数据集与 benchmarks

4.2 Baselines 与指标

4.3 模型、硬件与训练配置

5. Experimental Results (实验结果)

5.1 主结果：ARISE 在两个 base model 上均优于 GRPO-family 与 memory baselines

5.2 消融：hierarchical reward 是最大贡献项

5.3 额外分析与局限

目录

3.3 Skill generation rollout $O_{G + 1}$ 与结构化 skill document