返回专栏
· 25 分钟阅读

Reflection:反思与自我修正机制


一、Reflection 的核心概念

Reflection(反思)是指 Agent 对自身的推理过程、行动结果和任务完成情况进行评估,并根据评估结论修正后续行为的能力。

传统 LLM 调用通常采用一次性生成模式:

  • 接收用户输入。
  • 生成回答或执行计划。
  • 返回结果。

这种模式缺乏对结果的主动验证能力。模型可能产生错误推理、调用错误工具、遗漏关键步骤,甚至在任务失败后重复相同操作。

Reflection 在 Agent 执行过程中引入反馈与自我评估机制,使 Agent 不仅能够执行任务,还能够判断执行是否有效。

1.1 核心能力

能力 说明
结果评估 判断当前输出是否满足任务目标
错误识别 发现事实错误、逻辑错误和执行错误
原因分析 定位失败发生的原因,而不只是识别失败现象
策略修正 修改推理路径、工具选择或执行计划
再次执行 根据修正后的策略重新执行任务
停止判断 判断是否达到目标,避免无意义循环

1.2 Reflection 与普通推理的区别

维度 普通推理 Reflection
核心目标 生成解决方案 评估并改进解决方案
输入 用户任务和上下文 原始任务、执行过程和执行结果
关注重点 如何完成任务 是否完成任务、哪里存在问题
错误处理 可能直接输出错误结果 尝试识别并修正错误
执行模式 单轮或连续推理 评估、反馈、修正、再执行
终止依据 生成完成 质量达标或达到停止条件

需要注意:Reflection 不等于模型简单地重新思考一次。

真正有效的 Reflection 必须建立在可验证的反馈信息之上,并且能够将评估结果转化为具体的行为调整。


二、Reflection 的整体架构

Reflection 通常作为 Agent 执行循环中的一个独立环节,与 Planner、Executor、Tool、Memory 等模块协同工作。

2.1 核心架构

flowchart TD
    A["用户任务"] --> B["Planner 任务规划"]
    B --> C["Executor 执行任务"]
    C --> D["获取执行结果"]
    D --> E["Reflection 结果评估"]
    E --> F{"是否达到目标"}
    F -->|"是"| G["输出最终结果"]
    F -->|"否"| H["错误分析"]
    H --> I["生成修正策略"]
    I --> J["更新执行计划"]
    J --> C

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49

核心执行链路:

  1. Planner 根据用户任务生成执行计划。
  2. Executor 按照计划调用工具或执行操作。
  3. 系统收集执行结果、工具返回值和中间状态。
  4. Reflection 对结果进行评估。
  5. 如果任务未达标,分析错误并生成修正策略。
  6. 将修正策略反馈给 Planner 或 Executor。
  7. 重新执行,直到满足目标或触发终止条件。

2.2 Reflection 的模块划分

模块 主要职责 输出
Evaluator 评估任务执行质量 评估结果
Critic 识别缺陷与错误 问题列表
Analyzer 分析错误原因 根因分析
Reflector 生成反思结论 反思记录
Strategy Updater 修正后续执行策略 新执行策略
Controller 控制循环次数和停止条件 控制决策

实际工程中,这些模块不一定由独立模型实现。可以通过同一个 LLM 的不同提示词、独立评估模型、规则引擎或外部验证器实现。


三、Reflection 的核心工作机制

Reflection 的关键不是重新生成答案,而是将执行结果转化为可操作的反馈。

3.1 第一步:建立评估标准

Agent 在执行任务前,需要明确什么样的结果才算成功。

如果没有明确的评估标准,Reflection 就容易变成主观评价,例如:

  • 回答是否看起来合理?
  • 代码是否看起来正确?
  • 方案是否比较完整?

这些判断缺乏可靠性。

因此,应该将任务目标拆解为可检查的验收条件。

例如,用户要求开发一个 REST API:

验收维度 检查条件
功能正确性 API 是否实现指定业务功能
参数校验 是否处理非法参数
返回格式 是否符合约定的数据结构
异常处理 是否覆盖常见异常
安全性 是否处理认证和权限问题
测试覆盖 是否通过关键测试用例

可以将验收标准表示为:

