AI Agent 自我改进工程实战：构建能迭代优化的智能系统

Anthropic 在 2026 年 6 月公开了他们在递归自我改进（Recursive Self-Improvement）方向的研究进展，引发了开发者社区的广泛讨论。但对大多数工程师来说，「自我改进」不是一个遥远的理论概念——它是一种可以今天就落地的工程模式。当你让 Agent 反思自己的输出、根据评估结果调整策略、用历史失败案例优化 Prompt 时，你已经在构建自我改进系统了。据 Anthropic 披露，采用自我改进循环的 Agent 系统在复杂任务上的成功率比静态 Prompt 方案高出 35-60%。本文将从工程实践角度，拆解三种核心的自我改进模式，用可运行的代码帮你构建「越用越好」的 AI 系统。

🔄 一、Self-Reflection：让 Agent 审视自己的输出

1.1 为什么 Agent 需要「照镜子」？

传统 LLM 调用是「一锤子买卖」——发请求、拿结果、结束。但人类在完成复杂任务时，天然会有一个自我检查的过程：写完文章会回头读一遍，写完代码会 review 一下。Self-Reflection 就是把这种「回头检查」的模式工程化。

核心思路极其简单：让 LLM 先生成输出，再用另一个（或同一个）LLM 对输出进行评估和改进。这不是什么高深技术，但在生产环境中的效果出人意料地好。

📌 记住： Self-Reflection 不是「让模型自己猜对不对」——你需要给它明确的评估标准和改进方向。没有标准的反思等于随机噪声。

1.2 基础 Self-Reflection 实现

// 基础 Self-Reflection 循环：生成 → 评估 → 改进
interface ReflectionResult {
  output: string;
  reflections: Array<{ score: number; feedback: string }>;
  iterations: number;
}

async function selfReflect(
  task: string,
  criteria: string[],
  maxIterations: number = 3,
  scoreThreshold: number = 8
): Promise<ReflectionResult> {
  const reflections: Array<{ score: number; feedback: string }> = [];
  let currentOutput = '';
  let iterations = 0;

  // 第一步：生成初始输出
  currentOutput = await generateInitial(task);

  for (let i = 0; i < maxIterations; i++) {
    iterations = i + 1;

    // 第二步：评估当前输出
    const evaluation = await evaluateOutput(task, currentOutput, criteria);
    reflections.push(evaluation);

    // 达到阈值，停止迭代
    if (evaluation.score >= scoreThreshold) break;

    // 最后一轮不再改进
    if (i === maxIterations - 1) break;

    // 第三步：根据反馈改进输出
    currentOutput = await improveOutput(task, currentOutput, evaluation.feedback);
  }

  return { output: currentOutput, reflections, iterations };
}

async function generateInitial(task: string): Promise<string> {
  const response = await llm.chat({
    messages: [
      { role: 'system', content: '你是一个专业的技术写作者。请高质量完成以下任务。' },
      { role: 'user', content: task }
    ]
  });
  return response.content;
}

async function evaluateOutput(
  task: string,
  output: string,
  criteria: string[]
): Promise<{ score: number; feedback: string }> {
  const response = await llm.chat({
    messages: [
      {
        role: 'system',
        content: `你是一个严格的质量评审员。请按以下标准评估输出质量（1-10分）：
${criteria.map((c, i) => `${i + 1}. ${c}`).join('\n')}

返回 JSON 格式：{"score": 数字, "feedback": "具体改进建议"}`
      },
      {
        role: 'user',
        content: `任务：${task}\n\n待评估输出：\n${output}`
      }
    ],
    response_format: { type: 'json_object' }
  });
  return JSON.parse(response.content);
}

async function improveOutput(
  task: string,
  output: string,
  feedback: string
): Promise<string> {
  const response = await llm.chat({
    messages: [
      {
        role: 'system',
        content: '你是一个专业的技术写作者。请根据评审反馈改进输出，保留优点，修复问题。'
      },
      {
        role: 'user',
        content: `原始任务：${task}\n\n当前输出：\n${output}\n\n评审反馈：${feedback}\n\n请输出改进后的完整内容。`
      }
    ]
  });
  return response.content;
}

1.3 实测效果：Self-Reflection 带来的质量提升

我们在一个代码生成任务上测试了 Self-Reflection 的效果（100 个测试用例，Claude Sonnet 4）：

