Self-Evolving Agents 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. 核心问题：让 agent 在长程任务里持续提升能力，而不靠人类反复标注。形式化为 $\pi_t \to \pi_{t+1}$ 的更新算子 $\mathcal{T}$ 的收敛性 / 稳定性 / 渐进有效性。
2. 三大范式：① Experience-Driven（人造任务 + reward，如 AgentTuning、Voyager）；② Adversarial Self-Play（Challenger-Solver，如 Absolute Zero、Ctx2Skill）；③ Meta-Learning / Reward-Free（无任务无奖励探索 + outcome-based reward，如 Native Evolution）。
3. 能力载体：自然语言 skill / world knowledge K 写成 markdown——这是 2024-2026 年最重要的范式转移，绕开参数更新，所有内容都是 inference-time system_prompt += K。
4. Ctx2Skill 5-角色 self-play（arXiv 2604.27660）：Challenger / Reasoner / Judge / Proposer / Generator，冻结 LM 但 skill set 在进化。Cross-Time Replay 选 $\arg\max_i \rho^h_i \cdot \rho^e_i$ 防 adversarial collapse。
5. Native Evolution 两阶段（arXiv 2604.18131）：Evolution phase 无任务无 reward 探索 → 蒸馏 markdown K；Execution phase 用 K 当 system prompt。训练信号 $R_\text{evolve}(\mathcal{K}) = \text{Success}(\mathcal{T}_E\mid\mathcal{K}) - \text{Success}(\mathcal{T}_E\mid\varnothing)$。
6. A²RD 三件套（arXiv 2605.06924）：MVMem（textual states + frames + videos + dependency DAG）+ Adaptive Segment Gen + HITS（frame-level + video-level 自检）。直接迁移到任意长程 agent 当作 memory + audit 模板。
7. 理论上界：[arXiv:2601.05280] 在外源 grounding 信号缺失时 closed-loop density matching 退化（不是所有 reward-free 训练必崩，是该 setting 下的特定结论）；[arXiv:2507.00075] 把 solver-verifier gap 建模 + 经验拟合成 capability dynamics。
8. 常见故障：adversarial collapse（Challenger 极端化）、memory drift（K 内部矛盾累积）、reward hacking（self-rewarding 漂移）、bias amplification（agent 在自己输出上重训）、capability ceiling（外源 grounding 缺失时 self-improvement 退化）。

§1 Self-Evolving Agent 直觉

"Self-evolving" 不是 magic。一个 LLM agent 由四件东西组成：

• policy $\pi$：参数化或纯 in-context 的决策函数
• memory / knowledge $\mathcal{K}$：外部化、通常是 markdown 形式的长期状态
• skills $\mathcal{S}$：可复用的过程性知识，每个 skill 是一个 markdown 文档
• environment $E$：可交互的世界（web / code / paper / sandbox / OS）

"Self-evolution" 就是定义一个更新算子 $\mathcal{T}$：

$$\big(\pi_t, \mathcal{K}_t, \mathcal{S}_t\big) \xrightarrow{\mathcal{T}(E, \text{trajectories})} \big(\pi_{t+1}, \mathcal{K}_{t+1}, \mathcal{S}_{t+1}\big)$$

按照 $\mathcal{T}$ 更新的对象，2024-2026 大致可以分四个"层"：

面试常错的两个直觉：

• ❌ "self-evolving = 自动训出新模型权重"——错，绝大多数 work 不更新参数（Voyager、Ctx2Skill、Generative Agents、A²RD 全是 training-free / inference-time）。
• ❌ "self-evolving = agent 想干什么就干什么"——错，2026 主流是严格 grounding 的 self-improvement：要么 code executor（Absolute Zero），要么 math checker（STaR），要么 rubric judge（Ctx2Skill），要么 outcome utility（Native Evolution）。

§2 三种 Self-Evolution 范式的形式化

Native Evolution 论文 [arXiv:2604.18131] 给出了一个非常清晰的分类——我们补充上 mathematical formulation。

2.1　Experience-Driven Evolution

Setting：人提供任务集 $\mathcal{T}$、reward 函数 $R: \mathcal{O} \times \mathcal{A} \to \mathbb{R}$ 和 workflow。Agent 跑 trajectory $\tau$、按 $R(\tau)$ 加权更新。

Update operator：

$$\theta_{t+1} = \theta_t + \eta \,\mathbb{E}_{\tau \sim \pi_{\theta_t}}\!\left[\nabla_\theta \log \pi_\theta(\tau)\, R(\tau)\right]$$

这就是标准 policy gradient——AgentTuning、ToolLLM、Voyager 早期变种属于此类。

优点：监督密度高，收敛快。缺点：人力成本巨大（每个新环境都要重新设计 reward）。

2.2　Adversarial Self-Play Evolution

Setting：两 agent（Challenger + Solver）共同 evolve，无外部任务来源——任务由 Challenger 产生、Solver 解、verifier 给反馈。

Update operator（以 Absolute Zero / R-Zero 形式化）：

$$\theta^{\text{ch}}_{t+1}, \theta^{\text{sol}}_{t+1} = \arg\min_{\theta^{\text{ch}}, \theta^{\text{sol}}} \;\mathbb{E}_{t\sim \pi^\text{ch}_t}\big[\ell^\text{ch}(t)\big] + \lambda\, \mathbb{E}_{(t,a)\sim \pi^\text{ch}_t,\pi^\text{sol}_t}\big[\ell^\text{sol}(t,a)\big]$$

具体的"learnability reward"（Absolute Zero, arXiv 2505.03335）：

$$R^\text{learn}(t) = \pi^\text{sol}_t(\text{correct}\mid t)\cdot \big(1 - \pi^\text{sol}_t(\text{correct}\mid t)\big)$$

最大化时偏好 50% 难度——既不太简单也不太难。这是 curriculum-as-reward 的核心。

