AI 智能体 - 反思模式

反思模式通过“生产者-评论者”架构提升 AI 输出质量。生产者生成，评论者评审，生产者再迭代优化。此循环修正错误、提高准确性，但会增加延迟和成本。

在我们的 AI 智能体设计系列中，我们已经走过了一段漫长的路。

1. 在 提示链 (Prompt Chaining) 中，我们学会了如何像组装流水线一样，将复杂任务分解为可靠的顺序步骤。

2. 在 路由 (Routing) 中，我们为智能体安装了“交通枢纽”，让它能够根据条件逻辑做出动态决策。

3. 在 并行 (Parallelization) 中，我们赋予了智能体“分身术”，通过并发执行来压榨 I/O 等待时间，极大地提升了效率。

至此，我们已经构建了一个高效、灵活、路径清晰的智能体。但它仍然缺少一个至关重要的能力——判断力。

即使工作流设计得再精妙，一个 “一次通过”（first-pass）的输出也几乎不可能是完美的。它可能存在事实错误、逻辑缺陷、风格偏差，或者未能完全满足所有复杂的约束条件。

这正是 反思模式 (Reflection Pattern) 发挥作用的地方。

一、“第一稿”的缺陷：为什么反思至关重要？

想象一下，你要求一个初级营销助理（一个简单的链式智能体）“为我们的新款 AI 降噪耳机写一篇推广博文”。

你可能会得到这样的“第一稿”：

“快来购买我们的新款 AI 降噪耳机！它拥有惊人的技术和最好的降噪功能。我们的工程师日夜工作才打造出这款耳机。它的电池续航时间很长，听起来很棒。现在就下单吧！”

这份草稿有什么问题？

• 平淡无奇： 缺乏吸引人的“钩子”和品牌声音。

• 事实空洞： “惊人的技术”是什么技术？“很长”是多长？

• 未满足约束： 你的内部要求可能是“禁止使用‘最好’这样的绝对词汇”。

• 目标受众错位： 你的目标受众是“商务旅行者”，而这篇稿子看起来是写给所有人的。

没有反思能力的智能体，会自信地将这份“垃圾”作为最终答案提交给用户。它缺乏“元认知”（meta-cognition）——即“思考自己思考过程”的能力。

反思模式，就是为智能体引入一种自我纠正或自我改进的机制。它不再是“执行完就结束”，而是学会“停下来想一想”，评估自己的工作，并利用评估结果来迭代优化，直到产出真正高质量的成果。

二、反思模式的核心循环：从“执行者”到“改进者”

反思模式的本质区别在于它引入了反馈循环 (Feedback Loop)。智能体不再是 A→B→C 的线性执行者，而是进入了一个循环过程。

这个过程通常包括以下四个步骤：

1. 执行 (Execute)： 智能体执行任务，生成初始版本的输出（“第一稿”）。

2. 例如：生成一篇博文草稿。

3. 评估/剖析 (Evaluate / Critique)： 智能体（或另一个智能体）对上一步的结果进行分析。

4. 例如：检查草稿是否符合“商务旅行者”的语气？是否包含具体的技术参数？

5. 反思/优化 (Reflect / Refine)： 根据评估结果，确定具体的改进方向。

6. 例如：评估结果是“语气太随意，缺乏技术细节”。反思的决定是“重写开头，增加‘混合主动降噪’和‘30 小时续航’的细节”。

7. 迭代 (Iterate)： 智能体将优化后的方案付诸执行（生成“第二稿”），并重新开始步骤 2 的评估。这个循环不断进行，直到满足停止条件（如“评估通过”或“达到 3 次迭代上限”）。

三、“生产者-评论者”模型：实现客观反思的黄金搭档

虽然单个智能体可以“自我反思”（即自己生成，然后自己用不同的提示进行评估），但这往往会导致认知偏见。智能体很难跳出自己刚刚生成的“思维定势”。

一个更高效、更稳健的实现方式，是将流程拆分为两个独立的逻辑角色：生产者 (Producer) 和 评论者 (Critic)。

这被称为“生成器-评论者”（Generator-Critic）或“生产者-审查者”（Producer-Reviewer）模型。

