精读笔记：Reflexion — 用"语言强化学习"让 Agent 自我改进

基本信息

阅读地图（建议顺序）

术语速查（本文第一节）
    ↓
Abstract — 3 分钟了解全文贡献
    ↓
Introduction — 10 分钟理解"为什么需要 Reflexion"
    ↓
Section 3 框架核心 — 20 分钟搞懂三角色 + 记忆机制
    ↓
Section 4 实验 — 15 分钟看三大任务上的提升数字
    ↓
Conclusion — 5 分钟了解局限与未来

零基础术语速查

在正式读论文之前，先把这些词钉牢，后面遇到不会懵：

Abstract（摘要）精读

原文：We propose Reflexion, a framework to reinforce language agents not by updating weights, but instead through linguistic feedback.

翻译：我们提出 Reflexion，这是一个通过语言反馈而非更新模型权重来强化语言 Agent 的框架。

讲解：这一句是全文的灵魂。传统强化学习（RL）的核心操作是"根据奖励信号，用梯度下降算法更新模型的几十亿个参数"——这个过程需要大量数据、大量算力、大量时间。Reflexion 的激进创新在于：完全不动参数。它不更新权重，而是让 Agent 在失败后"写一段反思文字"，把这段文字塞进下一次尝试的输入提示里。用一个类比：传统 RL 像"脑手术"（直接改造大脑结构）；Reflexion 像"写日记"（把教训记下来，下次看笔记行动）。

原文：Concretely, Reflexion agents verbally reflect on task feedback signals, then maintain their own reflective text in an episodic memory buffer to induce better decision-making in subsequent trials.

翻译：具体而言，Reflexion Agent 对任务反馈信号进行语言反思，然后将自己的反思文字维护在一个情节记忆缓冲区中，以在后续尝试中引导出更好的决策。

讲解：两个关键词：
- verbally reflect（语言反思）：不是数值计算，而是用人类语言写出"问题在哪里"；
- episodic memory buffer（情节记忆缓冲区）：一个存放"过去反思文字"的小仓库，下一次尝试开始时，Agent 会先读一遍这些笔记。

类比：就像学生考试错了一道题，写了一段"错题反思"贴在书上，下次考前翻看这段反思，不再犯同样的错误。

原文：We run Reflexion agents on tasks spanning decision-making, reasoning, and code generation, and show that Reflexion agents significantly outperform baseline agents on AlfWorld tasks over strong baseline approaches by an absolute 22% in 12 iterative learning steps, and on reasoning questions in HotPotQA by 20%, and on Python programming tasks on HumanEval by as much as 11%.

翻译：我们在涵盖决策制定、推理和代码生成的任务上运行 Reflexion Agent，结果表明：在 AlfWorld 任务上，Reflexion Agent 在 12 次迭代学习步骤中绝对提升了 22%；在 HotPotQA 推理问题上提升了 20%；在 HumanEval Python 编程任务上最高提升了 11%。

讲解：论文用三种完全不同的任务来验证 Reflexion 的通用性：
- AlfWorld：文字游戏式的家务任务（找物品、移动物品等），考验序列决策能力；
- HotPotQA：需要检索多篇维基百科文章才能回答的问题，考验多跳推理能力；
- HumanEval：写 Python 代码并通过单元测试，考验代码生成能力。

22%、20%、11% 这些绝对提升（absolute improvement，不是相对提升）在 AI 研究中已经相当显著。要注意：这些提升是多次尝试累积的结果，不是一次尝试就达到的。

Introduction（引言）精读

引言第一段：问题背景

原文：Recent works have explored the use of large language models (LLMs) as autonomous agents for sequential decision-making, reasoning, and code generation tasks. However, a key challenge remains: efficiently learning from trial-and-error as traditional reinforcement learning methods require extensive training samples and expensive model fine-tuning.

翻译：近期研究探索了将大语言模型（LLM）用作自主 Agent 来完成序列决策、推理和代码生成任务。然而，一个关键挑战依然存在：如何像传统强化学习方法那样从试错中高效学习——而传统 RL 需要大量训练样本和昂贵的模型微调。

