《AI Agent 技术原理与架构·决策、记忆与学习》7.1 Reflexion:失败回看与反思注入

Reflexion 让 Agent 在失败后回看轨迹、写反思并注入下一次尝试。本节把失败模式、轨迹可诊断性与修正率显式建模,比较不反思、通用提醒、针对性反思与错误归因四种策略的重试成功率,说明反思的价值来自证据定位,并给出反思存储、注入范围与防过拟合的架构判据。

以下数字均为教学假设,不构成对任何真实系统或供应商的承诺。失败模式、修正率与任务分布都是固定参数,只用于展示反思机制的计算方式。

Agent 失败之后,最简单的做法是原样重试。稍微好一点的做法是加一句“请更仔细”。Reflexion 提出的是另一条路:把失败轨迹回看一遍,用自然语言写一条反思,存进记忆,在下一次尝试时注入。它把“从失败中学习”从参数更新变成了上下文更新,因此不需要训练,也能在单个任务内生效。

但“反思”两个字很容易被浪漫化。一条反思能不能提高成功率,取决于它是否定位到了真正的失败原因、轨迹里是否有足够证据、以及注入后会不会干扰原本正确的部分。这一节把这些问题压缩成一个可计算的模型。

反思注入了什么

Reflexion 的基本循环可以写成三步:

  1. 失败回看:拿到本次运行的轨迹,包括动作、观测、错误信息和最终结果。
  2. 写反思:用自然语言总结“为什么失败、下次应该怎么改”。
  3. 注入重试:把反思放进下一次尝试的上下文,重新执行。

这里的关键不是“写了一段话”,而是这段话是否携带了新信息。如果失败原因是工具参数类型错误,轨迹里有明确的校验报错,反思可以写成“调用 search 时把 limit 从字符串改成整数”,这条信息是可执行的。如果失败原因是需求理解偏差,轨迹里只有“测试未通过”,反思可能只能写成“再仔细读需求”,这几乎没有增加信息。

所以反思的价值至少受三个因素约束:失败模式是否可修正、轨迹是否可诊断、注入的反思是否与失败原因匹配。

机制:修正率模型

把一次重试的成功率写成:

$$
p_{\text{retry}} = 1 - (1 - p_{\text{base}}) \cdot (1 - g)
$$

其中 $p_{\text{base}}$ 是不反思时的重试成功率,$g$ 是反思带来的修正增益。$g=0$ 表示反思没有信息,$g=1$ 表示反思一定修好剩余失败。这个形式假设反思只影响“原本会失败的那部分”,不会让原本成功的结果变差;后面的边界会讨论这个假设何时不成立。

实验中 $p_{\text{base}} = 0.25$,修正增益按失败模式给定:

失败模式可修正率直觉
格式错误0.80报错明确,改法确定
工具选错0.65轨迹能看到选错的动作,但替换工具有时不确定
约束遗漏0.40需要从需求或历史里找回约束,轨迹未必完整
观测过期0.50需要识别时间戳并重新获取
未知原因0.15轨迹没有可用证据,只能靠通用提醒

策略分四种:

  • 不反思:原样重试,$g=0$。
  • 通用提醒:注入“请更仔细地检查”,所有模式统一 $g=0.15$。
  • 针对性反思:轨迹可诊断时使用该模式的修正率;不可诊断时退回通用提醒。
  • 错误归因:反思归错了原因,$g=0.04$,但仍占用上下文并可能干扰正确部分。

实验包含十个失败任务,其中五个轨迹可诊断。可诊断比例本身就是一个架构指标:它取决于日志、工具返回和错误信息的质量,而不是模型能力。

最小实验:四种反思策略

# file: agp_lab/reflexion.py | write
# tier: 3
# verify: python3 -m unittest tests.test_reflexion
"""Reflexion:失败回看、反思注入与重试成功率。

一次失败之后,Agent 可以:直接重试、注入一条通用提醒、或根据轨迹证据写一条
针对性反思再重试。实验把“失败模式”和“轨迹是否可诊断”显式建模,比较三种
策略的重试成功率,说明三件事:

1. 反思的价值来自对失败原因的具体定位,而不是“要更仔细”这类提醒;
2. 轨迹不可诊断时,针对性反思只能退化为通用提醒;
3. 错误归因的反思会挤占有效修正,效果可能低于不反思。
"""
from __future__ import annotations

from dataclasses import dataclass

BASE_RETRY = 0.25
GENERIC_GAIN = 0.15
MISDIAGNOSIS_GAIN = 0.04

FIX_RATE = {
    "format_error": 0.80,
    "wrong_tool": 0.65,
    "missing_constraint": 0.40,
    "stale_observation": 0.50,
    "unknown": 0.15,
}


@dataclass(frozen=True)
class Task:
    name: str
    mode: str
    diagnosable: bool