1. 生产者智能体 (The "Doer")

• 角色： 创意工作者、初级开发人员、草稿撰写者。

• 使命： 专注于生成。 它的任务是“先做出来”。它接收初始提示，并快速生成输出的第一个版本。它不应过多地“瞻前顾后”，目标是效率和创造力。

• 系统提示示例： “你是一个富有创造力的营销文案。请为[产品]写一篇 500 字的博文草稿。”

2. 评论者智能体 (The "Reviewer")

• 角色： 资深编辑、技术负责人、事实核查员。

• 使命： 专注于评估。 它的唯一任务就是“挑刺”和“提供改进路径”。它会被赋予一套完全不同的、高度结构化的指令和角色设定。

• 系统提示示例： “你是一位挑剔的高级编辑和 SEO 专家。请根据以下标准评估草稿：1. 事实准确性（续航、技术参数是否正确？）；2. 品牌声音（是否体现了‘专业’和‘高端’？）；3. SEO（是否包含关键词‘商务旅行’、‘降噪’？）。你的输出必须是一个结构化的 JSON，包含评分和具体的改进建议。”

为什么职责分离如此有效？

这种职责分离非常强大，因为它模拟了现实世界中最高效的创意流程。

• 避免认知偏见： 评论者以“全新”的视角审视输出，完全专注于发现错误。

• 专业化： 你可以让“生产者”使用一个速度快、富有创造力的模型（如 gpt-4o-mini），而让“评论者”使用一个逻辑严谨、强大的模型（如 gpt-5 或 Claude 4），从而优化成本和质量。

• 结构化反馈： 评论者的输出（如 JSON）可以被程序化地解析。你可以检查"status": "APPROVED"来停止循环，或者解析"suggestions": [...]来自动构建下一个“优化”提示。

四、实际应用场景：反思模式的 6 个深度应用

当输出质量、准确性或对复杂约束的遵从性至关重要时，反思模式就能大放异彩。让我们深入探讨几个“贴合实际”的场景。

1. 创意写作与营销内容生成

• 场景： AI 智能体为一家高端护肤品牌撰写一封 EDM（电子邮件营销）推送，主题是“新款抗衰老精华”。

• 约束： 必须符合广告法规（不能使用“治愈”、“永不”等词）；必须包含两个 CTA 按钮；语气必须是“科学而奢华”。

• 反思流程：

• 生产者 (v1 - 创意文案)： 生成一份热情洋溢的草稿，标题是“逆转时光，永葆青春！”

• 评论者 (v1 - 法务与品牌专家)：

• "status": "REJECTED"
  

• "critique": ["严重违规：使用了‘永葆青春’和‘逆转时光’，违反TGA法规。", "品牌失焦：语气过于夸张，不够‘科学’。", "缺少CTA：只在末尾发现一个CTA。"]
  

• 生产者 (v2 - 创意文案 + v1 反馈)： 收到反馈，重新生成。标题改为“科技赋能，重焕肌肤活力”。正文增加了“经临床验证的肽复合物”等科学术语，并在中部和尾部插入了 CTA。

• 评论者 (v2 - 法务与品牌专家)：

• "status": "APPROVED"
  

• "critique": ["符合法规。品牌调性准确。CTA完整。"]
  

• 好处： 如果没有反思模式，v1 的草稿（一个“法律炸弹”）可能会被直接发送，造成灾难性后果。

2. 代码生成与调试

• 场景： 用户要求 AI 智能体“为我的电商应用编写一个 API 端点，用于处理‘优惠券’”。

• 约束： 必须使用 Python FastAPI；必须处理并发问题（防止同一张优惠券被多人同时使用）；必须有单元测试。

• 反思流程：

• 生产者 (v1 - 初级开发者)： 快速生成了 FastAPI 代码，但在数据库操作时未使用“事务”（transaction）或“锁定”（locking）。

• 评论者 (v1 - 静态分析器 + 单元测试器)：

• "status": "REJECTED"
  

• "critique": ["单元测试失败：未模拟数据库。"，"潜在Bug：未处理并发竞争条件（Race Condition）。当两个用户同时使用优惠券COUPON123时，两个请求都可能通过验证。"]
  