讲解：引言开门见山地指出了痛点。LLM 已经很强了，但它有一个致命弱点：它不会从当前任务的失败中自动学习。每次调用 GPT-4 做任务，它都"不记得"上次失败过。而传统 RL 虽然可以让模型学习，但代价太高：需要数千次尝试的数据，需要用 GPU 跑好几天微调训练。有没有一种"廉价"的方式让 LLM Agent 从失败中学习？这是 Reflexion 要解决的问题。

引言第二段：核心思想提出

原文：We propose Reflexion, a novel framework that instead of updating model weights, reinforces language agents through linguistic feedback. Reflexion converts binary or scalar feedback from the environment into verbal feedback in the form of a textual summary, which is then added as additional context for the LLM agent in the next episode.

翻译：我们提出 Reflexion，一种不更新模型权重、而是通过语言反馈来强化语言 Agent 的新框架。Reflexion 将来自环境的二元或标量反馈信号（如成功/失败）转换为文字形式的反馈摘要，并将其作为额外上下文添加到下一次尝试中。

讲解：这是对核心机制的最精炼描述。注意两个转换关系：

```
传统 RL：
环境反馈（+1/-1）→ 梯度计算 → 更新模型 10 亿参数 → 模型变强

Reflexion：
环境反馈（成功/失败）→ LLM 写反思文字 → 追加到提示词 → 下次更聪明
```

"二元或标量反馈"：最简单的就是 True/False（任务完成了吗？），或者 0~1 分数。这类信号信息量极少——你只知道"失败了"，但不知道"为什么失败、在哪步失败"。Reflexion 的妙处在于用 LLM 把这个粗糙的信号"放大"成一段详细的文字分析。

引言第三段：三大核心优势

原文：The Reflexion framework has several key advantages: (1) it is lightweight and doesn't require finetuning of the LLM, (2) it allows for more nuanced feedback than scalar rewards, and (3) it enables explicit and interpretable episodic memory of prior failings.

翻译：Reflexion 框架具有几个核心优势：（1）轻量级，不需要对 LLM 进行微调；（2）与标量奖励相比，允许更细致、更丰富的反馈；（3）能够对过去失败建立显式且可解释的情节记忆。

讲解：逐一展开这三个优势：

优势 1——不需要微调（最重要）：使用 GPT-4 的 API 调用即可实现，无需访问模型内部，无需 GPU 训练。这意味着任何人用 API 就能用 Reflexion，极大降低了门槛。

优势 2——反馈更丰富：传统 RL 的奖励是一个数字（比如 0.73 分）。这个数字很难告诉 Agent 具体哪里错了。而 Reflexion 的反馈是一段自然语言，比如："第三步拿错了工具，应该先打开柜子再拿书，而不是直接去找书。"信息量完全不同。

优势 3——可解释记忆：Agent 的"学习成果"不是藏在不透明的神经网络权重里，而是存在一段可读的文字里。你可以直接查看 Agent 学到了什么，也可以手动编辑这些反思，甚至用于调试——这是传统 RL 完全做不到的。

引言第四段：与人类学习的类比

原文：This is akin to how humans iteratively learn to accomplish complex tasks in a few-shot manner – by reflecting on their previous failures in order to form an improved plan of attack for the next attempt.

翻译：这类似于人类如何通过少量尝试迭代学习完成复杂任务的方式——通过反思以往的失败，为下次尝试制定更好的行动计划。

讲解：作者明确了 Reflexion 的人类认知学灵感来源。"Few-shot manner"在 AI 语境中是"少量尝试"的意思——人类不需要做 10 万次才能学会骑自行车，通常几次就能找到规律。Reflexion 的目标也是让 AI 在极少次尝试（通常 3~12 次）内通过语言反思完成任务改进。