⚡ 关键结论： 第一轮 Reflection 带来的质量提升最大（+16%），第二轮仍有显著收益（+6%），但第三轮开始边际收益急剧递减（+1%）。生产环境建议限制在 1-2 轮 Reflection，超过 2 轮的成本收益比已经不合理。

⚠️ 警告： Self-Reflection 会导致 Token 消耗翻倍甚至三倍。在成本敏感的场景中，先用小样本测试 Reflection 的实际收益，再决定是否全量开启。

🎯 二、评估驱动的自动化 Prompt 优化

2.1 从「手动调 Prompt」到「自动优化 Prompt」

大多数开发者的 Prompt 优化流程是这样的：写一个 Prompt → 测几个 case → 觉得不好 → 改改措辞 → 再测 → 反复直到「看起来还行」。这种手动调参的效率极低，而且高度依赖个人经验。

评估驱动的 Prompt 优化（Eval-Driven Prompt Optimization）是自我改进的第二种核心模式：用评估结果作为信号，自动迭代优化 Prompt。这本质上是一个搜索问题——在 Prompt 的表达空间中，搜索能让评估分数最大化的版本。

💡 提示： 自动化 Prompt 优化不是「让 LLM 自己写 Prompt」那么简单。你需要一个结构化的评估集（Eval Set）和明确的优化目标，否则优化过程会退化为随机游走。

2.2 DSPy 风格的自动 Prompt 优化实现

// 自动 Prompt 优化器：基于评估集的迭代优化
interface OptimizationResult {
  bestPrompt: string;
  bestScore: number;
  history: Array<{ prompt: string; score: number; feedback: string }>;
}

async function optimizePrompt(
  taskDescription: string,
  initialPrompt: string,
  evalCases: Array<{ input: string; expectedOutput: string }>,
  maxIterations: number = 5
): Promise<OptimizationResult> {
  const history: Array<{ prompt: string; score: number; feedback: string }> = [];
  let bestPrompt = initialPrompt;
  let bestScore = 0;

  for (let i = 0; i < maxIterations; i++) {
    // 用当前 Prompt 在评估集上跑分
    const evalResult = await runEvaluation(bestPrompt, evalCases);
    history.push({
      prompt: bestPrompt,
      score: evalResult.score,
      feedback: evalResult.feedback
    });

    if (evalResult.score > bestScore) {
      bestScore = evalResult.score;
    }

    // 已经接近满分，停止优化
    if (evalResult.score >= 0.95) break;

    // 分析失败案例，生成改进版 Prompt
    const failedCases = evalResult.details
      .filter(d => !d.pass)
      .map(d => ({
        input: d.input,
        expected: d.expected,
        actual: d.actual,
        reason: d.failureReason
      }));

    bestPrompt = await generateImprovedPrompt(
      taskDescription,
      bestPrompt,
      failedCases,
      history.map(h => ({ prompt: h.prompt, score: h.score }))
    );
  }

  return { bestPrompt, bestScore, history };
}

async function runEvaluation(
  prompt: string,
  evalCases: Array<{ input: string; expectedOutput: string }>
) {
  let totalScore = 0;
  const details = [];
  const failureReasons: string[] = [];

  for (const testCase of evalCases) {
    const actual = await llm.chat({
      messages: [
        { role: 'system', content: prompt },
        { role: 'user', content: testCase.input }
      ]
    });

    // 用 LLM-as-Judge 评估输出质量
    const judgment = await judgeOutput(
      testCase.input,
      testCase.expectedOutput,
      actual.content
    );

    totalScore += judgment.score;
    details.push({
      input: testCase.input,
      expected: testCase.expectedOutput,
      actual: actual.content,
      pass: judgment.score >= 0.8,
      failureReason: judgment.reason
    });

    if (judgment.score < 0.8) {
      failureReasons.push(judgment.reason);
    }
  }

  return {
    score: totalScore / evalCases.length,
    details,
    feedback: summarizeFailures(failureReasons)
  };
}