• 生产者 (v2 - 开发者 + v1 反馈)： 收到反馈。重写了数据库逻辑，使用了SELECT ... FOR UPDATE的数据库行锁来确保原子性，并编写了模拟并发请求的 Pytest 测试用例。

• 评论者 (v2 - 测试器)：

• "status": "APPROVED"
  

• "critique": ["所有单元测试通过，包括并发测试。"]
  

• 好处： 生成了生产级别的、健壮的代码，而不是一个充满漏洞的“玩具”代码。

3. 复杂问题解决（多步推理）

• 场景： AI 智能体解决一个物流优化问题：“我需要在明天下午 5 点前，将一个包裹从 A 市送到 D 市，成本最低。有卡车（慢/便宜）、火车（中/中）和飞机（快/贵）三种选项。”

• 约束： 时间、成本。

• 反思流程：

• 生产者 (v1 - 规划师)： “方案 1：全程卡车。A -> B (4h), B -> C (8h), C -> D (10h)。总时长：22h。总成本：$100。”

• 评论者 (v1 - 约束检查器)：

• "status": "REJECTED"
  

• "critique": ["方案失败：总时长22小时。如果现在是下午1点，22小时后是明天上午11点，符合时间要求。成本$100。这是一个有效的方案，但你是否检查了其他选项以确保‘成本最低’？请尝试其他组合。"]
  

• 生产者 (v2 - 规划师 + v1 反馈)： “收到。尝试混合方案。方案 2：卡车 (A->B, 4h)，转火车 (B->C, 5h)，转卡车 (C->D, 10h)。总时长：19h。总成本：$250。”

• 评论者 (v2 - 约束检查器)：

• "status": "REJECTED"
  

• "critique": ["方案2成本高于方案1，不是最优解。请探索飞机选项。"]
  

• 生产者 (v3)： “方案 3：飞机 (A->D)。总时长：3h。总成本：$500。方案4：卡车(A->C,12h)，转飞机(C->D,1h)。总时长：13h。总成本：$350。”

• 评论者 (v3)：

• "status": "APPROVED"
  

• "critique": ["在所有有效方案（方案1、2、3、4）中，方案1（全程卡车）的总成本$100为最低，且满足时间约束。最终推荐方案1。"]
  

• 好处： 增强了智能体在复杂问题空间中的“探索”和“回溯”能力，确保找到最优解，而不只是第一个“可行解”。

4. 摘要和信息综合

• 场景： 一位金融分析师要求 AI 智能体“总结这份 100 页的上市公司年报，重点关注‘风险’和‘未来展望’”。

• 约束： 摘要必须准确反映原文，不得遗漏关键风险点。

• 反思流程：

• 生产者 (v1 - 摘要生成器)： 生成了一份流畅的摘要，重点提到了市场增长和新产品线（未来展望），但对“风险”部分一带而过。

• 评论者 (v1 - 事实核查员)：

• "status": "INCOMPLETE"
  

• "critique": ["‘未来展望’部分总结得很好。但是，‘风险’部分严重遗漏。原文第78页明确提到了‘供应链高度依赖单一供应商’和‘正在进行的监管调查’。这些关键风险必须在摘要中体现。"]
  

• 生产者 (v2 - 摘要生成器 + v1 反馈)： 收到反馈。重写了摘要，将“风险”部分提升到同等重要的位置，并明确指出了“供应链依赖”和“监管调查”这两个关键点。

• 评论者 (v2 - 事实核查员)：

• "status": "ACCURATE"
  

• "critique": ["摘要现已准确、完整地反映了原文中的关键风险和展望。"]
  

• 好处： 生成了高保真、高价值的摘要，避免了因“报喜不报忧”的 AI 幻觉而导致的灾难性决策失误。

5. 规划和策略（与目标监控结合）

• 场景： 一个自主 AI 智能体，目标是“帮我预订下周五去纽约的旅行，要求入住万豪旗下酒店，预算 $1000”。

• 约束： 日期、地点、品牌偏好、总预算。

• 反思流程（持续进行）：