类比强化版：想象你在学习烤蛋糕。第一次烤糊了 → 你反思"温度太高了，下次调低20度"。第二次没熟 → 你反思"调太低了，再加5度同时多烤5分钟"。第三次成功。这就是 Reflexion 的核心逻辑：每次失败 → 写反思 → 带着反思再试一次。

引言第五段：与相关方法的区分

原文：Reflexion is distinct from prior work in that it does not attempt to fine-tune the LLM or compute gradients. It maintains reflective text in an episodic memory buffer, creating a form of verbal reinforcement learning that is orthogonal to existing gradient-based methods.

翻译：Reflexion 与之前工作的区别在于，它不尝试微调 LLM 或计算梯度。它将反思文字维护在情节记忆缓冲区中，形成一种与现有梯度方法正交的"言语强化学习"形式。

讲解："正交"（orthogonal）是数学术语，这里意思是"完全独立、互不干扰"——Reflexion 可以和任何基于梯度的方法结合使用，并不冲突。

与 Self-Refine 的区别（另一个自我改进方法）：Self-Refine 在单次对话内反复修改输出；而 Reflexion 专注于跨多次完整尝试的长期记忆，每次重新开始一个任务时都带着上次的反思。这个区别很关键：Reflexion 的记忆跨越了多次独立的"游戏局"，而不只是在一局游戏内反复改稿。

与 ReAct 的关系：Reflexion 不是 ReAct 的竞争者，而是增强者。ReAct 已经很擅长在一次尝试中交替推理和行动；Reflexion 在此基础上加了"失败后反思 + 下次带着反思重试"的能力。论文里很多实验都是"ReAct + Reflexion"组合。

Section 3：Reflexion 框架（核心方法）精读

框架总览

原文：Reflexion consists of three distinct models: an Actor (M_a), an Evaluator (M_e), and a Self-Reflection model (M_sr). The Actor generates text and actions conditioned on the current state. The Evaluator scores the Actor's output. The Self-Reflection model generates verbal reinforcement cues to assist the Actor in self-improvement.

翻译：Reflexion 由三个独立模型构成：Actor（执行者，M_a）、Evaluator（评估者，M_e）和Self-Reflection 模型（自我反思模型，M_sr）。Actor 根据当前状态生成文字和动作；Evaluator 对 Actor 的输出进行评分；Self-Reflection 模型生成语言强化线索，帮助 Actor 自我改进。

讲解：把三个角色想成一个团队：

```
Actor（演员/执行者）
→ 实际干活：看环境状态，决定下一步行动
→ 类比：学生参加考试，实际作答

Evaluator（评估者/裁判）
→ 判断结果好坏：任务成功了吗？得了几分？
→ 类比：老师批改试卷，给出对错

Self-Reflection（自我反思）
→ 分析失败原因：我哪里做错了？下次应该怎么改？
→ 类比：学生写错题反思笔记
```

三者合作形成一个迭代改进循环，每循环一次就是"一次完整尝试"。

Actor（执行者）

原文：The Actor is built upon a large language model that generates text and actions conditioned on the current state observations. In our experiments, the Actor uses either Chain-of-Thought (CoT) or ReAct reasoning to produce actions.

翻译：Actor 建立在大语言模型之上，根据当前状态观测生成文字和动作。在实验中，Actor 使用思维链（CoT）或 ReAct 推理来产生动作。

讲解：Actor 本质上就是"做事的那个 LLM"。它的输入是：
1. 任务描述（比如"找到厨房的苹果放到餐桌上"）；
2. 当前环境状态（比如"我在走廊，看到了厨房入口"）；
3. 历史记忆（包括之前失败的反思文字）——这是 Reflexion 加的新输入。

使用 CoT 时，Actor 会先写出推理过程再行动；使用 ReAct 时，Actor 交替地写推理和执行动作。两种方式都可以无缝接入 Reflexion 框架。

Evaluator（评估者）

原文：The Evaluator is responsible for scoring the output produced by the Actor. Depending on the task, the Evaluator can use exact match grading, a heuristic function, or an LLM-based reward model to assign a reward signal.

