Reflexion：让 Agent 学会反思与自我纠正（附完整实现）

适合人群：已掌握 ReAct 与 Plan-and-Execute 两种范式、想进一步理解"自我改进"机制的开发者

---

📌 引言：Agent 做错了怎么办？

前面我们讲了两种规划范式：ReAct 边想边做，Plan-and-Execute 先计划再执行。但两者都有一个共同点：错了就重来，却从不总结经验。

想象一个场景：Agent 写代码时因为"忘记处理空列表"报错。修复后跑通了——但下一次遇到类似任务，它大概率还会犯同一个错，因为模型没有"记忆"这次教训。

Reflexion（反思） 解决的就是这个问题：让 Agent 在失败后主动总结经验教训，带着教训重试，直到成功或达到上限。 它把"试错"升级成了"从试错中学习"。

论文出处：Shinn et al., Reflexion: Language Agents with Verbal Reinforcement Learning。

---

一、Reflexion 的核心机制

一句话：执行 → 评估 → 反思 → 带着教训重试。

用户任务
   ↓
① 执行（Act）：Agent 尝试完成任务
   ↓
② 评估（Evaluate）：检查结果是否正确
   ↓ 失败 ↓
③ 反思（Reflect）：分析失败原因，生成一条"经验教训"
   ↓
④ 带着经验重试（Retry）：回到 ①，但这次带上反思记录
   ↓ 成功
最终答案

四个阶段各有分工：

阶段	角色	说明
执行者（Actor）	尝试完成任务	可以是 ReAct 循环，也可以是一次完整求解
评估者（Evaluator）	判断结果好坏	规则校验 / 测试用例 / LLM 评判
反思者（Reflector）	生成经验教训	分析"为什么错、下次怎么避免"
记忆（Memory）	跨尝试保存教训	每条反思作为上下文带入下一次尝试

关键洞察：Reflexion 不改模型权重（不微调），只改"上下文"——把反思文本塞进提示词。成本低、见效快，这就是它被称为"语言层面的强化学习"的原因。

---

二、Reflexion vs ReAct vs Plan-and-Execute

三大范式放到一起对比，选型就清晰了：

维度	ReAct	Plan-and-Execute	Reflexion
核心动作	边想边做	先计划后执行	失败后反思重试
主要解决	探索性任务	流程稳定与省 Token	高错误率任务的准确性
失败处理	思考换路（即时）	重规划（按需）	总结教训再重试（记忆型）
额外成本	每步推理	低	多轮尝试 + 反思，最高
适合场景	信息搜集	数据流水线	代码修复、精确计算、推理题

选型口诀：探索用 ReAct，流程用 Plan-and-Execute，容易错且必须对 → Reflexion。

---

三、完整实现：求解 + 评估 + 反思循环

下面用 OpenAI SDK 实现一个最小 Reflexion 系统，任务是用鸡兔同笼问题演示"第一遍可能错 → 反思 → 第二遍做对"的完整过程。

3.1 准备工作

pip install openai

并设置环境变量 OPENAI_API_KEY。

3.2 完整代码

import re
from openai import OpenAI

client = OpenAI()  # 自动读取 OPENAI_API_KEY

# ---------- ① 执行者：尝试解答一次，可携带历史反思 ----------
def solve_once(question: str, memory: list) -> str:
    messages = [
        {"role": "system", "content": (
            "你是解题助手。请先写出解题过程，最后一行输出：答案=数字\n"
            "如果用户消息中包含【反思记录】，请务必认真吸取其中的教训，避免重犯。"
        )},
    ]
    if memory:
        messages.append({
            "role": "user",
            "content": f"【反思记录】\n" + "\n".join(f"- {m}" for m in memory),
        })
    messages.append({"role": "user", "content": question})
    resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        temperature=0,
    )
    return resp.choices[0].message.content

# ---------- ② 评估者：用规则校验答案 ----------
def evaluate(answer_text: str, expected: int) -> bool:
    """从回答中提取'答案=数字'并比对期望值"""
    m = re.search(r"答案=\s*(\d+)", answer_text)
    if not m:
        return False
    return int(m.group(1)) == expected

# ---------- ③ 反思者：让 LLM 分析错误原因，生成教训 ----------
def reflect(question: str, answer_text: str, expected: int) -> str:
    resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": (
                "你是学习教练。学生答错了一道题，请分析错误原因，"
                "并总结成一条简短的、可执行的反思（不超过50字）。"
                "只输出反思内容本身。"
            )},
            {"role": "user", "content": (
                f"题目：{question}\n"
                f"正确答案：{expected}\n"
                f"学生的回答：{answer_text}\n"
                f"请指出哪里错了，并给出下次避免出错的方法。"
            )},
        ],
    )
    return resp.choices[0].message.content

# ---------- ④ 主循环：尝试 → 评估 → 反思 → 重试 ----------
def run_reflexion(question: str, expected: int, max_trials: int = 3) -> str:
    memory = []  # 反思记忆：跨尝试积累教训
    for trial in range(1, max_trials + 1):
        print(f"===== 第 {trial} 次尝试 =====")
        answer_text = solve_once(question, memory)
        print("回答：", answer_text.replace("\n", " ")[:80], "...")

        if evaluate(answer_text, expected):
            print("✅ 评估通过")
            return answer_text

        # 失败 → 反思 → 记入记忆
        lesson = reflect(question, answer_text, expected)
        memory.append(lesson)
        print(f"💡 反思：{lesson}")

    return "达到最大尝试次数，仍未通过。"