• 生产者 (v1 - 规划)： “计划：1. 搜机票。2. 搜酒店。3. 预订。”

• 评论者 (v1 - 策略师)：

• "critique": ["计划过于简单。在预订前必须增加‘成本核算’和‘用户确认’步骤。"]
  

• 生产者 (v2 - 规划)： “新计划：1. 搜机票。2. 搜酒店。3. 组合最佳方案并核算总价。4. 向用户呈现实时方案。5. 根据用户确认进行预订。”

• （执行计划 1） 生产者（执行）： “找到机票，往返 $450。”

• （执行计划 2） 生产者（执行）： “找到万豪酒店，每晚$300，共2晚，$600。”

• （执行计划 3） 生产者（核算）： “总成本：$450+$600 = $1050。”

• 评论者 (v2 - 目标监控器)：

• "status": "VIOLATION"
  

• "critique": ["总成本$1050，超出$1000的预算。计划失败。"]
  

• 生产者 (v3 - 重新规划)： “收到。必须降低成本。回溯到步骤 2。新计划：a. 搜索更便宜的万豪旗下酒店（如 Courtyard 或 Fairfield）。b. 如果仍然超支，回溯到步骤 1，搜索更便宜的航班（如红眼航班）。”

• 好处： 智能体不再是盲目执行者，而是成为一个有目的的、自主适应的系统，能通过反思不断纠正自己以逼近最终目标。

6. 具备记忆的对话智能体

• 场景： 一个 AI 心理健康助手，用户在进行长达数周的对话。

• 约束： 必须保持上下文连贯，记住用户的偏好和过去的痛点，避免重复提问。

• 反思流程（实时、基于记忆）：

• 用户： “我今天感觉又和上个月一样糟糕了。”

• 生产者 (v1 - 初稿)： “很遗憾听到你感觉不适。你能详细说说发生了什么吗？”（这是一个通用的、无记忆的回答）

• 评论者 (v1 - 记忆检索与连贯性检查器)：

• "status": "REJECTED"
  

• "critique": ["回答缺乏同理心和上下文。**检索对话记忆发现**：‘上个月’用户提到了‘工作压力’和‘项目截止日期’。当前的回答像是第一次对话，会破坏信任。"]
  

• 生产者 (v2 - 优化稿 + v1 反馈)： “收到你的感受。我记得上个月你提到过类似的感觉，当时似乎与‘工作压力’和‘项目截止日期’有关。你觉得这次也和那些因素有关吗？还是有新的情况出现？”

• 好处： 反思与记忆的结合，使智能体从一个“无状态”的聊天机器人转变为一个“有状态”的、真正理解并关心用户的“伙伴”。

五、实战示例 (LangChain)：构建“代码迭代优化器”

要实现完整的迭代反思，我们需要状态管理和循环执行。虽然 LangGraph 这样的图框架是原生支持循环的，但我们可以用一个清晰的 Python for 循环和 LCEL（LangChain 表达式语言）来演示反思模式的核心—— “生成-评审-改进” 的循环。

本示例将实现一个 AI，它迭代地生成并优化一个计算阶乘的 Python 函数，直到“评论者”满意为止。

import osfrom dotenv import load_dotenvfrom langchain_openai import ChatOpenAIfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_core.messages import SystemMessage, HumanMessage
# --- 0. 配置 ---# pip install langchain langchain-community langchain-openai dotenvload_dotenv()
# 检查 API 密钥if not os.getenv("OPENAI_API_KEY"):    raise ValueError("OPENAI_API_KEY 未在 .env 文件中找到。")
# 初始化LLM。我们使用一个强大的模型（如gpt-4o）来进行推理# 低温（temperature=0.1）确保输出更稳定、更具确定性try:    llm = ChatOpenAI(model="gpt-4o", temperature=0.1)    print("ChatOpenAI (gpt-4o) 初始化成功。")except Exception as e:    print(f"初始化LLM失败: {e}")    exit()