优点：无需人造任务集；缺点：仍需 verifier（code executor / math checker），且容易 adversarial collapse（Challenger 出极端任务、Solver 学到 trivial defense）。

2.3　Meta-Learning / Reward-Free Evolution

Setting（Native Evolution）：训练阶段给 outcome-based reward（不是 step-level）；推理阶段无任务、无 reward——agent 自主探索 → 蒸馏 markdown world knowledge $\mathcal{K}$ → 下游任务里用 $\mathcal{K}$ 作 system prompt。

Reward 设计（Native Evolution 核心公式）：

$$\boxed{\;R_\text{evolve}(\mathcal{K}) \;=\; \text{Success}(\mathcal{T}_E \mid \mathcal{K}) \;-\; \text{Success}(\mathcal{T}_E \mid \varnothing)\;}$$

其中 $\mathcal{T}_E$ 是环境 $E$ 的 downstream task 集合（训练时观察得到）。reward 衡量的是 K 的下游 utility gain，不需要 step-level 监督。

优点：完全 task-free / reward-free at inference；缺点：训练成本高（rejection sampling RFT × 2 iteration），且 $\mathcal{T}_E$ 在训练时仍需 labeled data。

2.4　三范式对比（必背）

§3 Skill / Knowledge 的 Markdown 化（最重要的工程转移）

2024 年最重要的一个范式转移是：长期记忆和能力扩展不通过权重更新，而是通过外部 markdown 文档。

3.1　Anthropic Skills + Native Evolution 的趋同

Anthropic 在 2025 年公开了 skills/ 范式（每个 skill 是一个独立 markdown 文件，agent 按需 load 到 system prompt）。Native Evolution 在论文里明确引用了 Anthropic skills作为 K 的实现 reference（论文 §3，footnote 1 指向 github.com/anthropics/skills/tree/main/skills）。

→ 趋同结论：system prompt 是新的 model weights，markdown 文档是新的 fine-tuning data。

3.2　Skill / K 文件的典型 schema

# skill_name
## Trigger / When-to-use
<什么 task 该用这个 skill>

## Steps
1. ...
2. ...

## Resources / References
- file paths / URLs

## Failure modes
- 已知陷阱 + 修复方式

Native Evolution 的 K 还会显式存：

• Visual arcs（实体/环境的视觉演化）
• Spatial relations（subject-relation-object triplets）
• Camera states / Site map（环境拓扑）
• Token budget allocation（每个子页面分多少 token）

3.3　为什么 markdown 而不是 vector embedding？

• 可解释：人类可以审计、修订、merge
• 可组合：skill A + skill B 直接 prepend
• 可路由：可以 LLM 自己读 trigger 段决定 load 哪个
• 可演化：自然语言 diff 比 vector diff 更稳定

代价：检索精度不如 vector RAG；解决方式是 hybrid（vector 做 candidate selection → markdown 做精读）。

§4 Voyager / Reflexion / STaR：奠基三件套

进入 2024-2026 前沿之前，必须先把三个奠基 work 嚼透——面试官十有八九会问 baseline。

4.1　Voyager（Wang 2023 NeurIPS, NVIDIA + Caltech）

第一个真正意义上的"自动 curriculum + skill library"端到端 agent：在 Minecraft 里跑 GPT-4，让它自己出任务、写 JS code（每段 code 是一个 skill）、自检、并把成功的 skill 存进 library。

核心三件套：

• Automatic Curriculum：根据当前 inventory 状态让 GPT-4 提出下一个 task
• Skill Library：每个新 skill 是 JS function，embedding 索引、按 description 检索
• Iterative Prompting + Self-Verification：execute → env feedback → critic agent → revise，直到通过

4.2　Reflexion（Shinn 2023 NeurIPS, Northeastern）

把"verbal RL"概念固化：每次失败后，agent 用自然语言对自己 trajectory 写一段反思（reflection），存进 episodic memory，下次 prompt 时 prepend。

形式化（伪 Bellman）：

$$M_{t+1} = M_t \cup \big\{\text{reflect}(\tau_t, r_t)\big\}$$

其中 $\text{reflect}$ 是 LLM 自己实现的 "what went wrong + how to fix" 文本生成。

为什么有效（理论上）：reflection 把稀疏 reward 信号压缩成结构化文本，绕开梯度更新；等价于在 in-context 域做一种非参数化 policy improvement。但缺乏收敛 guarantee。

4.3　STaR (Self-Taught Reasoner, Zelikman 2022 NeurIPS, Stanford)

让 LM 自己生成 rationale → 答错就用真答案 rationalize → 把对的 (q, rationale, a) 拿来 SFT。是 self-improvement on reasoning 的真正起点。

伪算法：

