反思：省身之美，把循环闭合成自我演进

06.1反思导论：不更新权重的自我演进

Reflexion 把强化学习闭环整个搬进自然语言：稀疏奖励 → 一段言语反思 → 写进情景缓冲 → 下次重试前注入，用可编辑的 context 替代权重更新。

底层机制（比"让模型复盘一下"深一层）：Reflexion（Shinn 等，NeurIPS 2023）的核心替换是用可编辑的 context 替代梯度更新。环境发出一个稀疏奖励（通过/失败、分数）；一个 Self-Reflection LLM 读入（奖励、轨迹、长期记忆），写出一段简短的言语复盘——"假设了门是开的，但门锁着；下次先查物品栏"；这段文本追加进持久缓冲，并在第 N+1 次试验时前置回 prompt。没有梯度、没有微调，"权重更新"这一步被换成了改 context。它维护两类记忆：短期 = 当前轨迹，长期 = 累积的反思。代价是线性于试验次数（每次重试是一整次 rollout 加一次反思调用），且受窗口约束——缓冲必须摘要或截断，否则反思堆成噪声。它在奖励太稀疏、无从反思时失效，也在反思被环境一再证伪却不更新时固化成错误信念（第 03 章的记忆虚构）。

06.2生成-批评：一个 agent 里的两个我

生成-批评把"写"和"评"拆成两个角色循环，但三种变体的天花板是同一个——模型检测自身错误的能力；无外部 oracle 时，这个天花板在推理上低到会让准确率不升反降。

底层机制（比"再检查一遍"深一层）：三种结构差别仅在角色怎么拆、信号从哪来。(a) Self-Refine（Madaan 等，NeurIPS 2023）= 一个模型扮三个角色（生成 / 反馈 / 精炼），循环至多 4 轮，7 个任务上用 GPT-4 平均提升约 20%。(b) 评估-优化（evaluator-optimizer，Anthropic 命名）= 拆成两次调用，让批评者不被"刚写完这段文字"锚定。(c) LLM-as-a-judge = 批评者是个打分/排序器，产出接受或继续的信号。文档下一层的真相是：这三者都从模型自己的分布里制造反馈，天花板就是模型检测自身错误的能力。Huang 等（ICLR 2024）给出硬证据，证明这个天花板在推理上很低：无 oracle、固定纠正 prompt 下，准确率下降——GPT-3.5 在 GSM8K 上 75.9→75.1→74.7，CommonSenseQA 大幅下降 75.8→38.1→41.8；GPT-4 在 GSM8K 上 95.5→91.5→89.0，HotpotQA 49.0→43.0；Llama-2 在 GSM8K 上 62.0→43.5→36.5。原因：GSM8K 上 GPT-3.5 有 74.7% 的答案根本不改，而在改了的里，模型把对的改错多于把错的改对，因为它判断不了自己推理链的对错。

LLM-as-a-judge 还自带偏置：批评信号不只弱，而且歪。位置偏置——交换候选顺序能让成对判断的准确率漂移超过 10%；冗长偏置——偏好更长更流畅的输出；自我偏好偏置——偏爱自己生成的、困惑度更低的文本。标准缓解是交换顺序取平均和长度控制的胜率。所以在可验证任务上，LLM-as-a-judge 绝不该是唯一 oracle。

06.3技能包：把一次成功蒸馏成可复用的招式

程序性记忆把一次情景成功蒸馏成一个可复用的"招式"——存的是经过自我验证的代码/流程，不是原始轨迹，靠 progressive disclosure 让库无限大却 token 廉价。

底层机制（比"存个 prompt 模板"深一层）：Voyager（Wang 等，2023）的做法——任务经自我验证确认成功后，把可运行代码存进向量库，键是一段 GPT-4 写的 docstring 的 embedding；未来任务用当前计划+反馈的 embedding 去查这个索引；技能是纯可执行代码，所以复杂技能调用更简单的技能（可组合、可解释、无灾难性遗忘）。Anthropic 的 Agent Skills 是同一思想的生产硬化版：一个文件夹放 SKILL.md（YAML 的 name + description），靠 progressive disclosure 分三层加载——L1 元数据始终在 prompt 里，L2 完整 SKILL.md 仅在判定相关时加载，L3 捆绑文件按需读取。于是"库"在大小上近乎无界，token 成本却近乎常数（每个技能平时只占约一行元数据），还能 fork 进一个带全新 context window 的 subagent。两者的主线一致：捕获成功的过程（代码或指令），不是原始轨迹；而那道自我验证门是关键——略过它，未来检索会复用 bug。