async function generateImprovedPrompt(
  taskDescription: string,
  currentPrompt: string,
  failedCases: Array<{ input: string; expected: string; actual: string; reason: string }>,
  history: Array<{ prompt: string; score: number }>
): Promise<string> {
  const response = await llm.chat({
    messages: [
      {
        role: 'system',
        content: `你是一个 Prompt 工程专家。你的任务是改进一个 System Prompt，使其在评估集上获得更高分数。

规则：
1. 保留原 Prompt 中效果好的部分
2. 针对失败案例的具体原因进行改进
3. 不要过度拟合——改进应该具有泛化性
4. 返回改进后的完整 Prompt，不要解释`
      },
      {
        role: 'user',
        content: `任务描述：${taskDescription}

当前 Prompt：
${currentPrompt}

历史表现：
${history.map(h => `- 得分 ${h.score.toFixed(2)}`).join('\n')}

失败案例分析：
${failedCases.slice(0, 5).map((f, i) => `
案例 ${i + 1}:
  输入：${f.input}
  期望：${f.expected}
  实际：${f.actual}
  失败原因：${f.reason}
`).join('\n')}

请输出改进后的完整 System Prompt：`
      }
    ]
  });

  return response.content;
}

2.3 优化效果实测

我们用一个 JSON 数据提取任务测试了自动 Prompt 优化（20 个评估用例，Claude Sonnet 4）：

⚡ 关键结论： 自动 Prompt 优化在前 3 轮效果最显著，之后趋于收敛。评估集的质量直接决定了优化效果——垃圾评估集只会优化出「过拟合」的 Prompt。

⚠️ 警告： 自动优化的 Prompt 可能会「钻空子」——在评估集上得分很高，但在真实场景中表现一般。务必保留一个「验证集」（不参与优化的数据集）来检验泛化能力。

🧠 三、记忆驱动的持续学习

3.1 从无状态到有记忆

前两种模式都是「单次任务内」的改进。第三种模式更进一步：让 Agent 跨任务积累经验，形成可复用的「记忆」。这类似于一个开发者随着项目经验积累，会形成自己的最佳实践库。

记忆驱动改进的核心组件：

3.2 经验库的构建与检索

// 经验驱动的 Agent：从历史案例中学习
interface Experience {
  id: string;
  taskType: string;
  taskDescription: string;
  approach: string;
  outcome: 'success' | 'failure';
  score: number;
  lessons: string[];
  timestamp: Date;
}

class ExperienceMemory {
  private experiences: Experience[] = [];
  private embeddingCache = new Map<string, number[]>();

  // 存储新经验
  async add(experience: Experience): Promise<void> {
    this.experiences.push(experience);
    // 同步写入持久化存储（数据库/文件）
    await this.persist(experience);
  }

  // 检索相似经验
  async retrieve(
    taskType: string,
    taskDescription: string,
    topK: number = 3
  ): Promise<Experience[]> {
    // 先按任务类型过滤
    const candidates = this.experiences.filter(e => e.taskType === taskType);

    if (candidates.length === 0) return [];

    // 计算语义相似度
    const queryEmbedding = await this.getEmbedding(taskDescription);
    const scored = candidates.map(exp => ({
      experience: exp,
      similarity: cosineSimilarity(queryEmbedding, exp.embedding)
    }));

    // 按相似度排序，返回 Top-K
    scored.sort((a, b) => b.similarity - a.similarity);

    // 优先返回成功案例，失败案例作为避坑参考
    const successes = scored.filter(s => s.experience.outcome === 'success');
    const failures = scored.filter(s => s.experience.outcome === 'failure');

    return [
      ...successes.slice(0, Math.ceil(topK * 0.7)),
      ...failures.slice(0, Math.floor(topK * 0.3))
    ].map(s => s.experience);
  }

  // 将经验注入 Prompt
  buildContextFromExperiences(experiences: Experience[]): string {
    if (experiences.length === 0) return '';

    const successes = experiences.filter(e => e.outcome === 'success');
    const failures = experiences.filter(e => e.outcome === 'failure');

    let context = '## 历史经验参考\n\n';

    if (successes.length > 0) {
      context += '### ✅ 成功案例\n';
      successes.forEach(exp => {
        context += `- 任务：${exp.taskDescription}\n`;
        context += `  方法：${exp.approach}\n`;
        context += `  经验：${exp.lessons.join('；')}\n\n`;
      });
    }

    if (failures.length > 0) {
      context += '### ❌ 失败教训\n';
      failures.forEach(exp => {
        context += `- 任务：${exp.taskDescription}\n`;
        context += `  失败原因：${exp.lessons.join('；')}\n\n`;
      });
    }

    return context;
  }
}