翻译：Evaluator 负责对 Actor 产生的输出进行评分。根据任务不同，Evaluator 可以使用精确匹配评分、启发式函数或基于 LLM 的奖励模型来给出奖励信号。

讲解：Evaluator 是"裁判"，但裁判的实现方式因任务而异：

任务类型	Evaluator 实现	示例
问答推理（HotpotQA）	精确匹配	答案和标准答案完全一样？+1，不一样？0
家务决策（AlfWorld）	启发式函数 + LLM	任务完成了吗？或者 LLM 判断"这条路线走偏了吗？"
代码生成（HumanEval）	单元测试执行	代码跑通了几个测试用例？

这个设计的巧妙之处：Reflexion 不依赖单一的评估方式，可以灵活适配各种任务。

Self-Reflection 模型（自我反思模型）——核心组件

原文：The Self-Reflection model is an LLM that takes a sparse reward signal (e.g., binary success/failure), the current trajectory, and its persistent memory as input, and produces a nuanced verbal summary of the failure, which is stored in long-term memory.

翻译：Self-Reflection 模型是一个 LLM，它以稀疏奖励信号（如二元的成功/失败）、当前轨迹，以及持久记忆作为输入，产生一段细致的失败文字摘要，存储在长期记忆中。

讲解：这是整个框架最关键的组件。它做的事情是：

```
输入：
- 稀疏信号："失败了（0分）" ← 信息量很少
- 本次完整轨迹：[动作1, 观察1, 动作2, 观察2, ...]
- 过去的反思笔记（如果有的话）

输出：
- 一段自然语言反思："我在第3步找书时，没有先检查桌子，
直接去了书架，但书其实在桌子上。下次应该先系统地搜索
每一个可能的位置，从最常见的位置开始。"
```

为什么"稀疏信号"是一个难题？ 想象老师只告诉你"考试不及格"（0分），没有给你试卷，没有告诉你哪道题错了。你很难从中学习。Self-Reflection 模型的任务就是：给定"失败"这个信号 + 完整的答题过程，自动分析出失败的原因并写成笔记。

用代码编程类比：这就像自动 Debug 工具——知道程序崩溃了（稀疏信号），看完整的执行日志（轨迹），分析根因，写一条"TODO: 第30行数组越界，下次检查边界条件"的注释留给下一次编程。

记忆机制（Memory）——短期 vs 长期

原文：The trajectory history serves as the short-term memory while outputs from the Self-Reflection model are stored in long-term memory. The long-term memory is bounded by a maximum capacity Ω, typically set to 1–3 experiences, to respect the finite context window of the LLM.

翻译：轨迹历史作为短期记忆，而 Self-Reflection 模型的输出存储在长期记忆中。长期记忆受最大容量 Ω 的限制，通常设置为 1~3 段经验，以适应 LLM 有限的上下文窗口。

讲解：Reflexion 的记忆系统分两层：

```
短期记忆（Short-term Memory）
= 当前这次尝试的完整行动序列
= 就像"工作记忆"，任务结束后通常不跨轮次保存
例如：这次找苹果的所有步骤 [走向厨房, 开冰箱, 发现苹果, ...]

长期记忆（Long-term Memory）
= 过去几次失败后写的反思文字
= 持续保存，每次新尝试开始时都读入
例如：
"第1次反思：我不应该直接找苹果，应该先检查可能的位置清单"
"第2次反思：我忘记了抽屉也是位置之一"
```

为什么限制 1~3 条？ LLM 的上下文窗口（一次能读多少文字）是有限的。如果积累了 100 条反思，全塞进提示词里，就超出了 LLM 能处理的长度。因此只保留最近几条最有用的反思，就像一个小本子只记最重要的几条笔记。

迭代算法（Algorithm 1）

原文：The agent iteratively generates a trajectory τ_t, receives evaluation from M_e, produces a self-reflection sr_t via M_sr, appends sr_t to memory, and continues until the task is solved or the maximum number of trials is reached.

