Reflexion：让AI学会从失败中成长
·
Reflexion：让AI学会从失败中成长
引言：为什么 Agent 需要"记住"失败？
想象一位程序员在调试代码：第一次遇到空指针异常，他学会了检查 null；第二次遇到并发问题，他记住了加锁。这些失败经验的沉淀，构成了他的专业判断力。
然而，传统的 AI Agent（如 ReAct）却像一位"金鱼记忆"的开发者——每次对话都是全新的开始，同样的错误会反复出现。Reflexion 架构正是为了解决这一根本缺陷而生：让 Agent 以自然语言的形式反思失败，将经验沉淀为可跨轮次传递的记忆。
一、核心命题：用 Verbal Memory 替代标量信号
传统强化学习用标量奖励（+1/-1）指导 Agent 学习，这存在三个致命缺陷：
| 问题 | 说明 |
|---|---|
| 不可解释 | -0.5 的奖励无法告诉 Agent “具体哪里错了” |
| 无法传递 | 本轮的奖励信号无法保留到下一轮对话 |
| 稀疏延迟 | 任务完成前的多步决策缺乏即时反馈 |
Reflexion 的核心创新：当 Agent 执行失败后，不立即重试，而是先以自然语言进行反思复盘，生成结构化的失败分析报告（如：“我在步骤3过早调用了API，应该先验证参数完整性”）。这份报告存入 Memory，供下一轮执行前读取。
本质：将强化学习的标量信号升级为可解释、可检索、可累积的 Verbal Memory。
二、论文层：Reflexion 四组件架构
来源：Shinn et al., Reflexion: Language Agents with Verbal Reinforcement Learning, NeurIPS 2023
┌─────────────────────────────────────────────────────────┐
│ Reflexion 架构 │
├─────────────┐ ┌─────────────┐ ┌──────────────────┐ │
│ Actor │───→│ Evaluator │───→│ Self-Reflection │ │
│ (执行者) │ │ (评估者) │ │ (自我反思) │ │
└─────────────┘ └─────────────┘ └────────┬─────────┘ │
↑ │ │
└────────────────────────────────────────┘ │
Verbal Feedback │
┌──────────────────────────────────────────────────────────┐│
│ Memory (记忆层) ││
│ ┌────────────────────────────────────────────────────┐ ││
│ │ 反思记录 #1: "步骤2未检查API返回值导致空指针..." │ ││
│ │ 反思记录 #2: "循环条件设置错误，应使用 < 而非 <= " │ ││
│ │ ... │ ││
│ └────────────────────────────────────────────────────┘ │◄┘
└─────────────────────────────────────────────────────────┘
2.1 四组件详解
| 组件 | 职责 | 关键设计 |
|---|---|---|
| Actor（执行者） | 执行任务；下一轮执行前先读取 Memory 中的反思记录 | 输入包含历史教训，具备"经验传承"能力 |
| Evaluator（评估者） | 对执行结果打分，判断成功/失败；触发反思流程 | 可由 LLM 自评、代码执行器或人工规则实现 |
| Self-Reflection（自我反思） | 失败后生成自然语言反思：“哪里做错了、下次怎么改” | 替代强化学习的标量信号，提供可解释的指导 |
| Memory（记忆） | 结构化存储反思内容；供后续 Actor 检索 | 支持向量检索或简单列表追加 |
2.2 工作流程
# 伪代码示意
memory = [] # 初始化空记忆
for trial in range(max_trials):
# Actor: 携带历史反思执行任务
context = build_prompt(task, memory)
result = actor.execute(context)
# Evaluator: 评估结果
score = evaluator.assess(result, ground_truth)
if score.is_success:
break # 成功则退出
# Self-Reflection: 生成失败分析
reflection = reflector.analyze(result, score.feedback)
memory.append(reflection) # 沉淀到记忆
# 下一轮循环：Actor 自动读取更新的 memory
三、工程层：Evaluator-Optimizer 工作流
学术论文到工程落地之间存在巨大鸿沟。Anthropic 在《Building Effective Agents》(2024) 中，将 Reflexion 转译为工程师可直接实现的三步流程：
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Draft │ ───→ │ Review │ ───→ │ Refine │
│ (生成初稿) │ │ (问题审查) │ │ (带反馈重写) │
│ ≈ Actor │ │ ≈ Evaluator │ │ ≈ Reflection │
└─────────────┘ └──────┬──────┘ └─────────────┘
│
识别问题、生成建议
(自然语言反馈)
3.1 三步流程映射
| 步骤 | 对应 Reflexion 组件 | 工程实现要点 |
|---|---|---|
| Draft | Actor | 生成初步输出（代码/文案/分析等） |
| Review | Evaluator | 独立的审查节点，可由另一个 LLM 实例担任"挑剔的审稿人" |
| Refine | Self-Reflection + Memory | 携带审查反馈重新生成，而非简单修改原文 |
3.2 关键工程决策
1. Evaluator 的多样性设计
- 代码任务：用执行器捕获编译错误/测试失败作为客观信号
- 文案任务：用评分模型或人工规则评估质量
- 复杂任务：用另一个 LLM 担任 Evaluator（如 GPT-4 审查 GPT-3.5 的输出）
2. Memory 的存储策略
# 简单实现：文本列表
memory = [
"错误类型: API调用过早 | 修正: 先验证参数完整性",
"错误类型: 循环边界 | 修正: 使用 < 替代 <="
]
# 高级实现：结构化存储 + 向量检索
memory = [
{
"error_type": "null_pointer",
"context": "步骤3调用外部API",
"fix": "添加非空检查",
"embedding": [0.23, -0.45, ...] # 用于相似错误检索
}
]
四、源码层：Claude Code 的三层防御机制
Claude Code 并未将 Reflexion 实现为独立的四个模块，而是将其思想散点式嵌入在 while true 主循环的三层防御中。这种设计体现了"防御性编程"的工程智慧。
4.1 架构全景图
┌─────────────────────────────────────────────────────────────┐
│ Claude Code 执行循环 │
│ while true {...} │
├─────────────────────────────────────────────────────────────┤
│ 第一层：工具错误注入（即时反馈） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 工具调用失败 → is_error: true 注入上下文 │ │
│ │ [最小粒度 Evaluator 闭环] │ │
│ └─────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│ 第二层：熔断机制（失败止损） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ denialTracking.ts: maxConsecutive = 3 │ │
│ │ 连续3次被拒 → 立即中止，强制人工介入 │ │
│ │ [防止无限循环的资源保护] │ │
│ └─────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│ 第三层：语言记忆（跨轮次沉淀） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ autoCompact 触发条件：上下文接近上限 │ │
│ │ 总结 Prompt 第4条：记录 Errors and fixes │ │
│ │ → 生成失败摘要，写入 Verbal Memory │ │
│ │ [Reflexion 的核心工程实现] │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
4.2 第一层：工具错误注入（即时 Evaluator）
当 Agent 调用外部工具（如文件读取、代码执行）失败时，系统不会直接抛出异常终止，而是将错误信息以结构化格式注入对话上下文：
// 示意代码
const toolResult = {
tool: "read_file",
params: { path: "/nonexistent.txt" },
result: null,
is_error: true, // 关键字段
error_message: "FileNotFoundError: [Errno 2] No such file..."
};
// 该结果作为 Assistant 的下一条输入，构成即时反馈闭环
设计智慧：这是最小粒度的 Evaluator，无需等待任务结束，单步工具失败即可触发纠正。
4.3 第二层：熔断机制（失败止损）
// denialTracking.ts 核心逻辑
class DenialTracker {
private maxConsecutive = 3; // 硬性上限
private consecutiveDenials = 0;
recordDenial(reason: string) {
this.consecutiveDenials++;
if (this.consecutiveDenials >= this.maxConsecutive) {
throw new CircuitBreakerError(
`连续 ${this.maxConsecutive} 次执行被拒绝，强制人工介入`
);
}
}
recordSuccess() {
this.consecutiveDenials = 0; // 重置计数器
}
}
工程必要性：防止 Agent 陷入"反思-重试-再失败-再反思"的无限循环，保护计算资源和用户体验。
4.4 第三层：语言记忆（Verbal Memory 工程化）
这是 Reflexion 思想最精妙的实现。当对话上下文接近模型长度上限时，触发 autoCompact 流程：
// autoCompact 触发后的总结 Prompt（简化版）
const compactionPrompt = `
请总结本次对话的关键信息，按以下结构输出：
1. 任务目标: [原始需求]
2. 执行计划: [已完成的步骤]
3. 当前状态: [进行中的环节]
4. **Errors and fixes**: [关键错误及修正方案] ← 第4条明确要求
5. 待办事项: [剩余任务]
`;
// 生成的总结（特别是第4条）被持久化存储
// 新对话启动时作为 System Prompt 的一部分注入
关键洞察：Claude Code 将"反思"从显式组件转化为隐式流程——不维护独立的 Reflector 模块，而是在上下文压缩时强制要求总结错误经验，实现跨会话的记忆传承。
感谢您的提醒！这部分对比内容确实非常重要，它帮助读者理解 Reflexion 在整个 Agent 架构演进中的定位。让我将这部分内容补充到文章中，并适当扩展以增强技术深度。
以下是补充后的完整章节，建议插入在原"五、从理论到实践"之前：
五、架构对比：Reflexion 在 Agent 范式中的定位
理解 Reflexion 的最佳方式，是将其置于 Agent 架构的演进脉络中观察。当前主流的三种模式各有侧重，而 Reflexion 的独特价值在于跨轮次的经验沉淀。
5.1 三种核心模式对比
| 模式 | 循环机制 | 记忆能力 | 核心局限 | 适用场景 |
|---|---|---|---|---|
| ReAct | 单轮内循环：Thought → Action → Observation | ❌ 无跨轮次记忆 | 同样错误反复出现 | 简单工具调用、单次查询 |
| Plan-and-Execute | 两阶段循环：规划 → 执行 → （可选）重规划 | ❌ 无失败经验沉淀 | 重规划时仍可能重复历史错误 | 复杂任务分解、多步骤工作流 |
| Reflexion | 纠错回路：执行 → 评估 → 反思 → 记忆 → 再执行 | ✅ 经验跨轮次传递 | 需要额外存储与检索开销 | 高可靠性要求、需持续学习的场景 |
┌─────────────────────────────────────────────────────────────────┐
│ ReAct 架构（单轮内反馈） │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Thought │───→│ Action │───→│ Obs │───→ (重复或结束) │
│ │ 思考 │ │ 行动 │ │ 观察 │ ↑ 无记忆传递 │
│ └─────────┘ └─────────┘ └─────────┘ │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Plan-and-Execute 架构（可重规划） │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Plan │───→│ Execute │───→│ Check │───→│Re-plan? │ │
│ │ 规划 │ │ 执行 │ │ 检查 │ │ 重规划? │ │
│ └─────────┘ └─────────┘ └────┬────┘ └────┬────┘ │
│ └────────────────┘ │
│ 重规划时仍可能重复历史错误 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ Reflexion 架构（跨轮次记忆） │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Actor │───→│Evaluate │───→│Reflect │───→│ Memory │────┐ │
│ │ 执行 │ │ 评估 │ │ 反思 │ │ 记忆 │ │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ ↑──────────────────────────────────────────────────────┘ │
│ 下一轮携带教训重新执行 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Memory 内容: ["错误:步骤3未检查null", "修正:添加验证"] │ │
│ └─────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
5.2 组合策略：Reflexion 作为增强层
Reflexion 并非替代 ReAct 或 Plan-and-Execute，而是作为纠错增强层叠加其上：
┌─────────────────────────────────────────┐
│ Reflexion 增强层 │
│ ┌─────────┐ ┌─────────┐ ┌──────┐ │
│ │Evaluate │───→│Reflect │───→│Memory│ │
│ └────┬────┘ └─────────┘ └──┬───┘ │
│ └────────────────────────────┘ │
├─────────────────────────────────────────┤
│ 底层执行架构（可替换） │
│ ┌─────────┐ ┌─────────┐ │
│ │ ReAct │ or │Plan-Exec│ │
│ │ 循环 │ │ 循环 │ │
│ └─────────┘ └─────────┘ │
└─────────────────────────────────────────┘
ReWOO 的特殊性：ReWOO（Reasoning WithOut Observation）为"单次盲跑"设计，通过预规划避免中间观察，不内置任何反馈机制，因此与 Reflexion 的纠错哲学相悖，不宜直接叠加。
六、while true 的角色演变：从驱动到纠错
Agent 架构的演进，本质上是 while true 循环职责范围的扩展：
6.1 三代架构的循环特征
| 架构代际 | while true 的核心职责 | 循环粒度 | 状态管理 |
|---|---|---|---|
| ReAct | 主动循环：驱动每一步的推理与工具调用 | 单步（Step-level） | 仅维护当前上下文 |
| Plan-and-Execute | 统筹循环：协调规划、执行与重规划的交替切换 | 阶段（Phase-level） | 维护计划与执行状态 |
| Reflexion | 纠错回路：将失败经验结构化存入记忆，下一轮携带教训重新执行 | 轮次（Trial-level） | 维护跨轮次记忆 |
6.2 代码层面的演进
# === ReAct: 单轮内循环 ===
while True:
thought = llm.generate("思考下一步...")
action = parse_action(thought)
observation = env.execute(action)
if is_done(observation):
break
# 下一轮：observation 加入上下文，但无历史经验
# === Plan-and-Execute: 阶段切换循环 ===
while True:
if need_replan:
plan = llm.generate("重新规划...")
for step in plan:
result = execute(step)
if check_failure(result):
break # 触发重规划
if is_done():
break
# 重规划时：plan 更新，但历史错误未结构化保存
# === Reflexion: 跨轮次纠错循环 ===
memory = [] # 关键：跨轮次持久化存储
while trial < max_trials:
# Actor: 携带历史教训
context = build_prompt(task, memory)
result = actor.run(context)
# Evaluator: 评估并触发反思
score = evaluator.assess(result)
if score.is_success:
break
# Self-Reflection: 生成结构化反思
reflection = reflector.analyze(result, score)
memory.append(reflection) # 沉淀经验
# 下一轮：自动携带 memory，避免重蹈覆辙
6.3 关键洞察：循环层级的升维
┌─────────────────────────────────────────────────────────────┐
│ 循环层级升维示意图 │
├─────────────────────────────────────────────────────────────┤
│ ReAct Plan-and-Execute Reflexion │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ 单步循环 ──────→ 阶段循环 ──────→ 轮次循环 │
│ (Step) (Phase) (Trial) │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ 上下文内反馈 阶段间重规划 跨轮次经验沉淀 │
│ 即时但易失 灵活但无记忆 持久且可累积 │
└─────────────────────────────────────────────────────────────┘
Reflexion 的本质突破，在于将 while true 从执行驱动器转变为学习进化器——每一次循环不仅是任务的重复尝试，更是认知能力的迭代升级。
七、从理论到实践：实施路径建议
基于上述三层架构，建议按以下路径落地 Reflexion：
Phase 1: 基础 Evaluator（1周）
├── 实现工具错误捕获（is_error 机制）
└── 添加简单的成功/失败判断
Phase 2: 反思生成（2周）
├── 设计反思 Prompt 模板
│ └── "分析失败原因，提出3条具体改进建议"
└── 实现 Memory 存储（文本/数据库/向量）
Phase 3: 记忆检索（2周）
├── Actor 输入时前置读取 Memory
└── 实现相似错误匹配（向量检索）
Phase 4: 生产加固（1周）
├── 添加熔断机制（maxConsecutive）
└── 实现上下文压缩与自动总结
六、总结：Reflexion 的三重价值
Reflexion 的本质，是将人类"从失败中学习"的认知机制工程化。当 Agent 开始像资深工程师一样记录踩坑笔记、复盘故障原因、避免重复犯错，我们才可以说：AI 真正拥有了持续进化的能力。
参考链接：
Shinn, N., et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. NeurIPS 2023. arXiv:2303.11366
Anthropic. (2024). Building Effective Agents. https://www.anthropic.com/engineering/building-effective-agents
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
8
0- 0
已为社区贡献7条内容
所有评论(0)