def run_reflection_loop():    """    演示一个多步骤的AI反思循环，以逐步改进一个Python函数。    """
    # --- 核心任务：定义我们想要什么 ---    task_prompt = """    你的任务是创建一个名为 `calculate_factorial` 的Python函数。    该函数必须满足以下所有要求：    1.  接受一个整数 `n` 作为输入。    2.  计算其阶乘 (n!)。    3.  包含清晰的文档字符串 (docstring)，解释其功能、参数和返回值。    4.  正确处理边界情况：0 的阶乘是 1。    5.  处理无效输入：如果输入是负数，必须引发 `ValueError`。    6.  处理无效输入：如果输入不是整数（例如浮点数或字符串），必须引发 `TypeError`。    """
    # --- 反思循环设置 ---    max_iterations = 4  # 设置一个上限，防止无限循环    current_code = "" # 存储当前的代码版本
    # 我们将构建一个对话历史记录，为每一步提供完整的上下文。    # 这是实现“记忆”和“迭代改进”的关键。    message_history = [        # 初始提示，定义了“生产者”的角色        SystemMessage(content="你是一个Python编程专家。请根据以下要求生成代码。"),        HumanMessage(content=task_prompt)    ]
    for i in range(max_iterations):        print("\n" + "=" + f" 反思循环：第 {i + 1} 次迭代 " + "=")
        # --- 1. 生产者阶段 (生成 / 优化) ---        # 第一次迭代是“生成”，后续迭代是“优化”。        if i == 0:            print("\n>>> 阶段 1: [生产者] 正在生成初始代码...")            # 第一次调用：message_history 只包含系统提示和任务提示            response = llm.invoke(message_history)            current_code = response.content        else:            print("\n>>> 阶段 1: [生产者] 正在根据上一轮的评审意见优化代码...")            # 告诉生产者利用历史记录中的评审意见            message_history.append(HumanMessage(content="""                请仔细阅读上一轮的评审意见（Critique），                并生成一个 *完整* 的新版本代码来解决 *所有* 提到的问题。            """))            response = llm.invoke(message_history)            current_code = response.content                # 将生产者的最新输出（代码）添加到历史记录中        message_history.append(response)         print(f"\n--- [生产者] 生成的代码 (v{i + 1}) ---\n{current_code}")

        # --- 2. 评论者阶段 (反思 / 评估) ---        print("\n>>> 阶段 2: [评论者] 正在评审生成的代码...")
        # 这是关键：我们创建了一个不同的提示，定义了“评论者”的角色。        # 这是一个临时的调用，不会污染我们的主 message_history        reflector_prompt_messages = [            SystemMessage(content="""                你是一名资深软件工程师和Python代码审查专家。                你的唯一角色是严格地审查所提供的代码。                请根据原始任务要求，批判性地评估Python代码。                                检查：                1.  是否满足所有功能要求？                2.  是否正确处理了所有边界情况（0）？                3.  是否正确处理了所有无效输入（负数、非整数）？                4.  文档字符串是否清晰且完整？                5.  代码风格是否良好？                                如果代码完美无缺并满足所有要求，请只回答 `CODE_IS_PERFECT`。                否则，请提供一个清晰、简洁、可操作的要点列表（bulleted list），指出 *必须* 修正的问题。            """),            # 传入原始任务和当前代码供评审            HumanMessage(content=f"原始任务:\n{task_prompt}\n\n需要评审的代码:\n{current_code}")        ]
        critique_response = llm.invoke(reflector_prompt_messages)        critique = critique_response.content
        # --- 3. 停止条件检查 ---        if "CODE_IS_PERFECT" in critique:            print("\n--- [评论者] 评审意见 ---\n评审通过。代码已满足所有要求。")            break # 成功！退出循环                print(f"\n--- [评论者] 评审意见 ---\n{critique}")                # 如果未达到最大迭代次数，将评审意见加入历史记录，用于下一次循环        if i < max_iterations - 1:            message_history.append(HumanMessage(content=f"对上一版代码的评审意见:\n{critique}"))        else:            print("\n" + "=" + " 达到最大迭代次数 " + "=")            print("循环停止。")
    print("\n" + "=" + " 最终结果 " + "=")    print("\n反思流程结束后的最终代码：\n")    print(current_code)

if __name__ == "__main__":    run_reflection_loop()

代码执行追踪（假设的输出）