if __name__ == "__main__":
    question = "笼子里有 35 个头、94 只脚，鸡和兔各有多少只？"
    final = run_reflexion(question, expected=23)  # 鸡 23 只
    print(f"\n最终答案：\n{final}")

说明：示例中"期望答案"用规则直接校验，用于演示评估环节；真实场景的评估可以是测试用例、单元测试、或另一轮 LLM 评判。

3.3 运行效果（示意）

===== 第 1 次尝试 =====
回答：设鸡 x 只、兔 y 只，x+y=35，2x+4y=94，解得 x=24，y=11 ...
💡 反思：注意联立方程 2x+4y=94 与 x+y=35 消元时，
     应先将 y=35-x 代入再计算，避免代数符号错误。

===== 第 2 次尝试 =====
回答：设鸡 x 只，则兔 35-x 只，2x+4(35-x)=94 → x=23，兔 12 只。答案=23
✅ 评估通过

第二次尝试明显"吸取了教训"：不再直接列双元方程，而是先代入消元——这就是反思记忆在起作用。

---

四、工程落地时的四个关键设计

4.1 评估器决定一切：评估不准，反思就失真

Reflexion 的效果上限由 Evaluator 决定。评估器选型优先级：

1. 规则/测试用例：结果可验证（如代码题跑单测）→ 最可靠，首选；
2. LLM 评判：开放题没有标准答案 → 用强模型 + 评分标准打分；
3. 人工抽检：LLM 评判仍有偏差 → 定期人工复核评估器的准确率。

4.2 反思的质量要约束

反思太短没信息量，太长稀释上下文。建议：

• 提示词限定反思格式：“错误原因 + 一条可执行教训”，不超过 50 字；
• 只保留最近 N 条反思（如 3 条），避免历史教训堆积把上下文撑爆；
• 可让反思"分类"：是计算错误、理解错误还是工具使用错误，分类后更利于下次规避。

4.3 控制尝试成本

Reflexion 是多轮重试，成本最高。三个护栏：

max_trials = 3        # 总尝试上限
budget_tokens = ...   # 总 Token 预算，超限即停
early_stop = True     # 连续两次反思内容高度相似 → 提前终止（说明模型已无改进空间）

4.4 记忆的两种归宿

• 会话内记忆：反思只影响当前任务（本文示例）——简单、无副作用；
• 持久化记忆：把"高质量反思"写入长期存储（向量库），下次同类任务直接复用——效果更好，但要做好反思的质检与去重，防止把错误教训也存进去。

---

五、适用场景与常见误区

值得用 Reflexion 的场景：

• 💻 代码修复：单测失败 → 反思 → 再修，效果好且评估简单；
• 🧮 精确计算/推理题：答案可校验，错一次就反思重来；
• 📄 格式敏感任务：输出必须符合 JSON Schema，失败即反思；
• 🔬 评测驱动开发：把 RAG / Agent 的评测分数作为评估器，反思优化策略。

常见误区：

1. “所有任务都套 Reflexion”：简单任务只会白花钱，先用 ReAct/Plan-and-Execute；
2. “反思等于微调”：反思只改上下文，不改权重，效果是"临时的"，不会让模型永久变聪明；
3. “重试越多次越好”：第 3 次以后收益骤降，成本却线性上涨，上限设在 3~4 次最划算。

---

六、常见问题 FAQ

1. “反思出来的教训一定对吗？”
不一定。反思也是模型生成的，可能把"正确的做法"当成教训记下来，或教训本身有误导性。生产环境要对反思做质检：用强模型对反思打分，或人工抽检，低质量反思直接丢弃，避免"越反思越错"。

2. “Reflexion 能用在多 Agent 场景吗？”
可以，而且很自然：评估者可以是另一个 Agent（如"批评者"角色）专门挑毛病；反思结果也可以写入共享的"团队记忆"，让其他 Agent 复用经验。这正是多 Agent 协作系统里"专家 + 评审"模式的底层机制。

3. “为什么有时候重试几遍还是错？”
常见三种原因：① 模型能力确实到顶（换更强模型）；② 评估器不准确，把对的判成错的（修评估器）；③ 反思没抓住根因，教训停留在表面（提高反思提示词质量，要求输出"根因 + 可执行教训"）。排查顺序也按此进行。

4. “Reflexion 和思维链（CoT）是什么关系？”
两者维度不同：CoT 是单次尝试内部的推理过程（让模型把思考写出来）；Reflexion 是跨尝试之间的经验积累（失败后总结再重来）。它们不冲突——Reflexion 里的每次尝试完全可以内部用 CoT 思考，两者叠加效果更好。

---

✅ 总结

• Reflexion = 执行 → 评估 → 反思 → 重试，核心是让 Agent “带着教训再来一次”；
• 四大组件：执行者、评估者、反思者、反思记忆，全部通过改上下文实现，不微调模型；
• 三大范式定位：ReAct 管探索、Plan-and-Execute 管流程、Reflexion 管准确率，可自由组合；
• 工程四要点：评估器选型、反思质量约束、成本护栏、记忆持久化；
• 适合高错误率且必须答对的任务，简单任务慎用——成本是它最大的代价。

📌 觉得有用就 点赞 + 收藏 + 关注，更多 AI Agent 干货持续输出。