{
  "task": "开发用户查询接口",
  "criteria": [
    {
      "name": "功能正确性",
      "check": "返回指定用户信息",
      "weight": 0.35
    },
    {
      "name": "参数校验",
      "check": "非法用户 ID 返回明确错误",
      "weight": 0.20
    },
    {
      "name": "异常处理",
      "check": "用户不存在时返回约定状态码",
      "weight": 0.20
    },
    {
      "name": "测试通过",
      "check": "核心测试用例全部通过",
      "weight": 0.25
    }
  ]
}

验收条件应尽可能在执行前确定,避免模型在执行失败后随意降低成功标准。

3.2 第二步:收集执行证据

Reflection 不能只依赖最终回答,还需要收集完整的执行上下文。

典型数据包括:

  • 原始任务目标。
  • 当前执行计划。
  • 模型生成的推理摘要。
  • 工具调用记录。
  • 工具返回结果。
  • 中间状态。
  • 最终输出。
  • 外部验证结果。
  • 执行耗时和资源消耗。

可以将执行过程抽象为:

{
  "task_id": "task_001",
  "goal": "完成用户查询接口",
  "plan": [
    "设计接口",
    "实现业务逻辑",
    "添加参数校验",
    "执行测试"
  ],
  "actions": [
    {
      "tool": "code_executor",
      "operation": "run_tests",
      "status": "success",
      "output": "8 passed, 1 failed"
    }
  ],
  "result": {
    "status": "partial_success",
    "completed_steps": 3,
    "failed_steps": 1
  }
}

这里有一个重要原则:

执行记录与模型对执行记录的解释必须分开存储。

例如,工具返回测试失败是客观事实;模型判断失败原因是参数校验遗漏,则属于分析结论。

两者不能混为一谈。

3.3 第三步:执行质量评估

Evaluator 根据验收标准和执行证据,对任务结果进行评价。

常见评估方式包括:

1. 规则评估

通过确定性规则判断结果是否符合要求。

例如:

  • HTTP 状态码是否正确。
  • JSON 字段是否完整。
  • 测试是否全部通过。
  • 文件是否存在。
  • 数据库记录是否成功写入。

优点是稳定、成本低、结果可复现。

缺点是只能覆盖明确编码的规则。

2. 模型评估

使用 LLM 判断结果是否满足任务要求。

适用于:

  • 自然语言质量评估。
  • 方案合理性分析。
  • 复杂逻辑审查。
  • 文档完整性检查。
  • 多维度语义比较。

缺点是可能存在评估偏差、幻觉和自我偏好。

3. 外部评估

使用独立系统提供验证结果。

例如:

  • 单元测试。
  • 集成测试。
  • 静态代码分析。
  • 数据库查询。
  • API 实际调用。
  • 搜索结果核验。
  • 人工审核。

外部评估通常比单纯的模型自我判断更可靠。

4. 混合评估

实际工程中通常组合多种方式:

