第 12 章 自我进化——从"用完即忘"到"越用越强"

在前面几章中，我们看到了 GA 的工具层如何控制信息密度（第 9 章）、记忆层如何组织跨任务知识（第 10 章）、压缩层如何管理单次任务内的上下文预算（第 11 章）。这三个机制共同解决了"当前任务如何高效执行"的问题。

但还有一个更深层的挑战尚未触及——跨任务的能力增长。

一个没有进化能力的 Agent，即使拥有完美的工具和记忆系统，每次面对相似的任务仍然要从头探索。它就像一个永远的新员工——每天都在重新学习同一套操作流程，永远无法积累经验。GA 如何打破这种"停滞循环"？

论文对此给出了一个关键的设计原则：进化的是策略，不是工具（What evolves: strategy, not tools）。GA 将固定的工具层与可进化的知识层严格分离——工具接口和用户交互方式在运行期间始终不变，而所有任务特定的能力都以 SOP 文件和可复用脚本的形式存储在记忆系统中。Agent 可以自由地读取、创建和修改这些知识资产，而不会干扰底层工具的稳定性。这种分离确保了知识的安全增长：常见的子任务会自然地从纯文本指令进化为稳定的、可复用的脚本，而 Agent 的运行时基础设施始终保持不变 [1, Section 2.3.3]。

---

12.1 经验蒸馏的动机

12.1.1 直觉理解：新员工 vs 老员工

想象两个员工在做同一件事——从 GitHub 上调研一个开源项目的 PR 记录并生成报告。

新员工的做法：打开浏览器 → 搜索项目 → 找到 PR 页面 → 一个个点开看 → 手动记录 → 尝试不同的筛选方式 → 走了几条弯路 → 最终完成。整个过程需要 30 分钟，中间有大量的试错和重复操作。

老员工的做法：直接打开书签 → 用 GitHub API 批量拉取 PR 数据 → 按预定模板整理 → 5 分钟完成。他不需要"探索"，因为他已经把这个流程内化为一套标准操作。

这两个员工的差异不在于智商，而在于经验是否被有效沉淀。老员工过去的试错经历已经被压缩成了一套高效的操作流程——这就是经验蒸馏（Experience Distillation）。

12.1.2 与信息密度的关系

从信息密度的视角来看，进化的价值在于：让后续任务从更高密度的起点出发。

没有进化时，每次任务的上下文都必须包含大量的探索性内容——尝试不同方案、处理意外错误、搜索替代路径。这些内容对"完成当前任务"是必要的，但对"执行一个已知流程"来说就是纯粹的冗余。

有了进化后，过去的探索成果被压缩为紧凑的 SOP 或可执行代码，直接注入后续任务的上下文。模型不需要重新推理"该怎么做"，而是直接执行"已经验证过的做法"。信息密度从一开始就处于高位。

---

12.2 GA 的三阶段进化路径

GA 的自我进化并非一步到位，而是经历三个渐进的阶段。我们用一组真实的实验数据来展示这个过程。

12.2.1 实验设置

实验任务是LangChain GitHub 研究任务——调研 LangChain 项目的 PR 记录并生成结构化报告。实验以 Claude Opus 4.6 为骨干模型，对比基线为同样使用 Claude Opus 4.6 的 OpenClaw，以确保差异来自系统架构而非模型能力。同一个任务被重复执行 9 轮，GA 可以在每轮结束后将经验写入长期记忆 [1, Section 4.4.1]。

12.2.2 Stage 1：自然语言执行（Round #1）

第一轮是纯粹的从零探索。GA 没有任何先验知识，需要通过 in-context reasoning 和 trial-and-error 来完成任务：

• 搜索 LangChain 的 GitHub 地址
• 尝试不同的 PR 筛选策略
• 处理各种意外情况（页面加载失败、数据格式变化等）
• 逐步摸索出一套可行的流程

执行数据：耗时 7 分 30 秒，LLM 调用 32 次，总 token 消耗 222,203。

这是一个典型的"高熵探索"过程——大量的推理循环、大量的上下文重建、大量的试错开销。

12.2.3 Stage 2：SOP 蒸馏（Rounds #2–#5）