第 1 次迭代：

• [生产者] 生成了 v1 代码。

• （代码可能实现了阶乘，但忘记了处理负数和类型错误）

• [评论者] 评审 v1。

• 评审意见："- 必须使用 raise ValueError 处理负数。 - 未处理非整数输入（如 calculate_factorial(3.5)），应引发 TypeError。"

第 2 次迭代：

• [生产者] 收到评审意见，生成 v2 代码。

• （代码添加了 if n < 0: raise ValueError，但仍然忘记了 TypeError）

• [评论者] 评审 v2。

• 评审意见："- 很好，已处理负数。 - 仍然未处理非整数输入。请在函数开头添加 if not isinstance(n, int): raise TypeError。"

第 3 次迭代：

• [生产者] 收到评审意见，生成 v3 代码。

• （代码现在包含了所有要求：文档字符串、0 的处理、ValueError、TypeError）

• [评论者] 评审 v3。

• 评审意见：CODE_IS_PERFECT
  

循环停止。 最终代码是 v3。

六、实战示例 (Google ADK)：构建“文稿-审查”管道

现在，我们来看一个使用 Google Agent Development Kit (ADK) 实现“生产者-评论者”架构的示例。ADK 非常适合这种模式，因为它天生就是基于“智能体”的，并且通过SequentialAgent（顺序智能体）来编排流程。

这个例子展示了一个单次反思循环（非迭代），即“生成”然后“审查”。