def task_set() -> tuple[Task, ...]:
    return (
        Task("r01", "format_error", True),
        Task("r02", "format_error", True),
        Task("r03", "wrong_tool", True),
        Task("r04", "wrong_tool", False),
        Task("r05", "missing_constraint", True),
        Task("r06", "missing_constraint", False),
        Task("r07", "missing_constraint", False),
        Task("r08", "stale_observation", True),
        Task("r09", "stale_observation", False),
        Task("r10", "unknown", False),
    )


def final_success(base: float, gain: float) -> float:
    """一次重试的最终成功率:原成功率加上“修好剩余失败”的比例。"""
    if not 0.0 <= base <= 1.0:
        raise ValueError("base 必须在 [0, 1] 内")
    if not 0.0 <= gain <= 1.0:
        raise ValueError("gain 必须在 [0, 1] 内")
    return 1.0 - (1.0 - base) * (1.0 - gain)


def specific_gain(task: Task) -> float:
    """有轨迹证据时用该模式的修正率;诊断不了则退回通用提醒。"""
    if task.mode not in FIX_RATE:
        raise ValueError(f"未知失败模式: {task.mode}")
    if task.diagnosable:
        return FIX_RATE[task.mode]
    return GENERIC_GAIN


def gain_for(task: Task, strategy: str) -> float:
    if strategy == "none":
        return 0.0
    if strategy == "generic":
        return GENERIC_GAIN
    if strategy == "specific":
        return specific_gain(task)
    if strategy == "misdiagnosis":
        return MISDIAGNOSIS_GAIN
    raise ValueError(f"未知策略: {strategy}")


@dataclass(frozen=True)
class PolicyResult:
    name: str
    success: float
    gain_pp: float
    corrected: int


def run_strategy(tasks: tuple[Task, ...], strategy: str) -> PolicyResult:
    if not tasks:
        raise ValueError("任务集合不能为空")
    scores = []
    corrected = 0
    for task in tasks:
        gain = gain_for(task, strategy)
        scores.append(final_success(BASE_RETRY, gain))
        if gain > 0.0:
            corrected += 1
    success = sum(scores) / len(tasks)
    return PolicyResult(
        name=strategy,
        success=success,
        gain_pp=(success - BASE_RETRY) * 100.0,
        corrected=corrected,
    )


def compare_strategies(tasks: tuple[Task, ...]) -> list[PolicyResult]:
    return [
        run_strategy(tasks, "none"),
        run_strategy(tasks, "generic"),
        run_strategy(tasks, "specific"),
        run_strategy(tasks, "misdiagnosis"),
    ]


def diagnosable_share(tasks: tuple[Task, ...]) -> float:
    if not tasks:
        raise ValueError("任务集合不能为空")
    return sum(1 for task in tasks if task.diagnosable) / len(tasks)