从第二轮开始，GA 将第一轮的成功经验压缩为一份文本化 SOP（Standard Operating Procedure）。这份 SOP 记录了：哪些步骤是必要的、按什么顺序执行、在什么地方容易出错。

后续轮次不再从零探索，而是读取 SOP → 按步骤执行 → 根据执行结果优化 SOP。

轮次	阶段	耗时	LLM 调用次数	Cache Read	总 Token
#1	初始执行	7m30s	32	183,375	222,203
#2	SOP 优化	4m19s	12	51,883	66,341
#3	SOP 优化	2m53s	8	39,534	49,825
#4	SOP 优化	2m29s	9	41,376	51,758
#5	SOP 优化	2m50s	7	27,268	35,536

从 Round #1 到 Round #5，token 消耗下降了 84%，LLM 调用次数下降了 78%。但更重要的是理解为什么效率在提升：

• 消除了重复的推理循环。Round #1 中模型需要反复推理"下一步该做什么"，而有了 SOP 后，这些推理被压缩为直接的步骤执行。效率提升的主要来源不是单次回复变短，而是 LLM 调用次数的大幅减少——整个"理解→推理→生成"的循环被从执行轨迹中移除了
• 减少了运行时上下文开销。从表中的 Cache Read 列可以看到，Round #1 的 cache-read token 高达 183,375，而 Round #5 降到了 27,268——Agent 不再需要在每轮调用中重建大量的上下文
• SOP 仍在迭代优化。注意 Round #3 到 #4 的 token 略有回升——这是 SOP 在适应新发现的边界情况时产生的正常波动

注意这里的关键事实：阶段转换不需要人工干预 [1]。Agent 在任务执行过程中，会在适当的时机（如子目标完成或故障恢复后）主动调用 start_long_term_update 将经验蒸馏为 SOP 并写入 L3 层。下一次执行同类任务时，L1 索引会路由到这份 SOP，Agent 自动切换到"按 SOP 执行"模式。这里的"自动"指的是 Agent 自主完成了从探索到 SOP 蒸馏再到 SOP 执行的整个转换过程，而非系统在后台自动改写记忆。

12.2.4 Stage 3：代码化执行（Rounds #6–#9）

当文本 SOP 经过多轮验证趋于稳定后，GA 会将其进一步编译为可执行代码。这意味着模型不再需要"阅读 SOP 然后一步步执行"，而是直接调用一段预编写的脚本来完成整个流程。

轮次	阶段	耗时	LLM 调用次数	Cache Read	总 Token
#6	代码化 SOP	2m24s	6	20,913	25,762
#7	代码化 SOP	1m41s	5	18,249	23,014
#8	代码化 SOP	1m35s	5	18,229	22,689
#9	代码化 SOP	1m38s	5	19,034	23,010

进入代码化阶段后，系统收敛到一个极窄的稳定带：约 23k±1k token，5 次 LLM 调用，1 分 40 秒左右完成。

相对于 Round #1 的初始执行：

• 时间减少 78.2%（7m30s → 1m38s）
• LLM 调用减少 84.4%（32 → 5）
• Token 消耗减少 89.6%（222,203 → 23,010）

三阶段进化的本质可以用信息密度来理解：

Stage 1: 自然语言执行          Stage 2: SOP 蒸馏           Stage 3: 代码化执行
┌──────────────────┐    ┌──────────────────┐    ┌──────────────────┐
│ 大量探索性推理     │    │ SOP 指导执行      │    │ 脚本直接执行      │
│ 大量试错分支       │    │ 少量适应性推理     │    │ 极少推理开销      │
│ 大量上下文重建     │    │ 中等上下文需求     │    │ 最小上下文需求    │
│                  │    │                  │    │                  │
│ 信息密度: 低       │    │ 信息密度: 中       │    │ 信息密度: 高      │
│ 222k tokens      │    │ 36k-66k tokens   │    │ 23k tokens       │
└──────────────────┘    └──────────────────┘    └──────────────────┘

12.2.5 对比实验：其他系统为什么不能进化？

