Reflection反思机制：Agent自我进化关键

可视化演示

Reflection是让Agent在行动后回顾总结并改进的经典机制。这篇深入讲Reflection的设计模式、... 切换模式查看不同维度。

反思机制概述

城南小馆的学徒阿火，炒了三个月菜还在犯同一个错：盐放太晚，菜炒老了。师父不骂他，只让他每晚打烊后做一件事——把当天炒的菜夹一筷子，边嚼边在本子上写：“哪道菜、火候、下料顺序、哪里不对”。三个星期后，阿火灶台上的菜开始有人夸了。这个“回锅试味 + 记录 + 调整”的循环，就是反思的雏形。

AI Agent 里的情况几乎一模一样。一个只会“执行任务→返回答案”的 Agent，就像从不回锅试味的阿火：错误的 JSON 格式可以连续输出六次，同样的逻辑漏洞一犯再犯。反思机制（Reflection）让 Agent 在拿到结果后多走一步——把任务目标、当前输出、一条专门的反思指令重新喂给大模型，让它以评审者的身份挑毛病，再根据意见改一版。

形式化地看，反思就是一次附加的 LLM 推理：

阿火的笔记本上写着“每晚三问：咸淡对吗？火候对吗？顺序对吗？”——这三问就是他的 \( p_{\text{ref}} \)。Agent 的反思提示词，本质也是这么一张“三问清单”，把模糊的“检查一下”变成有靶子的评审。

反思设计模式

阿火逐渐发现，复盘有两种频率：一种是菜出锅尝一口，没问题就上桌，这叫“单轮反思”；另一种是端上桌前反复试味，咸了就补、淡了就加，直到满意才出菜，这叫“循环反思”。他还给自己定了个规矩：试味最多三回，超过就得倒掉重做——这是终止条件。

在 Agent 里，“单轮反思”指生成 → 反思一次 → 修订一次 → 直接返回；“循环反思”则把“反思 → 修订”重复多轮，每一轮都把上一轮的反思意见拼进提示词，让输出逐步逼近目标。循环反思的模板大致是：先给系统指令“你是评审，请对照目标找缺陷”，再把目标、当前方案和上一轮反思意见依次排好。而“最多三回”对应终止条件：达到轮次上限、输出不再变化，或者模型自评为“已满足要求”。

循环反思的循环结构可以写成：

阿火后来把“最多试味三回”写成了后厨规矩，Agent 也一样：没有终止条件的循环反思，就像一把永远关不上的灶火，迟早把菜烧干、把预算烧穿。

ReAct框架配合

阿火以前是“收工才复盘”，后来跟着师父学会了“边炒边尝”：炒两下尝一口，咸了补盐，老了赶紧出锅——这叫过程控制。等到收工，再打开笔记本做整体复盘，这叫事后总结。两件事都做，菜才稳。

在 Agent 世界里，“边炒边尝”正是 ReAct 框架：模型在每个步骤先输出 Thought（思考），再输出 Action（行动，比如调用工具），然后拿到 Observation（观察结果），如此循环。而“收工复盘”就是 Reflection。把两者组合，就得到了 Agent 开发中最常见的一种范式：先用 ReAct 边想边做、收集工具反馈，跑完一段轨迹后再插入一轮反思，根据反思结果决定是交卷还是重跑。

ReAct 的单步循环可以写成：

阿火的灶台自此有了两道检查：菜下锅时盯火候（过程反思），收工后翻笔记本（事后反思）。ReAct 加 Reflection 的组合，正是把这两道检查都装进了 Agent。

效果提升案例

阿火开始把复盘笔记分享给一起学厨的同伴，大家照着“先尝后记”的方法做，出师速度明显加快。笔记不是玄学，是实打实的效率：同样的新菜，别人试六次才稳定，阿火试三次就稳了。Agent 的反思机制也有类似的、可量化的收益。

最经典的案例是代码生成。一个代码 Agent 生成函数后，先跑一遍单元测试，再把“哪些用例失败了、报错信息是什么”作为反思依据，让模型自己指出缺陷并重写。这被称为 Self-Debugging：小模型在 HumanEval 上的通过率可以翻倍以上；而 Reflexion 框架把 GPT-4 在 HumanEval 的 pass@1 从 80% 提升到 91%。类似的收益也出现在数学多步推理和多轮客服任务中——凡是“一步错、步步错”的场景，事后反思都能及时纠偏。

成功率提升的幅度可以这样衡量：

收益的另一面是成本：反思本质是“多跑几次模型”，token 消耗通常翻两三倍。阿火多吃了几块试味排骨，但换来的是招牌菜——值不值，得看任务的重要程度。

工程实现要点

阿火的笔记本越写越厚，他很快发现：如果所有复盘意见都堆在同一页，第二天根本找不到“排骨那一条”。于是他给本子分栏：左边记“当天过程”，右边贴“改进结论”，隔周再翻一次旧笔记——这叫记忆分轨。Agent 的工程实现，同样绕不开记忆。

工程上的第一件事是设计记忆存储：把“轨迹记忆”（本轮执行了哪些步骤、工具返回了什么）和“反思记忆”（得出了哪些结论）分开存放。轨迹记忆随任务结束可丢弃，反思记忆要沉淀下来，在下一次相似任务时作为前缀提示词复用。第二件事是设置反思轮次上限，默认 2-3 轮就够，防止死循环；第三件事是控制输入长度——把过长的历史轨迹做摘要，只保留关键步骤，否则提示词会撑爆上下文窗口。