翻译：Agent 迭代地生成轨迹 τ_t，从 M_e 接收评估，通过 M_sr 产生自我反思 sr_t，将 sr_t 追加到记忆中，循环直到任务解决或达到最大尝试次数。

讲解：用伪代码展示整个循环：

```python

Reflexion 完整工作流（概念伪代码）

memory = [] # 初始为空的长期记忆（反思笔记本）
max_trials = 12 # 最多尝试 12 次

for trial in range(max_trials):
# Step 1: Actor 尝试任务（带着历史反思）
trajectory = Actor.run(task, memory)

# Step 2: Evaluator 评估结果
score = Evaluator.score(trajectory)

# Step 3: 如果成功，停止
if score == SUCCESS:
    print("任务完成！")
    break

# Step 4: 失败了，Self-Reflection 写反思
reflection = SelfReflection.generate(
    signal=score,           # 失败信号
    trajectory=trajectory,  # 这次的完整行动记录
    memory=memory           # 之前的反思
)

# Step 5: 把反思存入记忆（最多保留 3 条）
memory.append(reflection)
if len(memory) > 3:
    memory.pop(0)  # 丢掉最旧的

# 进入下一轮尝试（Actor 会读取 memory 来避免重蹈覆辙）

```

这个循环就是 Reflexion 的全部精髓——用语言的方式"更新"Agent 的下次行为，完全绕过了梯度下降。

第三节补充：为什么叫"言语强化学习"？

Reflexion 的作者明确把这个框架定位为一种新型的强化学习范式。让我们对比两种 RL：

"言语强化学习"的本质定义：用自然语言反思代替梯度更新，通过提示词注入而非参数修改来实现 Agent 的行为改进。策略（policy）被参数化为：LLM 固定参数 + 动态更新的记忆文字。

Section 4：实验结果精读

实验 1：AlfWorld（家务序列决策任务）

原文：Reflexion agents complete 130 out of 134 tasks in AlfWorld, significantly outperforming the ReAct baseline which plateaus at approximately 104 tasks completed, representing a 22% absolute improvement over 12 iterative trials.

翻译：Reflexion Agent 在 AlfWorld 中完成了 134 个任务中的 130 个，显著超越了 ReAct 基线（大约完成 104 个任务即陷入停滞），在 12 次迭代尝试中取得了 22% 的绝对提升。

讲解：AlfWorld 是一个文字游戏式的家务模拟环境，包括 6 类任务：寻找隐藏物体、移动物体、用工具操作物体等，共 134 个场景。

为什么 ReAct 会"停滞"（plateau）？ ReAct 在一次尝试内会反复推理和行动，但如果任务真的很难，它靠单次尝试无法突破。Reflexion 则让 Agent 在失败后分析"为什么这条路走不通"，下次用不同策略——这就是 12 次迭代后 130/134 的底气。

具体例子：假设 Agent 需要"找热狗放进微波炉加热"，ReAct 可能一直在找热狗找不到（去错了地方）。Reflexion 的反思会写："我先搜索了冰箱，没找到。下次应该先检查餐桌、厨台、橱柜这些更常见的位置。"第二次尝试时带着这条笔记，就不会重复错误。

实验 2：HotpotQA（多跳推理问答）

原文：Reflexion outperforms all baseline approaches on HotPotQA reasoning tasks. The Reflexion ReAct approach achieves approximately 20% improvement over the ReAct baseline. An ablation study shows that self-reflection provides an 8% absolute boost over episodic memory alone (without verbal reflection).

翻译：Reflexion 在 HotPotQA 推理任务上优于所有基线方法。Reflexion + ReAct 方法比单纯 ReAct 基线提升约 20%。消融实验表明，自我反思（相比于只有情节记忆、没有语言反思）提供了 8% 的绝对提升。

讲解：HotpotQA 是 100 道需要检索多篇维基百科文章才能回答的多跳推理题（比如："出演《X 电影》的导演的出生城市是哪里？"——需要先找导演是谁，再找他的出生城市）。