上面的九轮实验展示了 GA 自身的进化轨迹。但一个关键问题是：其他 Agent 系统在重复执行任务时也能实现类似的效率提升吗？

在 HuggingFace 数据集下载任务的五轮重复实验中 [1]，答案是否定的：

• CodeX、Claude Code、OpenClaw 的操作时间和 token 消耗在各轮之间基本保持稳定，没有明显的改善趋势
• GA 的操作时间从第一轮的 102 秒下降到后续轮次的约 66 秒，token 消耗从 200,439 降至约 100,000

这些系统之间的差异不在于模型能力，而在于架构是否支持经验积累。CodeX、Claude Code 和 OpenClaw 没有将执行经验蒸馏为可复用知识的机制——每次执行都是从零开始的独立过程，无论重复多少次，效率都不会提升。

12.2.6 跨任务泛化

一个自然的后续质疑是：GA 的进化效果是否只对反复执行的同一任务有效？

论文通过一个包含 8 类不同网页任务的跨任务基准测试来回答这个问题，GA 和 OpenClaw 都使用 Claude Opus 4.6 作为骨干模型 [1, Section 4.4.3]。结果表明，GA 后续执行相比首次执行的 token 节省率范围为 61.0% 到 92.4%，总体降低 79.3%。所有任务都展现出相同的内部趋势：第一次执行的 token 成本显著较高，第二、三次执行快速收敛到稳定的低成本区间。

图 12-1：GA 与 OpenClaw 在 8 个不同任务上三轮重复执行的 token 收敛对比。每个子图对应一个基准任务，红线为 OpenClaw，蓝线为 GA。GA 在所有任务上都展现出从首次执行到后续执行的快速收敛，而 OpenClaw 的 token 消耗在各轮之间波动甚至上升。（来源：论文 Figure 5 [1]）

这种收敛模式揭示了一个重要机制：即使有了 SOP 记忆，首次执行仍然存在SOP 适配成本——Agent 需要将通用化的 SOP 知识映射到当前任务实例的具体页面结构和交互流程上。但这种适配只需发生一次。一旦成功路径与环境对齐，后续执行就可以直接复用，token 成本迅速趋于稳定。

进化收益与任务复杂度呈正相关：涉及状态转移和错误恢复的长链任务（如跨页面状态传递）节省率高达 92.0%，因为 SOP 充当了"路径压缩器"——一旦验证过的路线被存储，Agent 可以完全跳过大部分探索性分支。

作为对比，OpenClaw 在三轮重复执行中没有表现出可比的收敛模式——token 消耗在各轮之间波动甚至上升，说明系统持续在重新探索而非复用经验 [1]。

---

12.3 进化的触发与守门

12.3.1 什么时候触发记忆蒸馏

GA 提供了一个专门的工具 start_long_term_update 来触发长期记忆的更新。模型在以下情境中被引导调用这个工具：

• 子目标成功完成时：一个阶段性的成功值得记录
• 故障恢复转换时：从错误中恢复的过程包含了宝贵的调试经验
• 发现可复用模式时：识别到某个操作序列在未来可能被重用

12.3.2 准入标准：防止"垃圾进化"

并非所有经验都值得保存。如果不加筛选地将所有执行记录写入长期记忆，记忆库很快就会被一次性的调试信息、失败的尝试、以及过时的配置所污染。这就是垃圾进化（Junk Evolution） 问题。

GA 通过两道"守门"机制来防止垃圾进化：

第一道门：执行验证。 只有经过实际执行并验证成功的经验才能写入。"我觉得应该这样做"不够——必须是"我这样做了，而且成功了"。

第二道门：跨任务可复用性。 一次性的、特定于当前任务上下文的信息不应写入长期记忆。写入的信息必须具有在未来任务中被重用的潜力。

需要注意的是，这两道准入标准应被理解为引导性规则（Consolidation Guidance），而非完全自动化的强制过滤 [1]。GA 提供了记忆管理规范来引导 Agent 的写入行为，但当前实现并未包含对信息有效性、稳定性或未来复用价值的完整自动验证机制。

12.3.3 自我改进日志

除了 SOP 和代码形式的经验沉淀，GA 还维护了一个独立的轻量级自我改进日志（Self-Improvement Log），记录三类特定的信息 [1, Section 2.3.5]：

