反思：智能的分水岭

人类之所以智能，不只是因为我们能做事，更因为我们能反思——做错了会分析原因，做对了会总结经验。AI Agent同样需要反思能力，才能从"执行器"进化为"学习者"。

反思的四个层次

层次一：结果验证

最基本的反思——检查输出是否正确：

任务: "计算 17 × 23"
Agent输出: "391"
反思: "让我验证一下: 17 × 23 = 17 × 20 + 17 × 3 = 340 + 51 = 391 ✓"
结果: 验证通过

层次二：过程审查

检查推理过程是否合理：

任务: "分析销售下降原因"
Agent推理:
  1. 查看销售额数据
  2. 对比去年同期
  3. 发现下降20%
  4. 结论: 经济环境不好

反思:
  "步骤4的因果推理是否充分？
   是否考虑了其他可能原因？
   - 竞争对手动态？
   - 产品质量问题？
   - 营销策略变化？
   我应该补充调查这些因素。"

层次三：策略评估

评估整体策略是否最优：

任务: "开发一个Web应用"
Agent选择: 从零开发前端+后端

反思:
  "回看整个过程，从零开发花了5天。
   如果使用现成的框架（如Next.js），可能2天完成。
   下次类似任务应该先评估有无现成框架。"

层次四：经验抽象

从具体经历中提取通用经验：

经历: 用户连续3次纠正Agent的回答方式
抽象: "当用户多次纠正同一类问题时，说明我的默认行为模式在该场景下不合适。应该记录这类偏好。"

反思机制设计

Reflexion框架

经典的Agent反思框架：

循环:
  1. Act: Agent执行操作
  2. Observe: 观察结果
  3. Evaluate: 评估是否成功
  4. Reflect: 如果失败，分析原因
  5. Plan: 基于反思调整策略
  6. 重复直到成功或达上限

自我评估模块

def self_evaluate(task, result, criteria):
    prompt = f"""
    任务: {task}
    我的输出: {result}
    评估标准: {criteria}
    
    请评估:
    1. 是否完成了任务？(1-5分)
    2. 质量如何？(1-5分)
    3. 有什么不足？
    4. 改进建议？
    """
    return llm.generate(prompt)

经验库

class ExperienceStore:
    def __init__(self):
        self.experiences = []
    
    def add(self, task, approach, outcome, reflection):
        self.experiences.append({
            "task_pattern": extract_pattern(task),
            "approach": approach,
            "outcome": outcome,  # success/failure
            "reflection": reflection,
            "embedding": embed(task + reflection),
            "timestamp": datetime.now()
        })
    
    def retrieve_relevant(self, new_task):
        """检索与新任务相关的过往经验"""
        task_vec = embed(new_task)
        similar = vector_search(task_vec, self.experiences, top_k=3)
        return similar

实现方案

短期反思（会话内）

在任务执行过程中实时反思：

class ReflectiveAgent:
    async def run(self, task):
        max_attempts = 3
        attempts = []
        
        for i in range(max_attempts):
            # 执行
            result = await self.execute(task, previous_reflections=attempts)
            
            # 评估
            evaluation = await self.evaluate(task, result)
            
            if evaluation.success:
                return result
            
            # 反思
            reflection = await self.reflect(task, result, evaluation)
            attempts.append(reflection)
            
            # 记录经验
            self.experience_store.add(task, result, evaluation, reflection)
        
        return None  # 超过最大尝试次数

反思Prompt示例：

之前的尝试失败了。

任务: {task}
我的做法: {approach}
结果: {result}
失败原因: {evaluation}

请反思:
1. 哪一步出了问题？
2. 为什么会犯这个错误？
3. 下次应该怎么做？
4. 有什么通用经验可以提取？

反思: {reflection}

长期反思（跨会话）

跨会话的经验积累和策略改进：

class CrossSessionReflection:
    def __init__(self, experience_db):
        self.db = experience_db
    
    def get_relevant_experiences(self, new_task):
        """从历史经验中检索相关教训"""
        experiences = self.db.search(new_task, top_k=5)
        
        # 生成经验摘要
        summary = llm.generate(f"""
        基于以下过往经验，为当前任务提供建议:
        
        当前任务: {new_task}
        
        过往经验:
        {format_experiences(experiences)}
        
        建议:
        - 哪些方法可能有效？
        - 哪些错误需要避免？
        - 有什么注意事项？
        """)
        return summary

群体反思

多Agent共享经验：

Agent A 的经验 → 共享经验库
Agent B 的经验 → 共享经验库
Agent C ← 读取A和B的经验，避免重复错误

实现：

class SharedExperiencePool:
    def __init__(self):
        self.experiences = []  # 所有Agent共享
        self.patterns = {}      # 任务模式索引
    
    def contribute(self, agent_id, experience):
        """Agent贡献经验"""
        experience["agent_id"] = agent_id
        self.experiences.append(experience)
        self.update_patterns(experience)
    
    def query(self, task_description):
        """查询相关经验"""
        return self.search_patterns(task_description)

反思的挑战

过度反思

问题: Agent对每个小错误都做深入反思 → 效率极低

解决:
  - 简单错误：快速修复，不需深入反思
  - 复杂错误：启动完整反思流程
  - 用分类器决定反思深度

反思的准确性

Agent的反思本身可能有误:
  - 归因错误（把结果归错原因）
  - 过度归因（把偶发错误当系统性问题）
  - 忽略根本原因

解决:
  - 多次反思取共识
  - 用外部验证校验反思结论
  - 人工审核高影响反思

经验泛化

问题: 在任务A上获得的经验不能简单迁移到任务B

解决:
  - 抽象经验而非记忆具体操作
  - 标注经验的适用条件
  - 迁移时评估相似度

实践案例

编程Agent的反思

# 测试失败后的反思
def reflect_on_test_failure(code, test_error):
    reflection = llm.generate(f"""
    代码: {code}
    测试错误: {test_error}
    
    反思:
    1. 错误的根本原因是什么？
    2. 是理解需求有误？还是实现有bug？
    3. 修复方案是什么？
    4. 如何避免类似错误？
    """)
    
    # 记录经验
    experience = {
        "error_type": classify_error(test_error),
        "root_cause": reflection.root_cause,
        "fix_strategy": reflection.fix_strategy,
        "prevention": reflection.prevention
    }
    return experience

客服Agent的反思

用户反馈: "你给的答案完全不对！"
反思:
  - 原因: 检索到错误的知识库文档
  - 根因: 知识库中有过期信息
  - 修复: 标记该文档为过期
  - 预防: 在回答前检查文档时效性

总结

反思机制是Agent从"执行"到"学习"的关键。没有反思能力的Agent永远在做同样的事情——犯同样的错。有了反思，Agent能从错误中学习，逐步改进策略，积累经验。这是真正的"智能"——不是一次做对，而是知道为什么做错了，下次能做更好。反思机制的成熟，是Agent走向真正自主的必经之路。