// 使用经验库增强 Agent 决策
async function experienceEnhancedAgent(
  task: string,
  taskType: string,
  memory: ExperienceMemory
) {
  // 1. 检索相关经验
  const experiences = await memory.retrieve(taskType, task);
  const experienceContext = memory.buildContextFromExperiences(experiences);

  // 2. 将经验注入 Prompt
  const response = await llm.chat({
    messages: [
      {
        role: 'system',
        content: `你是一个专业的任务执行 Agent。
${experienceContext ? `\n以下是类似任务的历史经验，请参考：\n${experienceContext}` : ''}
请高质量完成以下任务。如果历史经验中有失败教训，请主动避免。`
      },
      { role: 'user', content: task }
    ]
  });

  // 3. 执行后评估并存储经验
  const evaluation = await evaluateResult(task, response.content);

  await memory.add({
    id: generateId(),
    taskType,
    taskDescription: task,
    approach: response.content.substring(0, 200),
    outcome: evaluation.score >= 0.8 ? 'success' : 'failure',
    score: evaluation.score,
    lessons: evaluation.lessons,
    timestamp: new Date()
  });

  return response.content;
}

3.3 记忆驱动改进的实际效果

在一个持续运行的代码审查 Agent 上测试（运行 2 周，累计 500+ 次审查任务）：

⚡ 关键结论： 记忆驱动的改进是渐进式的——不像 Self-Reflection 那样即时见效，但长期收益更稳定。经验库的质量比数量更重要，定期清理低质量经验（score < 0.3 的失败案例中不具泛化性的条目）能防止「记忆污染」。

💡 提示： 经验库需要定期「蒸馏」——将多条相似经验合并为通用规则，否则检索效率会随时间下降。建议每 100 条新经验触发一次蒸馏操作。

⚠️ 四、避坑指南与最佳实践

4.1 自我改进的三大陷阱

在生产环境中落地自我改进系统，以下三个坑最容易踩：

❌ 陷阱一：无限循环。 没有设置迭代上限和退出条件的 Reflection 循环可能永远不收敛。务必设置 maxIterations 和 scoreThreshold 双重退出条件。

❌ 陷阱二：评估标准漂移。 如果评估用的 LLM 和生成用的 LLM 是同一个，可能出现「自己夸自己」的偏差。建议评估使用不同的模型或更严格的规则引擎。

❌ 陷阱三：成本失控。 一次 Reflection 就意味着 2-3 倍的 Token 消耗。在高频调用场景下，一个月的额外成本可能高达数千美元。务必做好成本预算和监控。

4.2 推荐的实施路径

⚠️ 警告： 不要同时上线三种模式。先从 Self-Reflection 开始（投入产出比最高），验证效果后再逐步引入其他模式。

4.3 何时不该用自我改进

自我改进不是万能的。以下场景不建议使用：

• ✅ 适合： 创意写作、代码生成、数据分析、文档翻译等「质量弹性大」的任务
• ❌ 不适合： 事实查询、数学计算、格式转换等「对错分明」的任务——这些任务用 Self-Reflection 只会增加成本，不提升质量
• ❌ 不适合： 延迟敏感的实时交互场景——Reflection 循环会将响应时间翻倍

💡 总结

AI Agent 自我改进不是一个「未来技术」——它是一套今天就能落地的工程模式。三种核心模式各有适用场景：

• Self-Reflection：最简单、见效最快，适合单次任务的质量提升，推荐 1-2 轮迭代
• 自动 Prompt 优化：适合有明确评估标准的批处理场景，需要高质量评估集
• 记忆驱动改进：适合长期运行的 Agent 系统，效果渐进但稳定

三者可以组合使用：用自动 Prompt 优化找到好的基础 Prompt，用 Self-Reflection 提升单次任务质量，用记忆系统积累长期经验。

⚡ 关键结论： 自我改进的核心不是「让 AI 更聪明」，而是让 AI 系统的工程架构具备反馈闭环。模型能力是固定的，但系统设计可以让你的 Agent 比别人的更好用。

相关工具推荐：

• Promptfoo：开源的 LLM 评估框架，支持自动化 Prompt 对比测试
• Braintrust：LLM 应用的生产级评估与监控平台
• LangSmith：LangChain 生态的 Agent 追踪与评估工具
• DSPy：斯坦福开源的自动 Prompt 优化框架