flowchart TD
    A["执行结果"] --> B["规则评估"]
    A --> C["LLM 语义评估"]
    A --> D["外部工具验证"]
    B --> E["评估结果融合"]
    C --> E
    D --> E
    E --> F{"是否通过验收"}
    F -->|"通过"| G["确认任务完成"]
    F -->|"未通过"| H["进入错误分析"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438

3.4 第四步:识别问题并分析根因

发现任务失败后,不能直接重新执行,而应该判断失败发生在哪里。

常见错误类型:

错误类型 典型表现 可能原因
目标理解错误 完成的不是用户要求的任务 意图识别不准确
规划错误 执行顺序不合理 依赖关系分析错误
推理错误 结论与事实不符 前提错误或逻辑跳跃
工具选择错误 调用了不合适的工具 工具能力理解错误
工具执行错误 API 调用失败 参数错误、权限不足
数据错误 使用了过期或错误数据 检索质量不足
上下文错误 遗漏关键约束 上下文管理不完整
验证错误 错误结果被判定为成功 验收标准不充分

根因分析应区分三个层次:

  • 现象:发生了什么。
  • 直接原因:为什么出现这个现象。
  • 根本原因:哪个系统环节导致直接原因发生。

例如:

现象:
    单元测试失败。

直接原因:
    接口返回字段缺失。

根本原因:
    Planner 没有将返回字段要求纳入执行计划。

修正方向:
    补充接口契约约束,并增加响应结构验证。

如果只修复直接原因,而不修正根本原因,类似问题可能在下一次执行中再次出现。

3.5 第五步:生成修正策略

根因分析完成后,Reflection 需要生成具体、可执行的修正方案。

修正策略可以分为:

修正类型 处理方式
目标修正 重新明确任务约束
计划修正 调整任务步骤和依赖关系
推理修正 重新检查前提与逻辑
工具修正 更换工具或调整调用参数
数据修正 重新检索、校验或更新数据
验证修正 增加检查项或修改验收流程
上下文修正 补充缺失信息

修正策略应具备明确的执行动作,而不是模糊的自我评价。

不推荐:

需要更加仔细地检查代码。

推荐:

1. 检查用户查询接口的响应结构。
2. 补充缺失的 user_id 和 created_at 字段。
3. 增加响应结构断言。
4. 重新执行相关单元测试。

3.6 第六步:再次执行并验证

修正策略必须反馈到执行系统,而不是只生成一段反思文本。

flowchart TD
    A["收到修正策略"] --> B["更新执行计划"]
    B --> C["重新执行失败步骤"]
    C --> D["收集新执行结果"]
    D --> E["重新评估"]
    E --> F{"是否满足验收标准"}
    F -->|"是"| G["结束任务"]
    F -->|"否"| H{"是否还有重试预算"}
    H -->|"有"| I["进一步分析问题"]
    I --> B
    H -->|"没有"| J["终止并报告失败"]

    style A fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438

并不是所有任务都需要从头执行。

更合理的方式是定位失败步骤,只重新执行受影响的部分,同时保留已经验证通过的结果。


四、Reflection 的关键技术机制

4.1 自我评估与 Critic 机制

Critic 是 Reflection 中负责审查结果的核心角色。

它需要从任务目标、事实准确性、逻辑一致性、约束满足情况和执行质量等角度进行评价。

典型的 Critic Prompt:

你是一个独立的任务质量评估器。

请根据原始任务和验收标准,审查 Agent 的执行结果。

评估要求:
1. 不要默认 Agent 的结果正确。
2. 逐项检查验收标准。
3. 区分事实错误、逻辑错误和执行错误。
4. 必须引用执行证据。
5. 不确定的问题标记为 unknown。
6. 给出具体、可执行的修正建议。

输出 JSON:
{
  "passed": false,
  "score": 0.72,
  "issues": [
    {
      "type": "missing_requirement",
      "description": "缺少用户创建时间字段",
      "evidence": "实际响应中不存在 created_at",
      "severity": "high"
    }
  ],
  "root_cause": "接口响应契约未完整纳入执行计划",
  "suggestions": [
    "补充 created_at 字段",
    "增加响应结构测试"
  ]
}

Critic 的关键不是给出一个分数,而是提供有证据支持的问题定位。

4.2 自我修正与策略更新

Self-Correction(自我修正)是 Reflection 的后续行动阶段。

二者关系:

  • Reflection:发现问题并形成反思结论。
  • Self-Correction:根据反思结论修改执行行为。

常见修正对象:

  1. Prompt:补充约束和执行要求。
  2. Plan:修改任务分解和步骤依赖。
  3. Tool:更换工具或修正调用参数。
  4. Context:补充缺失的事实和历史信息。
  5. Code:修改错误代码。
  6. Memory:记录经过验证、值得复用的经验。

这里需要特别注意:修改执行计划和修改模型参数不是同一件事。

大多数 Agent 的自我修正发生在推理上下文、执行计划和外部状态层面,并不会直接更新基础模型权重。

4.3 反思记录与经验复用

如果每次任务完成后都只保留最终结果,Agent 很难积累有效经验。

可以将反思结论结构化保存:

{
  "reflection_id": "reflection_001",
  "task_type": "api_development",
  "failure_type": "missing_requirement",
  "observation": "响应中缺少 created_at 字段",
  "root_cause": "接口契约未完整纳入计划",
  "correction": "增加响应字段清单和结构测试",
  "verification": "相关测试全部通过",
  "confidence": 0.95,
  "reusable": true
}

后续遇到相似任务时,可以检索相关反思记录,提前规避已经发生过的问题。

需要注意:

  • 不要将未经验证的推测直接写入长期记忆。
  • 不要将单次任务的偶然经验泛化为通用规则。
  • 记录经验时应保留适用条件和来源。
  • 对过期经验应支持更新、失效和删除。

五、Reflection 的主要实现模式

Reflection 并不是单一固定算法,根据任务复杂度和执行成本,可以采用不同模式。

5.1 单轮 Reflection

执行一次任务,然后进行一次评估和修正。

flowchart TD
    A["输入任务"] --> B["生成结果"]
    B --> C["执行评估"]
    C --> D{"是否达标"}
    D -->|"是"| E["输出结果"]
    D -->|"否"| F["生成修正建议"]
    F --> G["修正结果"]
    G --> H["再次验证"]
    H --> I["输出最终结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

特点:

  • 实现简单。
  • 调用次数可控。
  • 适合短文本、简单代码和结构化输出。
  • 无法充分处理复杂的多阶段任务。

5.2 多轮 Reflection

Agent 在多轮执行中不断评估和修正,直到满足验收标准或达到最大迭代次数。

flowchart TD
    A["任务输入"] --> B["执行任务"]
    B --> C["质量评估"]
    C --> D{"是否达到目标"}
    D -->|"是"| E["任务完成"]
    D -->|"否"| F["分析失败原因"]
    F --> G["调整执行策略"]
    G --> H{"是否超过迭代上限"}
    H -->|"否"| B
    H -->|"是"| I["终止并返回当前结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438

特点:

  • 能够处理复杂问题。
  • 支持逐步修正。
  • 可以根据反馈动态调整执行路径。
  • 需要控制迭代次数、Token 消耗和执行时间。

多轮 Reflection 并不意味着循环次数越多越好。如果每一轮都没有引入新的证据或有效策略,继续反思只会增加成本。

5.3 外部反馈驱动的 Reflection

该模式不完全依赖 LLM 自我判断,而是通过外部系统提供客观反馈。

例如代码开发 Agent:

  • 代码生成模型负责实现。
  • 编译器负责语法检查。
  • 单元测试负责功能验证。
  • 静态分析工具负责代码质量检查。
  • Reflection 负责解释失败原因并修正实现。
flowchart TD
    A["生成代码"] --> B["编译器检查"]
    B --> C{"编译是否通过"}
    C -->|"否"| F["Reflection 分析编译错误"]
    C -->|"是"| D["执行单元测试"]
    D --> E{"测试是否通过"}
    E -->|"是"| G["静态分析"]
    E -->|"否"| F
    F --> H["生成修正方案"]
    H --> A
    G --> I{"质量是否达标"}
    I -->|"是"| J["交付代码"]
    I -->|"否"| F

    style A fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这种模式的可靠性通常更高,因为评估结果能够通过外部工具验证。

5.4 跨步骤 Reflection

复杂 Agent 任务通常由多个子任务组成。

如果某个步骤失败,Agent 不一定需要重新执行整个任务,而是需要分析失败对后续步骤的影响。

例如:

任务:
    生成业务分析报告。

子任务:
    1. 获取业务数据。
    2. 清洗数据。
    3. 统计指标。
    4. 分析趋势。
    5. 生成报告。

如果第三步统计指标出现错误,可能需要重新执行第四步和第五步,但不一定需要重新获取数据。

这就要求 Reflection 具备:

  • 子任务依赖关系识别。
  • 失败影响范围分析。
  • 中间结果有效性判断。
  • 局部重试和结果复用能力。

六、Reflection 的高级机制

6.1 Reflection 与 ReAct 的结合

ReAct 通过 Reasoning 和 Acting 交替完成任务。

Reflection 在 ReAct 的执行链路中增加结果评估和策略修正能力。

二者区别:

维度 ReAct Reflection
核心机制 推理与行动交替 结果评估与自我修正
关注对象 当前应该采取什么行动 已执行行动是否有效
反馈来源 工具观察结果 任务目标、执行轨迹和验证结果
主要作用 推动任务执行 提升执行质量
典型场景 工具调用、信息检索 纠错、验证、迭代优化

二者结合后,Agent 可以在每次重要行动后检查结果,并在必要时调整下一步行动。

flowchart TD
    A["接收任务"] --> B["Reason 推理"]
    B --> C["Act 执行动作"]
    C --> D["Observe 获取观察结果"]
    D --> E["Reflection 评估"]
    E --> F{"当前执行是否合理"}
    F -->|"是"| G{"任务是否完成"}
    G -->|"否"| B
    G -->|"是"| H["输出结果"]
    F -->|"否"| I["分析错误"]
    I --> J["修正执行策略"]
    J --> B

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D

6.2 Reflection 与 Memory 的结合

Reflection 产生的经验可以被写入 Agent Memory,供后续任务使用。

但需要区分两类数据:

任务级反思记录

用于当前任务的修正,例如当前代码存在什么问题、哪一步执行失败。

长期经验记忆

用于后续相似任务,例如某种 API 调用方式容易出现参数错误,某类任务需要增加额外验证。

二者不能无条件混合。

推荐的经验沉淀流程:

flowchart TD
    A["Reflection 产生结论"] --> B["提取候选经验"]
    B --> C["检查证据充分性"]
    C --> D{"是否经过验证"}
    D -->|"否"| E["保留为临时记录"]
    D -->|"是"| F["评估复用价值"]
    F --> G{"是否值得长期保存"}
    G -->|"否"| H["归档或丢弃"]
    G -->|"是"| I["去重与冲突检查"]
    I --> J["写入长期记忆"]
    J --> K["后续任务检索复用"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

长期记忆的写入应该经过质量控制,否则 Agent 可能把错误判断固化成长期经验,导致后续任务持续受到错误记忆影响。

6.3 Reflection 与 Planning 的结合

Planner 负责生成任务计划,Reflection 负责判断计划是否有效。

二者形成动态规划机制:

  • 初始计划由 Planner 生成。
  • Executor 执行当前计划。
  • Reflection 评估执行结果。
  • 如果计划本身存在缺陷,则要求 Planner 重新规划。
  • 如果计划正确但执行失败,则优先修正执行步骤。

这里有一个重要区别:

执行错误不一定意味着计划错误。

例如:

  • API 超时:可能是临时网络问题。
  • API 参数错误:可能是工具调用问题。
  • 任务依赖关系错误:才更可能属于规划问题。

如果将所有失败都反馈给 Planner 重新规划,会造成不必要的计划变更。

6.4 多 Agent Reflection

在多 Agent 架构中,可以让不同 Agent 分别承担执行、评估和审查职责。

例如:

Agent 职责
Planner Agent 制定任务计划
Executor Agent 执行任务
Critic Agent 独立评估执行结果
Reviewer Agent 复核重要结论
Controller Agent 控制任务状态和重试

多 Agent Reflection 的优势是降低执行者与评估者之间的角色偏差。

但需要注意:

  • 多 Agent 不代表一定更准确。
  • 多个 Agent 可能共享相同模型偏差。
  • 评估意见可能互相冲突。
  • 通信和推理成本会增加。
  • 必须明确最终决策权归属。

对于高风险任务,可以采用独立模型、确定性验证器和人工审批相结合的方式。


七、Reflection 的工程实现

7.1 核心数据结构

生产环境中,Reflection 不应只是一个 Prompt,而应成为具有状态、评估结果和执行记录的工作流模块。

可以设计以下数据结构:

from dataclasses import dataclass, field
from typing import Any


@dataclass
class EvaluationIssue:
    issue_type: str
    description: str
    evidence: str
    severity: str


@dataclass
class EvaluationResult:
    passed: bool
    score: float
    issues: list[EvaluationIssue] = field(
        default_factory=list
    )
    root_cause: str = ""
    suggestions: list[str] = field(
        default_factory=list
    )


@dataclass
class ReflectionRecord:
    task_id: str
    iteration: int
    execution_result: Any
    evaluation: EvaluationResult
    correction_plan: list[str] = field(
        default_factory=list
    )

主要字段:

  • task_id:任务唯一标识。
  • iteration:当前反思轮次。
  • execution_result:执行结果。
  • evaluation:评估结论。
  • correction_plan:修正策略。