1. 观察到的错误及其修正：某次操作失败的原因和对应的纠正方案
2. 用户显式偏好：用户在交互中表达的工作习惯和偏好
3. 经验证的成功模式：被实践验证有效的操作模式

这些条目会被自动注入系统提示词，持续引导 Agent 的未来决策。与 L3 SOP 不同，这个日志关注的不是"怎么做一个任务"，而是"在做任何任务时应该注意什么"。

需要注意的是，当前实现中这个日志的维护依赖人工参与——用户需要确认哪些错误和偏好值得记录。这限制了 Agent 自主影响核心行为的程度，是当前系统的一个已知局限 [1, Section 3.3]。

12.3.4 故障升级作为进化安全阀

进化过程中的一个关键保护机制是故障升级（Failure Escalation）。当 GA 在执行过程中遇到失败，它不会盲目重试，而是遵循论文 §2.3.3 描述的三步渐进恢复流程：

1. 局部修正：分析当前错误信息，做小幅定向调整后重试
2. 策略切换：如果失败持续，放弃当前方案，强制切换到全新策略或搜索环境中缺失的信息
3. 人类介入：如果所有自动化尝试均失败，暂停执行并请求人类干预

这个机制确保了 GA 不会将错误的"经验"固化为 SOP。如果一条路径反复失败，它会被标记为死胡同，而不是被记忆为"标准做法"。

---

12.4 自主探索：让 Agent 自己"上课"

除了在执行用户任务时被动地积累经验，GA 还支持一种更激进的进化方式——自主探索（Autonomous Exploration）。

12.4.1 直觉理解

自主探索就像一个员工在没有紧急任务时，主动学习新技能、探索新工具、扩展自己的能力范围。它不是等着老板布置任务才开始学习，而是自己规划课程表。

12.4.2 探索的闭环流程

自主探索由四个阶段组成一个闭环：

┌──────────────────────────────────────────────────┐
│                 自主探索闭环                       │
│                                                  │
│  ① 触发 ─→ ② 课程规划 ─→ ③ 执行 ─→ ④ 技能入库   │
│     ↑                                    │       │
│     └────────────────────────────────────┘       │
└──────────────────────────────────────────────────┘

① 触发：自主探索可以通过两种方式启动 [1, Section 3.3]。在任务模式（task mode）下，外部编排器（如 cron job）向文件系统信箱提交一次性任务；在反射模式（reflect mode）下，系统轮询一个用户提供的回调函数（默认每 6 分钟一次），当回调返回非空字符串时，该字符串被注入为新的提示词，启动自主学习。两种模式都是 Reflect Mode 原语的具体实例化，不需要对核心架构做任何扩展。

② 课程规划：GA 检查当前技能库的分布，生成一份优先级排序的任务清单。任务候选项通过一个四维评分公式来排序：

$$S(t)=w_b\cdot B(t)+w_d\cdot D(t)+w_u\cdot U(t)+w_i\cdot I(t)$$

四个维度的直觉含义：

• 广度 $B(t)$：这个技能是否能填补技能树中的空白区域？如果某个类别的技能数量远低于平均水平，学习该类别的新技能得分更高
• 深度 $D(t)$：这个技能是否能强化已经常用的能力？使用频率越高的技能，进一步深化的价值越大
• 实用性 $U(t)$：这个技能在实际工作中被用到的可能性有多大？
• 创新性 $I(t)$：这个技能是否涉及新的技术领域或方法论？

广度和深度有具体的计算公式，基于技能树的统计数据：

$$B(t)=10\times max(0,1-\frac{|S_c|}{\overline{S}+1})$$$$D(t)=10\times \frac{u(t)}{u_{max}+1}$$

其中 $|S_c|$ 是目标类别中的技能数量，$\overline{S}$ 是所有类别的平均技能数，$u(t)$ 是目标技能的使用次数，$u_{max}$ 是所有技能中的最高使用次数。

默认权重为 $(w_b,w_d,w_u,w_i)=(0.3,0.2,0.3,0.2)$，优先考虑广度和实用性。