# 技能库：自我验证门 + embedding 索引 + progressive disclosure（Voyager / Agent Skills）
def try_task(task, skills, verify):
    plan      = decompose(task)
    retrieved = skills.search(embed(plan + last_feedback))   # 按相似度拉回候选技能
    code      = generate_with(plan, retrieved)               # 复杂技能可调用子技能
    result    = execute(code)

    # 写入门禁：只有自我验证确认成功，才允许进库（不然就是往库里灌 bug）
    if verify(task, result).passed:                          # 外部 oracle / 测试
        docstring = llm_write_docstring(code)                # GPT-4 写说明，用作检索键
        skills.add(key=embed(docstring),
                   value=code,                               # 存的是可执行代码，不是轨迹
                   level1=metadata_line(docstring))          # L1 常驻；L2/L3 按需加载
        return result
    return None                                              # 失败不入库，避免污染

# progressive disclosure：平时只有 L1 一行元数据在 prompt 里，相关时才载入 SKILL.md 正文

06.4经验回放：学过的工作不白费

情景回放存整条轨迹，检索一个相关的过往成功当 few-shot 注入给相似新任务；hindsight relabeling 更进一步——让失败的轨迹也变成可用范例。

底层机制（比"多给几个 few-shot"深一层）：经验回放存整条过往轨迹，检索一个相关的过往成功，作为 few-shot 范例注入给"相似但新"的任务。它和 06.3 的区别是硬的：技能 = 蒸馏后的代码/流程，回放 = 原始轨迹范例用于 in-context。机制代价由检索质量主导——一个不相关的检索范例会主动误导，把行为拖向错误解（"experience-following"，即被旧经验带偏）；记忆必须被治理，否则膨胀 context、产生漂移。聪明的扩展是 hindsight relabeling（沿用 HER 的方法）：一次未达成原目标、却达成了别的目标的轨迹，被重新标注成它实际达成的那个目标——于是连失败也变成正样本范例，在稀疏奖励下大幅提升样本效率。这正回应第 03 章那条主线：context window 不是 oracle，真正决定一条记忆有没有用的，是检索把不把对的那条调出来。

06.5自愈循环：测试驱动的自我修复

测试驱动自愈 = 生成-批评 + 把批评者换成外部 oracle（测试/编译/运行时）；正因为 oracle 是真 ground truth，循环才真收敛——这恰是 06.2 缺的那味料。

底层机制（比"跑通测试就行"深一层）：自愈循环是生成-批评，但批评者是一个外部 oracle（测试套件 / 编译器 / 运行时）——这正是 Huang 证明 06.2 缺失的那味料。循环：生成代码 → 执行测试 → 失败时把具体信号（stack trace、失败断言、diff）喂回 → 打补丁 → 重复。因为 oracle 是真 ground truth，循环真收敛，而非退化。最吃功夫的工程是停止条件：全部测试通过是顺利路径，但还需要 max-retries 护栏（常见每轮约 3 次，到上限接受最后一版）、no-progress / 震荡检测，以及防止 agent 奖励黑客（reward hacking）——它会去钻一个弱 oracle 的空子：写代码淹没一个 LLM-judge 让它误判通过，或干脆改测试而不改代码、把期望输出硬编码进去。而自己生成测试会把 06.2 的问题请回来：oracle 就只和模型一样可靠了，自愈又退回内在自我纠正。所以 06.5 的强度，精确地等于它那个 oracle 的强度——一个纯代码测试 oracle 远比一个 LLM oracle 安全。

# 统一反思循环——oracle 是否外部，决定它是 06.5（收敛）还是 06.2（退化）
def reflective_agent(task, oracle=None, skills=SkillLibrary(),
                     memory=EpisodicMemory(), max_iters=4):
    # 06.3/06.4：先拉回可复用技能 + 过往成功轨迹当 few-shot
    context = skills.retrieve(task) + memory.retrieve_successes(task)
    output  = generate(task, context)            # generator
    history = [output]

    for i in range(max_iters):                   # 06.5：循环护栏 / 停止条件
        if oracle:                               # 外部信号 → 真收敛
            signal = oracle.run(output)          # 测试 / 编译 / 环境奖励
            if signal.passed:
                break
            feedback = signal.failure_detail     # stack trace、失败断言、diff
        else:                                    # 内在自评（Huang ICLR'24）→ 慎用
            feedback = critique(output)          # 生成-批评 / LLM-as-judge
            if i > 0 and not improving(history): # no-progress / 震荡护栏
                break                            # 否则循环会让准确率退化

        output = refine(task, output, feedback)  # optimizer / refiner
        history.append(output)

    if oracle and oracle.run(output).passed:     # 只提交已验证的胜利
        reflection = reflect(task, history, reward=1)   # Reflexion：言语教训
        memory.store(trajectory=history, reflection=reflection)
        skills.add(distill_to_code(output))             # Voyager：自我验证→存技能
    return output