成本模型可以预估为：

阿火后来把笔记本精简成“一页摘要 + 一条结论”，Agent 工程师们也做同样的事：摘要历史、裁剪轨迹、限定轮数。省下的每一分 token，最后都变成产品的毛利。

局限与改进

阿火遇到了新麻烦：他“反思上瘾”了。明明排骨味道已经不错，他非要再炒一遍，结果肉老了；有时实在尝不出毛病，又不想空着本子，就编一句“缺了点灵魂”。前者叫过度反思，后者叫幻觉式反思——两个都是 Reflection 的经典副作用。

过度反思发生在没有明确信号约束时：模型反复修改，把原本正确的输出改成错的，成本还线性上涨。幻觉式反思更隐蔽：当模型确实没有能力判断对错时（比如不知道正确答案），它倾向编造一个听起来合理的“问题”，再自问自答地修一遍。于是研究者引入外部 Critic：单元测试、工具报错、用户反馈、检索到的权威资料，这些真实信号比模型自己的“感觉”可靠得多。Reflexion 框架正是把测试结果转化为一条带分数的记忆，让 Agent 凭分数决定下一步。

把自评与外部评价融合，是当前的主流做法：

阿火最后把规矩改成：“自己尝一遍，再请师父尝一口。”Agent 的进化方向也一样：从闭门自省，走向“自省 + 外部信号”的双通道反思——这也是 Reflexion 等前沿框架的核心思想。

评估与调试

师父怎么判断阿火的复盘有没有效？看两点：一是犯过的错有没有再犯，二是同一道菜上桌的速度有没有变快。Agent 的反思机制也要用同样的眼光去评估：指标变了没有？错误是不是真的减少了？

工程上至少要盯三个指标：任务成功率（目标是否达到）、单任务反思轮数（是否总是在边界弹跳）、单任务成本（是否烧钱）。调试时则要打开日志，记录每轮的三元组 \((o_t, r_t, o_{t+1})\)——输出、反思、修订，三者对照才能看出反思是“真找毛病”还是“自说自话”。反思质量评估常用“命中率”：反思指出的问题是否真实存在，按此修改后结果是否变好。最后是收敛判断：如果连续两轮输出基本没变，说明反思已经榨不出新信息，该停了。

收敛条件可以写成：

阿火的本子上从此多了两个记号：犯过的错打叉，不再犯的打勾；菜还在改进的直接标注“待定”。Agent 的调试日志就是这本子——把每次反思都留下痕迹，你才知道它究竟是进化了，还是在原地转圈。

AI 应用场景

Python 演示

"""ReflectionAgent 演示：在 Agent 循环中嵌入反思，反复改进输出。"""  class ReflectionAgent:    """一个带反思循环的极简 Agent：执行 -> 反思 -> 改进 -> 再执行。"""     def __init__(self, llm_call, max_reflect=3):        self.llm_call = llm_call            # 外部注入的 LLM 调用函数        self.max_reflect = max_reflect      # 反思轮次上限        self.reflect_count = 0              # 当前任务已反思轮数        self.trajectory = []                # 记录每轮 (输出, 反思, 修订)     def solve(self, goal, draft):        self.reflect_count = 0        while self.reflect_count < self.max_reflect:            review = self.llm_call(                "你是评审。目标：" + goal + "\n当前方案：" + draft +                "\n请指出具体缺陷和改进点。"            )            revised = self.llm_call(                "根据反思修订方案。反思：" + review + "\n原方案：" + draft            )            self.trajectory.append((draft, review, revised))            if self.is_converged(draft, revised):                return revised            draft = revised            self.reflect_count += 1        return draft     def is_converged(self, old, new):        return old.strip() == new.strip()  def mock_llm(prompt):    """离线演示用：模拟 LLM 返回反思意见或修订方案。"""    if "指出具体缺陷" in prompt:        if "已补充空值检查" in prompt:            return "方案已完整，无需修改。"        return "边界条件未覆盖：入参为空时会崩溃。"    revised = prompt.split("原方案：")[-1]    if "已补充空值检查" not in revised:        revised += "（已补充空值检查）"    return revised  if __name__ == "__main__":    agent = ReflectionAgent(llm_call=mock_llm, max_reflect=3)    answer = agent.solve("实现两个数相除的函数", "def div(a, b): return a / b")    print("最终方案：", answer)    print("反思轮数：", agent.reflect_count)

1. def solve(self, goal, draft):入口方法，把一个粗糙的初始方案反复打磨，直到收敛或达到上限。
2. self.reflect_count = 0每开始一个新任务就重置轮次计数器，防止上一次任务的计数残留。
3. self.llm_call("你是评审...")第一次调用扮演“评审”，让模型站在挑刺视角给出具体缺陷。
4. self.trajectory.append((draft, review, revised))把“输出-反思-修订”三元组存进轨迹，方便事后排查日志。
5. if self.is_converged(draft, revised):新旧方案完全一致时提前收敛，省掉无意义的后续反思。
6. self.reflect_count += 1轮次递增，配合 max_reflect=3 形成终止条件，防止死循环。
7. answer = agent.solve("实现两个数相除的函数", ...)演示从有缺陷的除法函数出发，经过一轮反思补上空值检查。

常见误区

面试题