# 假设这是 ADK 配置文件（如 agent.py）的一部分from google.adk.agents import SequentialAgent, LlmAgent
# --- 1. 定义 生产者 智能体 ---# 它的任务是生成初始草稿
generator = LlmAgent(    name="DraftWriter",    description="根据给定主题生成初始内容草稿。",    instruction="""你是一个富有创造力的作家。    根据用户的主题，撰写一段简短（约100字）、信息量丰富的段落。    你的重点是速度和创意，而不是完美。    """,    # 关键：ADK 通过 output_key 来管理状态    # 它的输出（草稿）将被保存到会话状态的 'draft_text' 键中    output_key="draft_text" )
# --- 2. 定义 评论者 智能体 ---# 它的任务是评估生产者的草稿
reviewer = LlmAgent(    name="FactChecker",    description="审查给定文本的事实准确性，并提供结构化的评审。",    instruction="""    你是一名一丝不苟的事实核查员。    1.  请读取在状态键 'draft_text' 中提供给你的文本。    2.  仔细核实文本中所有声明的事实准确性。    3.  你的最终输出 *必须* 是一个字典，包含两个键：        - "status": 一个字符串，必须是 "ACCURATE"（准确）或 "INACCURATE"（不准确）。        - "reasoning": 一个字符串，为你给出的状态提供清晰的解释，如果发现问题，请具体指出。    """,    # 它的输出（评审结果字典）将被保存到 'review_output' 键中    output_key="review_output" )
# --- 3. 定义 顺序管道 (协调器) ---# SequentialAgent 确保了智能体按特定顺序执行
review_pipeline = SequentialAgent(    name="WriteAndReview_Pipeline",    description="一个两步管道：首先撰写草稿，然后进行事实核查。",    # 列表中的顺序至关重要    sub_agents=[        generator,  # 第 1 步：运行生产者        reviewer    # 第 2 步：运行评论者    ])
# --- 执行流程 ---# 当 review_pipeline 运行时：# 1. 'generator' 首先运行。# 2. 它生成段落，并将其保存到 state['draft_text']。# 3. 'reviewer' 随后运行。# 4. 它从 state['draft_text'] 读取该段落。# 5. 它生成评审字典，并将其保存到 state['review_output']。## 提示：要实现 *迭代* 反思（如LangChain示例），# 可以将这个 SequentialAgent 包装在 ADK 的 "LoopAgent" 中，# 该循环的退出条件是 state['review_output']['status'] == "ACCURATE"。

ADK 示例解析

• 状态管理 (output_key)： 这是 ADK 中智能体间通信的核心。generator 将其输出“广播”到名为 draft_text 的共享状态中。

• 信息流： reviewer 的提示明确指示它从状态中读取 draft_text。这演示了 ADK 如何将智能体松散地耦合在一起——reviewer 并不“知道”generator 的存在，它只关心 draft_text 这个状态键。

• 结构化输出： reviewer 被要求输出结构化的字典。这是一种极其健壮的实践，因为它使得后续的智能体（比如一个 LoopAgent 或一个“最终决策者”）可以轻易地解析"status"键并采取程序化行动，而不是去猜测自然语言的含义。

• 可扩展性： 这个管道非常容易扩展。你可以轻松地在 generator 和 reviewer 之间添加另一个 LlmAgent，比如 StyleEditor（风格编辑器），它负责在事实核查之前先润色文笔。

七、反思的代价：重要的权衡

反思模式虽然强大，但绝不是“银弹”。它带来了显著的成本和权衡，你必须在“质量”和“效率”之间做出明智的选择。

1. 延迟（Latency）- 最大的敌人

反思是有代价的，这个代价就是时间。

• 一个简单的链： 1 次 LLM 调用 = 3 秒延迟。

• 一个反思循环（3 次迭代）：

• (生产者 v1: 3 秒) + (评论者 v1: 3 秒) = 6 秒

• (生产者 v2: 3 秒) + (评论者 v2: 3 秒) = 6 秒

• (生产者 v3: 3 秒) + (评论者 v3: 3 秒) = 6 秒

• 总延迟： 18 秒（甚至更多，因为提示更长了）。

经验法则：

• 高延迟可接受（异步任务）： 撰写报告、生成代码、发送营销邮件。（适合反思）

• 低延迟要求（实时交互）： 聊天机器人、实时问答、UI 操作。（不适合多重迭代反思）

2. 成本（Cost）

显而易见，每次迭代（包括生产者和评论者的调用）都是一次完整的 LLM 调用。3 次迭代的成本至少是简单链的 6 倍（3 次生产 + 3 次评审）。

3. 内存与上下文窗口（Context Window）

正如我们的 LangChain 示例所示，迭代反思依赖于不断增长的会话历史（message_history）。[任务 + v1代码 + v1评审 + v2代码 + v2评审 + v3代码...]这个历史记录会迅速膨胀。在三四次迭代后，你可能会轻易地超出模型的上下文窗口限制（即使是像 GPT-4o 的 128k），导致 API 错误或性能下降（模型在“大海捞针”）。

4. 风险：卡死、振荡与过度修正

• 卡死（Stuck Loop）： 如果生产者的能力不足以修复评论者提出的问题，它们可能会陷入死循环。

• 振荡（Oscillation）： 如果你有两个评论者，它们的标准相互冲突（例如，评论者 A：“太啰嗦了，删掉！” 评论者 B：“太简洁了，补充细节！”），智能体可能会在两个极端之间来回摆动，永远无法收敛。

• 过度修正（Over-Correction）： 有时，“第一稿”的创意火花是最好的。过度、机械的评审可能会磨灭掉所有的创造力，产生一篇“正确”但“无聊”的最终稿。

八、结语：从“执行”到“思考”

反思模式为智能体的工作流提供了至关重要的自我修正手段。它标志着智能体从一个简单的“指令执行者”向一个“质量保障者”的转变。

通过引入“生产者-评论者”这一强大的架构，我们使智能体能够系统地评估自己的工作，发现缺陷，并迭代改进。这种“生成-评审-改进”的循环是人类创造高质量工作（无论是写代码、写文章还是做研究）的核心过程。

是的，反思是有成本的——它需要更多的时间、更多的计算资源和更复杂的状态管理。但对于那些质量、准确性和可靠性压倒一切的任务而言，反思模式不仅是值得的，更是不可或缺的。

掌握了反思，我们的智能体系统才真正开始具备一种初级的“元认知”能力，不再只是盲目地“做”，而是开始学会“思考”。

参考资料

1. LangChain 文档: https://python.langchain.com/v0.2/docs/core_modules/expression_language/

2. LangGraph 文档: https://langchain-ai.github.io/langgraph

3. Google ADK 文档: https://google.github.io/adk-docs

4. Antonio Gulli 《Agentic Design Patterns》