消融实验（Ablation Study） 是机器学习中的一种重要实验方法："逐一去掉某个组件，看性能下降多少"，由此判断该组件的贡献。这里的消融说明：
- 只有情节记忆（把之前的轨迹直接塞进提示）：有提升，但有限；
- 加上语言反思（Self-Reflection 分析失败）：再多 8% 的绝对提升。

结论：语言反思本身（分析失败、提炼教训）是关键，不只是"记住了历史"。

实验 3：HumanEval 代码生成（最亮眼结果）

原文：Reflexion achieves 91% pass@1 accuracy on the HumanEval coding benchmark, surpassing the previous state-of-the-art GPT-4 that achieves 80% (80.1%). On LeetcodeHard (Python), Reflexion achieves 15.0% compared to GPT-4's 7.5%.

翻译：Reflexion 在 HumanEval 代码生成基准测试上达到了 91% 的 pass@1 准确率，超越了此前最优的 GPT-4（80.1%）。在 LeetcodeHard Python 任务上，Reflexion 达到 15.0%，而 GPT-4 仅为 7.5%。

讲解：这是全文最令人印象深刻的数字。HumanEval 是由 OpenAI 发布的编程测评集，共 164 道 Python 编程题，每道题都有配套的单元测试。

完整结果对照表（来自论文 Table 1）：

基准测试	GPT-4 基线	Reflexion（GPT-4）
HumanEval (Python)	80.1%	91.0% (+10.9%)
HumanEval (Rust)	60.0%	68.0% (+8.0%)
MBPP (Python)	80.1%	77.1% (-3.0%)
LeetcodeHard (Python)	7.5%	15.0% (+7.5%)

为什么 MBPP 反而下降了？ 论文专门解释了这一点：MBPP 测试集的自动生成单元测试"误报率"（false positive rate）高达 16.3%——即测试本身就有问题，会把正确的代码误判为错误，导致 Agent 反思了一些实际上不需要反思的"错误"，引入了噪音。而 HumanEval 的误报率只有 1.4%，所以效果显著。这提醒我们：Reflexion 的效果依赖评估信号的质量。

代码任务的反思是什么样的？ 假设 Agent 写了一段排序代码，但单元测试失败（边界情况没处理）。Self-Reflection 会分析："代码在输入为空列表时崩溃。测试用例 test_empty() 失败。下次需要在函数开头添加对空输入的检查。"Agent 带着这条反思，在下一次尝试中会在函数开头加 if not arr: return []。

实验 4：WebShop（电商环境，揭示局限）

原文：In WebShop experiments with 100 e-commerce environments, Reflexion agents showed no improvement after four trials. The agent terminated runs early. The key finding is that Reflexion struggles with tasks requiring significant diversity and exploration where permissible actions aren't visible in observations.

翻译：在 100 个电商环境的 WebShop 实验中，Reflexion Agent 在四次尝试后没有表现出改进。Agent 提前终止了运行。关键发现是：当任务需要大量多样性探索，且可用动作在观测中不可见时，Reflexion 难以发挥作用。

讲解：WebShop 是模拟在网上购物的任务——需要搜索商品、筛选条件、最终购买符合要求的产品。这个任务 Reflexion 失败了，为什么？

根本原因：WebShop 的动作空间极大（搜索词可以是无穷多种组合），而且正确的动作（比如"应该用什么搜索关键词"）并不能从观测中直接推断。反思能告诉你"上次用的关键词找不到产品"，但下次用什么词才对？LLM 不知道——它需要的是大量探索，而不是"反思上次的具体错误"。

这个失败案例非常重要：它明确划出了 Reflexion 的适用边界：
- 适合：任务结构清晰，失败原因可以从轨迹中分析出来（找物品、问答、写代码）；
- 不适合：需要大量随机探索才能找到解法的任务（搜索空间巨大、信息稀疏）。

Conclusion（结论）精读

原文：Reflexion provides a new paradigm for language agent learning, where agents reinforce themselves through verbal self-reflection rather than weight updates. The framework is lightweight, interpretable, and achieves strong results across diverse task types. However, it relies on the quality of LLM self-evaluation and cannot guarantee convergence to an optimal solution.