for iter in 1..N:
    for each (q, a_gt) in D:
        r, a_pred = LM(q)
        if a_pred == a_gt:
            collect (q, r, a_gt)
        else:
            r' = LM(q, hint=a_gt)        # rationalize
            if r' produces a_gt:
                collect (q, r', a_gt)
    SFT(LM, collected)

STaR 的关键缺陷（也是 [arXiv:2601.05280] 攻击 self-improvement 的核心论据）：rationalization 是 reverse-engineering 答案，不一定反映真实推理过程，导致 distribution drift。

§5 Ctx2Skill：5-角色 Self-Play Loop（重点 1）

这一节几乎逐字对应 arXiv 2604.27660 的 §3，因为面试官可能从论文里逐字问。

5.1　Problem formulation

给一个 context $C$（可能是 100k+ tokens 的 manual / paper / repo / dataset），一个 task 集 $\mathcal{T} = \{t_j\}$，每个 task 有 binary rubric 集 $\mathcal{R}_j = \{r_{j,k}\}$。Solving indicator：

$$y_j(\pi; C) = \prod_k \mathbb{I}\big[r_{j,k}(a_j) = \text{pass}\big], \quad a_j \sim \pi(\,\cdot\mid C, t_j)$$

目标：构造 markdown skill set $\mathcal{S}^R$ 使得：

$$a_j \sim \pi(\,\cdot\mid \mathcal{S}^R, C, t_j) \quad \text{maximizes}\ \mathbb{E}_j y_j$$

且不更新 $\pi$ 的参数——只更新 $\mathcal{S}^R$。

5.2　5 个 frozen LM 角色

注意两路独立 evolve：

• Reasoner side：失败案例 → Reasoner Proposer 诊断"缺什么 contextual knowledge" → Reasoner Generator 写新 $\mathcal{S}^R_i$
• Challenger side：被太容易解的案例 → Challenger Proposer 诊断"为什么 challenger 出题太弱" → Challenger Generator 强化 $\mathcal{S}^C_i$

→ 这两路永远不交换 skill set——保持严格对抗。

5.3　Cross-Time Replay 机制（核心防 collapse）

iteration 越多，Challenger 越极端，Reasoner 越 over-specialize 到极端任务。直接返回 $\mathcal{S}^R_N$ 会糟。

Replay 流程：

1. 训练过程中维护两个 probe set：

   • Hard set $\mathcal{Q}^h$：每 iteration 选 rubric pass rate 最低的失败 task
   • Easy set $\mathcal{Q}^e$：每 iteration 选 rubric pass 最少的 solved task（"刚好解出来"的）
2. 训练结束后，对每个候选 $\mathcal{S}^R_i$（$i=1\ldots N$）跑 Reasoner $\pi^R$ 在两个 probe set 上：

$$\rho^h(i) = \frac{\sum_{q\in \mathcal{Q}^h} y_q(\pi^R; C, \mathcal{S}^R_i) + 1}{|\mathcal{Q}^h| + 1}, \quad \rho^e(i) = \frac{\sum_{q\in \mathcal{Q}^e} y_q(\pi^R; C, \mathcal{S}^R_i) + 1}{|\mathcal{Q}^e| + 1}$$

（Laplace smoothing 防 probe set 为空）

1. 选：

$$\boxed{\;\mathcal{S}^R_\star = \mathcal{S}^R_{i^\star}, \quad i^\star = \arg\max_i \big(\rho^h(i) \cdot \rho^e(i)\big)\;}$$

为什么乘积而不是加和：乘积惩罚 catastrophic forgetting（如果某版本 $\rho^e \to 0$，整个分数 → 0），强制选两边都不太差的版本。Ctx2Skill ablation 显示用加和会让最终精度下降 ~1.5%。

5.4　Ctx2Skill 5-角色 + Replay 代码骨架

def ctx2skill_loop(context: str, llm, num_iters: int = 5, M: int = 5):
    """
    Ctx2Skill: 5 frozen LM 角色 + Cross-Time Replay.
    返回 cross-time-replay 选出的最优 Reasoner skill set.
    所有 LM 调用都是同一个 frozen backbone, 只有 skill set 在变.
    """
    S_R = ""                    # Reasoner skill markdown (初始空)
    S_C = ""                    # Challenger skill markdown
    candidates = []             # 历史 S_R 候选 (cross-time)
    Q_hard, Q_easy = [], []     # 两个 probe set

    for i in range(1, num_iters + 1):
        # ── (1) Challenger 出 batch ──
        batch = llm(role="challenger", prompt=challenger_prompt(context, S_C), n=M)
        # batch = [(t_m, rubrics_m), ...]

        failed, solved = [], []
        for t_m, rubrics_m in batch:
            # ── (2) Reasoner 解题 ──
            a_m = llm(role="reasoner", prompt=reasoner_prompt(context, S_R, t_m))
            # ── (3) Judge per-rubric ──
            per_rubric = [llm(role="judge", prompt=judge_prompt(a_m, r))
                          for r in rubrics_m]
            y_m = all(per_rubric)
            pass_rate = sum(per_rubric) / len(per_rubric)
            (failed if not y_m else solved).append(
                (t_m, rubrics_m, a_m, pass_rate)
            )

        # ── 维护 probe sets (Laplace 平滑前预备) ──
        if failed:
            hardest = min(failed, key=lambda x: x[3])
            Q_hard.append((hardest[0], hardest[1]))
        if solved:
            # solved 中 pass_rate 最低的 (即 "勉强解出" — 所有 rubric pass 但很多 prompt 都险险通过)
            # 注意：solved 的 entries 都满足 all(per_rubric)，所以 pass_rate=1.0；
            # 实际生产里 "勉强解出" 应该用 per-rubric soft 分数 (例如 LLM-judge 给 [0,1] 而非 0/1)，
            # 这里教学版以接近解题边界的 task 为代表（即 batch 中 reasoner 用了最多 retry 的）
            easiest_among_solved = solved[-1]  # 教学简化：取最后一个 solved task
            Q_easy.append((easiest_among_solved[0], easiest_among_solved[1]))

        # ── (4) 双路 Proposer 诊断 ──
        diag_R = llm(role="reasoner_proposer",
                     prompt=proposer_prompt(failed, S_R))
        diag_C = llm(role="challenger_proposer",
                     prompt=proposer_prompt(solved, S_C))

        # ── (5) 双路 Generator 写 skill ──
        S_R = llm(role="reasoner_generator",
                  prompt=generator_prompt(diag_R, S_R))
        S_C = llm(role="challenger_generator",
                  prompt=generator_prompt(diag_C, S_C))

        candidates.append(S_R)

    # ── Cross-Time Replay ──
    best_idx, best_score = 0, -1.0
    for i, cand in enumerate(candidates):
        rho_h = laplace_smoothed_rate(Q_hard, cand, llm, context)
        rho_e = laplace_smoothed_rate(Q_easy, cand, llm, context)
        score = rho_h * rho_e
        if score > best_score:
            best_score, best_idx = score, i

    return candidates[best_idx]


def laplace_smoothed_rate(probe, skill_set, llm, context):
    """ Laplace-smoothed pass rate: (sum_q y_q + 1) / (|probe| + 1).
    
    Args:
        probe:     list[(task, rubrics)]
        skill_set: candidate S_R^i 要评估的 markdown skill
        llm:       frozen LM
        context:   原始 context（与 ctx2skill_loop 入参同源；必须显式传入，
                   防止 closure 误用）
    """
    num_pass = 0
    for t_q, rubrics_q in probe:
        a = llm(role="reasoner",
                prompt=reasoner_prompt(context, skill_set, t_q))
        if all(llm(role="judge", prompt=judge_prompt(a, r))
               for r in rubrics_q):
            num_pass += 1
    return (num_pass + 1) / (len(probe) + 1)

5.5　Ctx2Skill 实验结果（必记）

CL-bench 上，没有任何参数更新：

→ 用 GPT-4.1 + Ctx2Skill (16.5%) 超过 无 skill 的 Gemini 3 Pro (15.8%)——印证"high-quality skill 可弥补 model 差距"。

5.6　Ctx2Skill ablation（面试加分）

Challenger evolving 的下降最大——证明"持续 adversarial pressure"是 Reasoner 进步的真正动力。

§6 Native Evolution：Reward-Free Meta-Learning（重点 2）

全部对应 arXiv 2604.18131。Tencent + HKUST(GZ)，2026-04-20。

6.1　核心 architecture：双阶段解耦

  ┌─────────────────────────────────┐       ┌──────────────────────────────┐
  │      Native Evolution Phase     │       │   Knowledge-Enhanced Execution│
  │      (推理时 task-free + rf)     │       │   (推理时拿 K 当 system prompt)│
  │                                 │       │                              │
  │   π_θ(K | E)                    │  ──→  │   π_task(a_t | o_t, K, Task) │
  │   "exploring + summarizing"     │       │                              │
  │                                 │       │                              │
  └──────────────┬──────────────────┘       └──────────────────────────────┘
                 │
                 │ (训练时用 outcome-based reward 监督 evolve)
                 ▼
  R_evolve(K) = Success(T_E | K) − Success(T_E | ∅)

关键 design choice：evolution 和 execution 用同一个 LLM（不像 RLHF 区分 SFT-policy / RM）；只是给不同 system prompt + 训练阶段经过 SFT + RFT 让它学会 "evolution mode"。

6.2　Outcome-Based Reward 设计

$$\boxed{\;R_\text{evolve}(\mathcal{K}) = \underbrace{\text{Success}(\mathcal{T}_E\mid \mathcal{K})}_{\text{有 K 时下游成功率}} - \underbrace{\text{Success}(\mathcal{T}_E\mid \varnothing)}_{\text{无 K baseline}}\;}$$

其中 $\text{Success}(\mathcal{T}_E\mid \mathcal{K}) = \frac{1}{M}\sum_{j=1}^M \mathbb{I}\big[f(Q_j, \mathcal{K}) = A_j\big]$。

为什么 outcome-based 而不是 step-level？

Native Evolution 选 outcome-based 还有一个特殊原因：$\mathcal{K}$ 是整段 markdown（374.8 步 × 3322.4 tokens/step），step-level reward 在如此长 horizon 上几乎无意义。

6.3　两阶段训练：SFT → RFT

Stage 1 (SFT)：

• 用 teacher model $\pi_T$ (Gemini-2.5-Pro) 生成 3 个候选 $\{\mathcal{K}_i\}_{i=1}^3$
• 算 $R_\text{evolve}(\mathcal{K}_i)$，选最优 $\mathcal{K}^\star$
• 用 $T^\star = \{Q, o_1^\star, a_1^\star, \ldots, o_k^\star, a_k^\star\}$ trajectory SFT base model $\pi_{\theta_0}$
• 训练数据：600 deep search questions × 20 websites

Stage 2 (RFT, Rejection Sampling Fine-Tuning)：

• 用 $\pi_{\theta_1}$ 自己生成 $C$ 个候选 K
• 按 $R_\text{evolve}$ 选最高分
• 用最高分 trajectory 继续 fine-tune
• 跑 2 iteration

6.4　Native Evolution 训练 + 推理代码骨架

def native_evolution_pipeline(base_model, teacher_model, env_pool,
                              downstream_tasks_per_env, num_iter=2,
                              C_sft: int = 3, C_rft: int = 8):
    """
    Native Evolution: SFT + RFT (2 iter) → 学会 reward-free self-evolution.
    
    Args:
        C_sft: SFT 阶段 teacher 生成 K 候选数（论文 3）
        C_rft: RFT 阶段 pi 自生成候选数（论文 8）
    """
    # ── Stage 1: SFT ──
    sft_data = []
    for E in env_pool:
        T_E = downstream_tasks_per_env[E]            # labeled downstream
        # baseline: 不给 K
        s0 = success_rate(base_model, T_E, K=None)

        # teacher 生成 C_sft 个候选 K
        candidates = [explore_and_summarize(teacher_model, E)
                      for _ in range(C_sft)]
        # 评 reward = Success(T_E | K) − Success(T_E | ∅)
        rewards = [success_rate(base_model, T_E, K=K) - s0
                   for K in candidates]
        K_star = candidates[argmax(rewards)]
        traj_star = extract_trajectory(teacher_model, E, K_star)
        sft_data.append(traj_star)                   # ~374 steps each

    pi_1 = sft(base_model, sft_data)                 # warm-up

    # ── Stage 2: RFT × num_iter ──
    pi = pi_1
    for it in range(num_iter):
        rft_data = []
        for E in env_pool:
            T_E = downstream_tasks_per_env[E]
            s0 = success_rate(pi, T_E, K=None)
            # pi 自己生成 C_rft 个候选
            candidates = [explore_and_summarize(pi, E) for _ in range(C_rft)]
            rewards = [success_rate(pi, T_E, K=K) - s0
                       for K in candidates]
            best = candidates[argmax(rewards)]
            rft_data.append(extract_trajectory(pi, E, best))
        pi = sft(pi, rft_data)                       # next iter

    return pi   # π_θ*: 学会了 native evolution


def native_evolution_inference(pi_star, new_env, task):
    """
    推理时: 无 task, 无 reward → 探索 → 蒸馏 K → 用 K 解题.
    """
    K = explore_and_summarize(pi_star, new_env)      # task-free!
    answer = pi_star(task, system_prompt=K)          # K-augmented
    return answer

6.5　Native Evolution 实验结果

WebVoyager + WebWalker，14B Qwen3 / 36B Seed-OSS：

最 striking：14B Qwen3 + transferred K from 36B → 35.6% conference accuracy；unassisted Gemini-2.5-Flash 只有 31.3%——证明 high-quality K 可超过纯参数缩放。

6.6　Native Evolution vs Ctx2Skill 对比

→ 它们是互补的：Native Evolution 让 backbone 学会怎么探索；Ctx2Skill 让冻结 backbone怎么把 context 蒸馏成可复用 skill。可以叠加。

§7 A²RD 与 Long-Horizon Memory Architecture（重点 3）

arXiv 2605.06924，Google Cloud AI + NUS，2026-05-07。虽然是 video，但 memory schema 直接迁移到所有 long-horizon agent。

7.1　Retrieve → Synthesize → Refine → Update 闭环

   ┌──────────────────────────────────────────────────────────────┐
   │   for segment i = 1..N:                                       │
   │     1. Retrieve relevant context from MVMem (T_j, F_j, V_j)   │
   │     2. Decide mode: extrapolation vs interpolation            │
   │     3. Synthesize boundary frames F_i^begin, F_i^end          │
   │     4. HITS (frame-level): verify + revise frames             │
   │     5. Synthesize video segment V_i = TI2V(P_i, F_i, F^rel)   │
   │     6. HITS (video-level): verify + revise via MAPO           │
   │     7. Update MVMem with (F_i, V_i, T_i, T_{i+1}^F)           │
   └──────────────────────────────────────────────────────────────┘

7.2　MVMem schema（textual states + frames + videos）

$$\mathcal{M} := \{\mathcal{M}_1, \ldots, \mathcal{M}_N\} \cup \mathcal{R} \cup \mathcal{D}$$

每段 $\mathcal{M}_j = \{T_j, \mathcal{F}_j, V_j\}$：

• Textual States $T_j$：包含 Visual Arcs（entity identity / motion）+ Spatial Relations（subject-relation-object triplets，ground geometric layout）+ Camera trajectories
• Frames $\mathcal{F}_j = \{F_j^\text{begin}, F_j^\text{end}\}$：keyframes
• Videos $V_j$：完整 segment

加上：

• $\mathcal{R}$：global reference frames (background, entity references)
• $\mathcal{D}$：prompt database（失败 prompt 也存）

7.3　Dependency DAG（关键 trick）

reference 之间有依赖：entity 依赖 environment、camera 依赖 entity 位置。A²RD 建一个 DAG：

$$\mathcal{G} := \text{MLLM}_\text{dep}(\mathcal{P}_\mathcal{R})$$

然后 topological sort 决定合成顺序。直接迁移到 ARIS-style agent：研究项目里 claim ← experiment ← code ← idea，typed memory 也是 DAG。

7.4　HITS: Hierarchical Test-Time Self-Improvement

两级：

• Frame-level HITS：对每个 $F^\text{begin}, F^\text{end}$ 用 VLM verify "是否符合 textual state"，不符合 → MAPO (Multi-Aspect Prompt Optimization) 改 prompt → 重生成
• Video-level HITS：对整段 $V_i$ 用 VLM verify "narrative continuity"，不符合 → 改 video prompt → 重生成

→ inner-segment + inter-segment 两个 scale 的自检——比单层 self-improvement 防 drift 更强。

7.5　迁移到通用 long-horizon agent（典型 cheat-sheet）

class TypedMemory:
    """A²RD MVMem 思想 ⇒ 通用 long-horizon agent memory."""
    def __init__(self):
        self.segments = []          # list of {state, artifacts, deps}
        self.global_refs = {}       # 全局实体 (e.g., paper-level claim)
        self.dep_graph = {}         # DAG: which artifact depends on which
        self.failure_db = []        # 失败 trace 数据库

    def retrieve(self, current_segment_ctx, k=3):
        """检索 narratively-relevant 上下文 (前 k 段)."""
        cands = []
        for j, M_j in enumerate(self.segments):
            score = relevance(M_j["state"], current_segment_ctx)
            cands.append((score, j))
        topk = sorted(cands, reverse=True)[:k]
        return [self.segments[j] for _, j in topk]

    def update(self, segment, deps):
        self.segments.append(segment)
        seg_id = len(self.segments) - 1
        self.dep_graph[seg_id] = deps      # parent ids

    def topo_synthesis_order(self, num_segments: int) -> list[int]:
        """A²RD 的 dependency DAG → 决定生成顺序.
        
        Args:
            num_segments: 待生成段总数；自动补充未在 dep_graph 中的节点为 root.
        Returns:
            合法的 topological order (list of segment indices).
        """
        # 自动把所有 0..num_segments-1 都加入 graph (没有依赖的视为 root)
        graph = {i: self.dep_graph.get(i, []) for i in range(num_segments)}
        return topological_sort(graph)


def long_horizon_agent_with_hits(memory, segments_to_generate, llm, verifier):
    """A²RD 风格的 R→S→R→U 闭环.
    
    Note: segments_to_generate 是需要生成的段的 context 描述列表；
    生成 order 由 memory.dep_graph 决定（若空，则默认顺序生成）。
    """
    order = memory.topo_synthesis_order(num_segments=len(segments_to_generate))
    for i in order:
        # Retrieve
        ctx = memory.retrieve(segments_to_generate[i])
        # Synthesize
        artifact = llm.generate(segments_to_generate[i], context=ctx)
        # Frame-level HITS (artifact 内部一致性)
        for _ in range(MAX_REFINES):
            if verifier.frame_check(artifact): break
            artifact = llm.refine(artifact, verifier.feedback)
        # Video-level HITS (artifact 与历史一致性)
        for _ in range(MAX_REFINES):
            if verifier.video_check(artifact, ctx): break
            artifact = llm.refine(artifact, verifier.feedback)
        # Update
        memory.update(artifact, deps=ctx)

§8 Self-Improvement 的理论上界（L3 level）

两篇 2025-2026 必读理论 paper——这是顶级 lab 面试可能问的部分。

8.1　On the Limits of Self-Improving in LLMs（arXiv 2601.05280）

全名: "On the Limits of Self-Improving in LLMs: The Singularity Is Not Near Without Symbolic Model Synthesis"

Setup：把 self-training 建模成概率分布上的 dynamical system：

$$p_{t+1} = \mathcal{T}_\text{closed}(p_t) = \mathbb{E}_{x \sim p_t}\big[\delta_{x'}\big],\quad x' = \pi_t(x)$$

即 $p_{t+1}$ 是当前模型在自己样本上重训得到的分布。

主定理（叙述版）：在 closed-loop density matching（无外源 grounding signal）下，若 $\pi_t$ 没有访问 ground truth，则 $\{p_t\}$ 一般不收敛到 target $p^\star$，且会在 mode collapse / drift 中退化。

核心 mechanism：

$$D_\text{KL}(p^\star \,\|\, p_{t+1}) \;\ge\; D_\text{KL}(p^\star \,\|\, p_t) - \Delta_\text{grounding}$$

其中 $\Delta_\text{grounding}$ 是 grounding 信号带来的 KL 减少。无 grounding ($\Delta = 0$) 时 KL 不降反升。

正面 implication：self-improvement 需要外源 grounding——code executor / math checker / human label / rubric judge——这就是为什么 Absolute Zero 必须挂 code executor，STaR 必须用 ground-truth answer 做 rationalization，Ctx2Skill 必须用 Judge 验 rubric。

8.2　Solver-Verifier Gap（arXiv 2507.00075）

Setup：把 capability 演化建模成两个变量 $\theta^\text{sol}, \theta^\text{ver}$ 的耦合 dynamics：

$$\begin{cases} \dot\theta^\text{sol} = \eta_s\, g_s(\theta^\text{sol}, \theta^\text{ver}) \\ \dot\theta^\text{ver} = \eta_v\, g_v(\theta^\text{sol}, \theta^\text{ver}) \end{cases}$$

经验观察：capability $C(\theta)$ 在 self-improvement 下服从（拟合的）指数律：

$$C(\theta_t) \approx C_\infty - (C_\infty - C_0)\, e^{-\kappa t}$$

且 $\kappa$ 与 solver-verifier gap $\Delta := C^\text{ver} - C^\text{sol}$ 正相关（gap 越大、improvement 越快），但 gap 太大也会 saturate（verifier 给的反馈 solver 学不到）。

对工程的指导：

• 跨模型 reviewer（如 ARIS 用 Codex 5.5 review Claude）天然制造 verifier-solver gap → 加速 self-improvement
• 同模型 self-review 几乎无 gap → 收敛慢甚至无效

8.3　两篇论文的实际含义

→ 二者结合：reward-free at inference + grounded at training 是 Native Evolution 等 work 能 work 的根本原因；ARIS-style 跨模型 audit 是 system-level 加速 self-improvement 的工程选择。

§9 Memory-Driven Self-Evolution

9.1　Generative Agents（Park 2023 UIST, Stanford）

最经典的 long-horizon 仿真：observation stream → memory store → reflection (LLM 自己写 insight) → planning。

记忆三层：

• Observation memory：原始 timestamp + 字面描述
• Reflection memory：由 retrieval-augmented LLM 生成"insight"
• Planning memory：long-term goal

retrieval score：

$$\text{score}(m) = \alpha_\text{recency}\, r(m) + \alpha_\text{importance}\, i(m) + \alpha_\text{relevance}\, s(m, q)$$

其中 $r(m) = \gamma^{\Delta t}$（指数 decay），$i(m) \in [1,10]$（LLM 自评），$s(m,q)$ cosine similarity。

9.2　MemGPT（Packer 2023, Berkeley）

OS-style hierarchical memory：

• Main context（LLM token budget）= "RAM"
• External archival（disk）= "HDD"
• LLM 学会 paging：memgpt_function_call(load, save, summarize)

核心 trick：让 LLM 在自己 context 内观察到 token usage，主动决定换页——这是把 OS 抽象搬到 LLM agent。

9.3　这一层与 Ctx2Skill / Native Evolution 关系

→ memory-driven 这条线 2024-2026 演化方向：从 episodic（GA）→ hierarchical (MemGPT) → typed + DAG (MVMem)。

§10 Skill / K 检索与排序（工程实践）

实际部署时，skill library 几十到几百条，必须按需 load——否则 token 爆炸。

10.1　Hybrid retrieval pipeline

def hybrid_skill_retrieval(task: str, skills: list, k=3):
    """
    Stage A: 粗筛 (vector embedding, fast)
    Stage B: 精排 (LLM scoring on description, accurate)
    Stage C: 按 trigger 段精确匹配 (deterministic)
    """
    # ── Stage A: BM25 + dense embedding hybrid ──
    bm25_scores = bm25_search(task, [s.description for s in skills], topn=20)
    dense_scores = dense_search(task, [s.embedding for s in skills], topn=20)
    candidates = top_k(merge(bm25_scores, dense_scores), n=10)

    # ── Stage B: LLM rerank ──
    reranked = []
    for skill in candidates:
        prompt = f"task={task}\nskill trigger={skill.trigger}\n" \
                 f"Q: relevant? (yes / no / partial)"
        verdict = llm(prompt)
        score = {"yes": 1.0, "partial": 0.5, "no": 0.0}[verdict]
        reranked.append((score, skill))

    # ── Stage C: 关键词强匹配 ──
    keyword_hits = [s for s in skills
                    if any(kw in task.lower() for kw in s.exact_triggers)]

    # 合并去重 → 取 top k
    final = top_k(reranked + [(2.0, s) for s in keyword_hits], k=k)
    return [s for _, s in final]

10.2　Skill 排序公式

加权融合 3 个信号：

$$\text{score}(s, q) = \alpha_\text{sim}\, \cos(\mathbf{e}_s, \mathbf{e}_q) + \alpha_\text{prior}\, \log(1 + n_\text{used}(s)) + \alpha_\text{recent}\, \gamma^{\Delta t}$$

其中 $n_\text{used}$ 是历史调用次数（越常用越可靠），$\gamma^{\Delta t}$ 是 recency decay。

10.3　Skill 的更新（防陈旧）

每个 skill 维护：

• success_count, fail_count
• last_updated
• version

触发更新条件：

• fail_count / total > τ_fail（失败率过高）→ 修订
• last_updated > T_stale（陈旧）→ 重新探索
• environment 变化检测 → 触发 Native-Evolution-style 重新蒸馏

§11 Inference-Time Orchestration（如 ARIS）vs Training-Time Meta-Learning（如 Native Evolution）

顶级 lab 面试 L3 必问：把握 inference-time orchestration 和 training-time meta-learning 的根本数学区别。

11.1　数学 formulation 对比

11.2　各自局限

Inference-time orchestration：

• ❌ 不能内化 skill 进 weights → 每次需 load token
• ❌ Context 长度上限会成瓶颈
• ❌ 难以学习 low-level subtoken pattern
• ✅ 立刻可解释，可审计
• ✅ 不需要 GPU

Training-time meta-learning：

• ❌ 训练昂贵（rejection sampling × 2 iter, 600 task × 20 env）
• ❌ 一旦 train 完，进化能力固化
• ❌ 跨 environment 泛化仍是开问题
• ✅ 一次训练长期受益
• ✅ 行为可内化到 fast inference path

11.3　实际系统的混合形态

主流 production agent 往往是两层都用：

• 底层：fine-tune 过 instruction follow + tool use（一次性训练）
• 上层：inference-time 编排 skill / memory（持续 update）

这也是 ARIS 类型 system 的实际位置——上层 inference-time orchestration，下层依赖 GPT-4.5 / Claude Opus 等已经 trained-to-follow-skill 的 backbone。

§12 失败模式与防御（必背）

12.1　Adversarial Collapse

症状：Challenger 越来越极端，Reasoner 学会的 skill 只对极端 case 有效，对正常 case 退化。

Ctx2Skill 解法：Cross-Time Replay 选 $\arg\max \rho^h \cdot \rho^e$，乘积形式强制保留 easy task 性能。

通用解法：

• 维护历史 probe set（不只看 current iteration）
• 选最 balanced 而非 last-iteration skill
• 用 KL penalty 防 skill set 单步剧变：$\mathcal{L}_\text{KL} = \beta \,D_\text{KL}(\mathcal{S}_i \| \mathcal{S}_{i-1})$（textual KL 可近似为 BLEU/edit distance）

12.2　Memory Drift

症状：long-horizon agent 把矛盾 / 过时信息累积进 K 或 memory，越用越糟。

A²RD 解法：

• HITS 在每个 segment 跟 retrieved context cross-check
• typed memory schema 强制 schema validation
• failure_db 单独存"已知不可信"trace

通用解法：

• 定期跑 self-consistency check：让 LLM 读自己 K 找内部矛盾
• 给每个 entry 加 confidence 衰减
• 触发"K 重蒸馏"机制（Native-Evolution-style）

12.3　Reward Hacking

症状：self-rewarding 训练（Yuan et al. 2024 Self-Rewarding LM）中，model 学到 game 自己的 reward function。

防御：

• 跨模型 reward：让另一个 model family 当 verifier
• outcome-grounded reward：不让 LLM 给自己评分；用 code executor / math checker / labeled downstream task
• reward dropout / regularization：random subset of reward components

12.4　Bias Amplification（Echo Chamber）

症状：STaR-style rationalization 把 model 训练在自己生成的 rationale 上，扩大 mode collapse。

[arXiv:2601.05280] 给出的 KL bound 直接对应这种情况 —— 无外源 grounding，KL 不降反升。

防御：

• 永远保留一部分 ground-truth supervision
• 用真实人类反馈 anchor
• diverse seed prompts 强制多模态

12.5　Sandbox Contamination

症状：agent 自己生成 test case → 自己 train on 这些 case → eval 上看上去很高但实际是 train-test 重叠。

防御：

• 严格 holdout set，agent 完全无 access
• benchmark 由 third-party 维护
• 多 round canonical eval（如 Ctx2Skill 用 CL-bench）

12.6　Capability Ceiling

症状：经过 N 轮 self-improvement 后曲线 saturate，无论多少 compute 都不再涨。

Solver-Verifier Gap [arXiv:2507.00075] 的解释：当 gap $\Delta \to 0$ 时 $\kappa \to 0$，improvement rate → 0。

突破方式：

• 引入更强的 verifier（如换 stronger model 当 judge）
• 增加 task 难度（Ctx2Skill 的 Challenger evolve）
• symbolic 模型综合 ([arXiv:2601.05280] 提出的最后救命稻草)：让 LLM 同时维护一个 symbolic / programmatic model 防 drift

12.7　Hallucination Compounding（独立 reviewer 也可能共幻觉）

症状：跨模型 reviewer 都同意一个错误结论（如 Claude 写 + GPT 审，都漏掉同一个 bug）。

防御（briefing 中 codex round 2 也提过）：

• reviewer 一定要接 raw evidence / executable check（unit test, claim audit against raw experiment output）
• 不能只靠 LLM 的 textual judgment

§13 25 高频面试题（L1 + L2 + L3）

L1 必会 (Q1-Q10)

L2 进阶 (Q11-Q20)

L3 顶级 lab (Q21-Q25)

§A 附录：完整 from-scratch 代码骨架

A.1　Skill library 完整实现

import json, time, math
from dataclasses import dataclass, field, asdict
from typing import Callable, Optional


@dataclass
class Skill:
    """Markdown skill with metadata for retrieval + lifecycle."""
    name: str
    trigger: str            # when-to-use 段
    body: str               # 真正 system-prompt 注入的 markdown
    exact_triggers: list = field(default_factory=list)
    success_count: int = 0
    fail_count: int = 0
    last_updated: float = field(default_factory=time.time)
    version: int = 1
    embedding: list = field(default_factory=list)


class SkillLibrary:
    """Skill 持久化、检索、生命周期管理."""

    def __init__(self):
        self.skills: dict[str, Skill] = {}
        self.callbacks_on_update: list[Callable] = []

    def add(self, s: Skill) -> None:
        self.skills[s.name] = s

    def retrieve(self, query: str, embed_fn, k: int = 3) -> list[Skill]:
        """Hybrid retrieval: keyword + dense + recency."""
        q_emb = embed_fn(query)
        scored = []
        now = time.time()
        for name, s in self.skills.items():
            sim = self._cos(s.embedding, q_emb) if s.embedding else 0.0
            prior = math.log(1 + s.success_count)
            recency = math.pow(0.999, max(0, (now - s.last_updated) / 3600))
            kw_hit = 1.0 if any(t.lower() in query.lower()
                                for t in s.exact_triggers) else 0.0
            score = 0.5 * sim + 0.2 * prior + 0.2 * recency + 0.1 * kw_hit
            scored.append((score, s))
        scored.sort(reverse=True, key=lambda x: x[0])
        return [s for _, s in scored[:k]]

    @staticmethod
    def _cos(a: list, b: list) -> float:
        if not a or not b: return 0.0
        dot = sum(x * y for x, y in zip(a, b))
        na = math.sqrt(sum(x * x for x in a))
        nb = math.sqrt(sum(y * y for y in b))
        return dot / (na * nb + 1e-9) if na > 0 and nb > 0 else 0.0

    def update_outcome(self, skill_name: str, success: bool) -> None:
        s = self.skills[skill_name]
        if success: s.success_count += 1
        else:       s.fail_count    += 1

    def should_revise(self, skill_name: str,
                      tau_fail: float = 0.5,
                      t_stale: float = 7 * 24 * 3600) -> bool:
        s = self.skills[skill_name]
        total = s.success_count + s.fail_count
        if total > 0 and s.fail_count / total > tau_fail:
            return True
        if time.time() - s.last_updated > t_stale:
            return True
        return False

    def revise(self, skill_name: str, new_body: str) -> None:
        s = self.skills[skill_name]
        s.body = new_body
        s.last_updated = time.time()
        s.version += 1
        s.success_count = 0
        s.fail_count = 0
        for cb in self.callbacks_on_update:
            cb(s)

    def serialize(self) -> str:
        return json.dumps({n: asdict(s) for n, s in self.skills.items()})

    def assemble_prompt(self, skills: list[Skill]) -> str:
        return "\n\n".join([f"# {s.name}\n{s.body}" for s in skills])

A.2　Reflexion memory 完整实现

@dataclass
class Reflection:
    trajectory_summary: str
    failure_root_cause: str
    fix_strategy: str
    timestamp: float


class ReflexionMemory:
    """verbal-RL style memory."""

    def __init__(self, max_entries: int = 50):
        self.entries: list[Reflection] = []
        self.max_entries = max_entries

    def add(self, traj: str, llm: Callable) -> None:
        """让 LLM 自己生成 reflection."""
        prompt = (
            f"Trajectory: {traj}\n\n"
            f"Task FAILED. Write a short reflection in JSON with keys: "
            f"trajectory_summary, failure_root_cause, fix_strategy."
        )
        raw = llm(prompt)
        try:
            obj = json.loads(raw)
        except Exception:
            obj = {"trajectory_summary": traj[:400],
                   "failure_root_cause": "parse_failed",
                   "fix_strategy": raw[:400]}
        self.entries.append(Reflection(
            trajectory_summary=obj["trajectory_summary"],
            failure_root_cause=obj["failure_root_cause"],
            fix_strategy=obj["fix_strategy"],
            timestamp=time.time(),
        ))
        # 保留最近 max_entries 条
        if len(self.entries) > self.max_entries:
            self.entries = self.entries[-self.max_entries:]

    def render(self) -> str:
        """渲染成 prefix prompt."""
        return "\n".join([
            f"[Reflection {i}] cause: {r.failure_root_cause}\n"
            f"           fix: {r.fix_strategy}"
            for i, r in enumerate(self.entries[-5:])
        ])

A.3　Sanity check 输出（伪示）

[a] SkillLibrary.add + retrieve            ✓ topk = ['voyager_craft', 'minecraft_kill']
[b] update_outcome 累积 success_count       ✓ s.success_count = 3
[c] should_revise 触发条件 (fail rate)       ✓ tau_fail=0.5 → True
[d] revise 后 version += 1                  ✓ s.version: 1 → 2
[e] Reflexion.add 解析 LLM JSON            ✓ len(entries) = 1
[f] Reflexion render 取最近 5 条            ✓ render len = 154 chars
[g] hybrid retrieval 中 keyword_hit 权重    ✓ keyword > dense when exact match
[h] cross-time replay arg max(rho_h * rho_e)✓ best_idx = 2 (out of 5)
[i] Native Evolution outcome reward 计算   ✓ R_evolve = 0.18 (≥ 0)

代码经独立 reviewer 静态检查，逻辑通过 dataclass / 类型注解约束。