③ 执行：GA 使用标准的工具集（搜索、代码执行、文件读写）来执行任务，受 30 轮交互上限约束。所有操作限制在临时目录内，禁止访问密钥和核心源码。

④ 技能入库：执行完成后，结果被写入结构化报告，新技能注册到技能树中。即使是失败的实验也会被记录，以便未来的规划能避开同样的死胡同。

12.4.3 反思驱动的权重自适应

四维评分的权重不是固定不变的。GA 实现了一个反思驱动的权重自适应机制（Reflection-Based Weight Adaptation）：

• 如果一个任务的预测得分很高（$S(t)>8.0$）但实际使用率很低（30 天内使用次数 < 3），说明得分中贡献最大的那个维度的权重被高估了 → 该主导维度的权重降低 10%
• 如果一个任务的预测得分很低（$S(t)<5.0$）但实际使用率很高（使用次数 > 5），说明某个维度的权重被低估了 → 对应维度的权重增加 10%
• 调整后的权重被重新归一化，确保总和为 1

这个反馈循环让系统能够逐渐发现哪些维度在当前用户的工作流中最能预测实际价值，无需手动调参。

12.4.4 技能树结构

技能库被组织为一个二级映射：

技能树
├── web_automation（类别）
│   ├── web_scraping（技能）→ 使用次数: 12
│   ├── form_filling（技能）→ 使用次数: 5
│   └── ...
├── data_processing（类别）
│   ├── csv_parsing（技能）→ 使用次数: 8
│   └── ...
└── ...

每个技能关联着对应的工具脚本和一个单调递增的使用计数器。技能树通过一组 API 支持查询、修改、使用追踪和原子化的完成操作。

12.4.5 局限性

自主探索机制目前存在几个已知局限：

1. 30 轮上限：复杂任务可能需要跨多个会话完成，连续性仅通过报告和任务清单注释来维护
2. 权重自适应的初步性：反思机制尚未积累足够的数据来验证其在多样化用户工作流中的有效性
3. 自我改进日志的手动性：记录错误和偏好的自我改进日志目前依赖人工维护，限制了 Agent 自主影响核心行为的程度
4. 技能树维护的手动性：合并冗余类别、弃用过时技能、扩展类别体系——这些工作目前仍需人工参与

---

12.5 本章小结

本章展示了 GA 如何从"用完即忘"进化到"越用越强"。核心要点：

1. 进化的是策略，不是工具：GA 将固定的工具层与可进化的知识层严格分离，所有任务特定的能力以 SOP 和脚本形式存储，确保知识安全增长
2. 三阶段进化路径（自然语言执行 → SOP 蒸馏 → 代码化执行）将高熵探索逐步压缩为低成本的确定性执行，实现了 89.6% 的 token 节省
3. 进化的触发与守门通过执行验证和可复用性筛选，防止垃圾进化污染记忆库
4. 自我改进日志记录错误修正、用户偏好和成功模式，自动注入系统提示词以持续引导行为
5. 自主探索让 Agent 在空闲时主动扩展能力边界，通过四维评分和反思自适应来规划学习课程
6. 故障升级确保失败经验不会被固化为错误的标准操作

自我进化的核心意义在于：它将每一次任务执行都变成了一次学习机会，让后续任务从更高的信息密度起点出发。这不是参数层面的学习（模型权重没有改变），而是环境层面的进化——模型运行的信息环境在持续优化。

至此，我们已经完整地剖析了 GA 的四大核心机制：工具层（第 9 章）、记忆层（第 10 章）、压缩层（第 11 章）、进化层（本章）。一个自然的问题浮现：这些机制加在一起，能产生什么超出各部分之和的效果？为什么一个只有 9 个工具、没有专用子 Agent 管理器、没有事件总线的系统，却能实现并行任务分发、定时监控、自主运维这些"高级功能"？

这就是最后一章的主题——涌现能力。

参考文献

[1] Advantage AI Agent Laboratory. (2025). GenericAgent: A Self-Evolving LLM Agent via Contextual Information Density Maximization. Technical Report V1.0, Sections 2.3.3, 2.3.5, 3.3 & 4.4.