翻译：Reflexion 为语言 Agent 学习提供了一种新范式，Agent 通过语言自我反思而非权重更新来自我强化。该框架轻量、可解释，并在多种任务类型上取得了强劲结果。然而，它依赖 LLM 自我评估的质量，且无法保证收敛到最优解。

讲解：结论诚实地指出了两个重要局限：

1. 依赖 LLM 自我评估：如果 Self-Reflection 模型本身分析失误（把原因分析错了），后续的反思笔记就会误导 Agent，导致越学越差。LLM 并不总是能准确判断"为什么失败"。

2. 无法保证最优：Reflexion 可能陷入"局部最小"——每次反思都朝同一个错误方向改进，始终无法突破。这和传统 RL 面对的"局部最优"问题类似，只是在语言空间里。

原文：The reflective text is bounded by the LLM context window, which limits the number of historical experiences that can be stored. Future work could explore advanced memory structures such as vector embeddings or database-backed storage to overcome this limitation.

翻译：反思文字受 LLM 上下文窗口的限制，这限制了可存储的历史经验数量。未来工作可以探索更先进的记忆结构，如向量嵌入或数据库支持的存储，以克服这一局限。

讲解：当前 Reflexion 只能存 1~3 条反思（受上下文长度限制），这是个实际工程约束。未来方向是将记忆系统换成外部数据库——比如把所有历史反思存入向量数据库，每次尝试前检索"最相关的几条记忆"注入提示，而不是把所有记忆塞进上下文。这个方向和 RAG（检索增强生成）非常相似，是将 Reflexion 工程化、实用化的自然延伸。

核心贡献总结

一句话概括

Reflexion 让 LLM Agent 在失败后用语言写下反思笔记，下次任务开始前先读笔记——这就是它的全部，但效果出奇地好。

三个原创贡献

1. 新范式：提出"言语强化学习"框架，证明无需更新参数、用语言反思即可实现迭代自我改进；

2. 跨任务验证：在三类完全不同的任务（决策、推理、代码）上同时取得显著提升，证明框架的通用性；

3. 新基准：发布 LeetcodeHardGym（40 道 LeetCode 困难题 × 19 种编程语言），填补了代码生成评测空白。

思维导图

Reflexion
├── 问题：LLM Agent 无法从失败中学习
│   ├── 传统 RL：需微调，代价太高
│   └── 解法：用语言反思代替梯度更新
│
├── 框架三角色
│   ├── Actor（执行者）
│   │   ├── 基于 CoT 或 ReAct
│   │   └── 输入：任务 + 当前状态 + 历史反思
│   ├── Evaluator（评估者）
│   │   ├── 精确匹配 / 启发式函数 / LLM 评分
│   │   └── 输出：奖励信号（成功/失败/分数）
│   └── Self-Reflection（反思模型）
│       ├── 输入：稀疏信号 + 轨迹 + 历史记忆
│       └── 输出：自然语言反思文字
│
├── 记忆系统
│   ├── 短期：当前轨迹（游戏内）
│   └── 长期：最近 1~3 条反思（跨游戏局）
│
├── 迭代循环
│   └── 尝试 → 评估 → 反思 → 记忆 → 再尝试
│
├── 实验结果
│   ├── AlfWorld：+22%（134 题完成 130 题）
│   ├── HotpotQA：+20%
│   ├── HumanEval：80.1% → 91.0%（超越 GPT-4）
│   └── WebShop：失败（探索空间过大）
│
├── 优势
│   ├── 无需微调，只需 API 调用
│   ├── 反馈丰富（语言 vs 数字）
│   └── 完全可解释（记忆可读）
│
└── 局限
    ├── 依赖评估质量（垃圾进，垃圾出）
    ├── 上下文长度限制记忆量
    └── 不适合大探索空间任务

延伸阅读推荐

笔记作者：基于 arXiv:2303.11366 原文，使用 Claude Code 辅助精译 | 2026-05-27