if __name__ == "__main__":
    tasks = task_set()
    print(f"{'策略':<14}{'重试成功率':>12}{'相对无反思':>12}{'有修正任务':>12}")
    for result in compare_strategies(tasks):
        print(
            f"{result.name:<14}{result.success:>12.3f}"
            f"{result.gain_pp:>11.1f}pp{result.corrected:>12}"
        )
    print()
    print(f"轨迹可诊断比例: {diagnosable_share(tasks):.1%}")
    print(f"未知模式修正率: {FIX_RATE['unknown']:.2f}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.reflexion

输出:

策略                   重试成功率       相对无反思       有修正任务
none                 0.250        0.0pp           0
generic              0.362       11.2pp          10
specific             0.542       29.2pp          10
misdiagnosis         0.280        3.0pp          10

轨迹可诊断比例: 50.0%
未知模式修正率: 0.15

四个结果可以连起来读。

第一,针对性反思明显优于通用提醒。 重试成功率从 0.250 提到 0.542,提升 29.2 个百分点;通用提醒只提升 11.2 个百分点。差距来自可诊断的五个任务:格式错误和工具选错的修正率高,反思能直接指出要改什么。通用提醒对所有模式一视同仁,实际上把高可修正任务的收益压平了。

第二,通用提醒也不是零收益。 它把成功率从 0.250 推到 0.362,说明“让模型再检查一遍”确实能捞回一部分表层错误。但它没有利用失败模式的信息,因此不应该和针对性反思相提并论。

第三,错误归因几乎没有价值。 错误归因的成功率 0.280,只比不反思高 3.0 个百分点,明显低于通用提醒。更糟的是,它会让系统误以为已经做了反思,从而跳过真正的诊断。归错原因的反思不是“弱一点的反思”,而是负资产:它消耗上下文、增加延迟,还可能把模型引向错误方向。

第四,可诊断比例决定了反思的上限。 十个任务里只有五个可诊断,针对性反思对其余五个只能退回通用提醒。如果日志里没有工具参数、没有校验错误、没有时间戳,再强的反思模型也只能写出“下次注意”。反思系统的第一个瓶颈通常在可观测性,而不是语言能力。

这也解释了为什么 Reflexion 在不同任务上的效果差异很大。W2 代码修复有测试输出和堆栈,轨迹可诊断性高;W1 检索问答的错误往往是引用不匹配,需要把答案和原文逐条对齐才能诊断;W3 运维处置的失败可能已经产生不可逆副作用,事后反思只能防止下一次,救不了这一次。

边界与失败模式

反思可能过拟合单次失败。 一次失败可能由偶发因素造成,比如工具超时或临时限流。如果反思写成“以后不要用这个工具”,下一次可能错过正确工具。反思应该区分“这次为什么失败”和“这个模式是否普遍”,前者是事件,后者才值得写入长期记忆。

反思会污染上下文。 注入的反思占用上下文预算,也可能让模型过度关注某个次要错误,忽略主要目标。反思越长、越具体,这种干扰越明显。生产系统要限制反思的长度、数量和注入位置,并保留“无反思”的对照组。

错误归因比不反思更差。 如果轨迹证据不足,模型可能编造一个看似合理的原因。错误反思会被当成事实注入,下一次尝试围绕错误假设展开。没有证据时,正确动作是标记“原因未知”,而不是生成一条自信的反思。

反思不能替代外部验证。 对 W2,反思应该指向“跑哪个测试、看哪段堆栈”,而不是“我认为问题在缓存”。对 W3,反思发生在失败之后已经太晚,真正需要的是动作前的审批、幂等和补偿。反思是学习机制,不是安全机制。

反思记忆会累积噪声。 多条反思叠加后可能互相矛盾,或者把早期环境的结论带到新环境。需要 TTL、作用域和冲突消解:哪些反思只对当前任务有效,哪些可以跨任务复用,哪些在新版本后必须失效。

反思本身有成本。 写反思要多一次模型调用,注入后上下文变长,重试也可能更慢。如果反思带来的成功率提升抵不过延迟和成本,它就不该默认开启。这一点和上一节的三角权衡是同一个问题。

架构含义

把 Reflexion 做成可用的系统,至少要满足五条:

  1. 结构化失败分类。 先用解析、工具、推理、终止等类别给失败归因,再让模型写反思;分类器可以规则化,反思只负责把类别翻译成可执行建议。
  2. 反思必须绑定证据。 每条反思要引用轨迹中的具体事件,比如错误码、测试名、工具返回字段。没有证据的反思标记为低置信,不进入长期记忆。
  3. 控制注入范围。 反思可以只注入当前任务的下一次尝试,也可以跨任务复用;两者要有不同的存储、TTL 和审核策略。默认应该是任务内注入。
  4. 保留对照组。 上线前后比较“有反思/无反思”的成功率、延迟和成本,确认收益来自反思而不是流量变化。没有对照,反思很容易变成一种仪式。
  5. 给反思设预算。 限制反思长度、生成次数和注入次数;连续多次反思仍失败时,应该停止重试并转人工或明确失败。

判据表:

判据合格的样子不合格的样子
归因有失败分类和轨迹证据让模型自由猜测原因
反思引用具体错误、测试或字段“下次更仔细”
注入限定任务、次数和长度无限累积进上下文
评测有反思/无反思对照只看最终成功率
安全不可逆动作有前置审批靠事后反思兜底

小结

  • Reflexion 把失败回看、反思生成和上下文注入连成闭环,不需要更新模型参数。
  • 反思的价值取决于失败模式可修正、轨迹可诊断、反思与原因匹配三个条件。
  • 针对性反思在实验里把重试成功率从 0.250 提到 0.542,通用提醒只提到 0.362。
  • 错误归因的反思接近无效,还会占用上下文并掩盖真正原因。
  • 可诊断比例是反思系统的上限,通常由日志和工具返回质量决定,而不是模型能力。
  • 反思不能替代外部验证和安全机制,尤其在 W3 这类不可逆动作上。

阅读导航:上一节:6.3 延迟/质量/成本的三角 · 下一节:7.2 Self-Refine:自我批评的失效模式 。

常见错误与边界

  1. 把“写反思”当成“学到了”。 没有证据、没有对照、没有注入策略的反思,只是一次额外的模型调用。
  2. 用通用提醒代替诊断。 “请更仔细”对所有失败一视同仁,收益有限,还会掩盖可修正性差异。
  3. 允许错误归因。 轨迹不足时编造原因,会把错误假设注入下一次尝试;此时应标记原因未知。
  4. 让反思无限累积。 无 TTL、无作用域、无冲突消解的反思记忆会互相矛盾,并挤占上下文预算。
  5. 只在失败后反思。 W3 的不可逆动作需要事前审批、幂等和补偿,事后反思救不了已经发生的副作用。
  6. 不做有/无反思对照。 流量、模型版本和任务分布都会变化,没有对照组就无法判断收益来自哪里。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图