第 7 讲：开放式演化——让 AI 改进自己的设计（ADAS、Darwin Gödel Machine、AlphaEvolve、AI Scientist）

对应：Stanford CS329A Autumn 2025 Lecture 7（Mon 10/13，Open-Ended Evolution of Self-Improving Agents）；作业 2 在 10/14 发布。阅读材料：课程主页上标为 Automated design of agentic systems 的链接（arXiv 2505.22954，实际指向 Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents，Zhang et al. 2025，它的副标题和本讲的标题完全一致）、The AI Scientist（Lu et al. 2024）、AlphaEvolve（Novikov et al. 2025）。本讲同时介绍 DGM 的前身 Automated Design of Agentic Systems（ADAS，Hu et al. 2024）和 AlphaEvolve 的前身 FunSearch（Romera-Paredes et al. 2023）。幻灯片没有公开，本讲依据这些论文编写。 配套代码：code/lecture07/（只用 Python 标准库；01 号约 6 秒，02 号约 1 秒） 预计阅读时间：3 小时（含运行代码）

0. 本讲导航

0.1 学完本讲，你应该能够

1. 说出”第三层自我改进”是什么：不改答案（test-time）、不改权重（train-time），而是改系统的设计本身——agent 的架构、算法的代码、甚至研究的方向。
2. 说出为什么 LLM 让这件事第一次变得可行：设计空间 = 程序，LLM 能读、能写、能评价程序。
3. 说出 ADAS / Meta Agent Search 的做法（agent 写成代码、meta agent 不断写出新的 agent、存档）和主要结果（跨领域、跨模型的迁移）。
4. 说出 Darwin Gödel Machine 的两个关键：自我指涉（coding agent 修改自己的代码，修改能力也随之提高）和开放式的存档（保留”更差但能运行”的 agent 作为垫脚石）；说出它的两个消融各说明了什么。
5. 说出 FunSearch / AlphaEvolve 的组成：LLM 提议修改、自动评估器打分、程序数据库保持多样性；说出 AlphaEvolve 的代表性结果（4×4 复矩阵乘法 48 次乘法、数学构造、Google 的数据中心调度和 Gemini 训练加速）。
6. 说出 The AI Scientist 的流水线和它暴露的问题：幻觉的结果、novelty 评估不可靠、修改自己的超时限制。
7. 用一句话说出本讲反复出现的原则：评估器就是目标——它决定了开放式搜索能找到什么，也决定了它会怎样被钻空子。

0.2 先修知识

0.3 本讲地图

第1节  第三层自我改进：从"人设计系统"到"系统设计系统"
第2节  ADAS：把 agent 写成代码，让 meta agent 去搜索
第3节  Darwin Gödel Machine：自己修改自己 + 开放式的存档           ← 代码 02
第4节  FunSearch 与 AlphaEvolve：用演化和评估器发现算法             ← 代码 01
第5节  The AI Scientist：自动化整个科研流程
第6节  共同的问题：评估器、新颖性与安全
第7–10节 小结、练习、延伸阅读、下一讲预告

0.4 本讲的代码

本讲的两个文件不再使用前几讲的算术 toy world：

• 01_evolve_heuristic.py：FunSearch 原论文里的在线装箱问题。程序是一个”优先级函数” priority(s, r)（一段 Python 表达式），评估器在随机实例上模拟装箱、计算比下界多用了多少箱子。没有调用真正的 LLM，“LLM 提议的修改”用随机的局部修改、变异和交叉代替。
• 02_open_ended_archive.py：Darwin Gödel Machine 的风格化模拟。agent 的设计是一组可选的改进，得分函数里有”单独加上会变差、组合起来很有用”的垫脚石。得分函数和”修改质量随能力提高”的关系都是设定的，用来说明 DGM 两个消融的机制，不是定量模拟。

关于本讲的数字：论文里的数字注明出处；模拟实验的数字都来自 01、02 号代码的实际输出（固定随机种子，Python 3.9 与 3.13 逐字相同）。

1. 第三层自我改进：从”人设计系统”到”系统设计系统”

1.1 三层自我改进

第 1 讲第 1.3 节把自我改进分成了几层：

前两层里，“怎样采样、怎样验证、怎样训练”都是人设计好的。第三层要问：这些设计本身，能不能也交给 AI？

1.2 历史的教训：手工设计终将被学习取代

ADAS 论文开头引用了机器学习史上反复出现的模式：

• 手工设计的特征（SIFT、HOG）被 CNN 学到的特征取代；
• 手工设计的网络结构，部分被神经网络架构搜索（NAS）取代；
• 手工设计的优化器、学习率调度，被元学习（meta-learning）探索。

第 1 讲第 2.2 节提到的 The Bitter Lesson 说的也是这件事：长期来看，能随计算扩展的通用方法（搜索和学习）总会赢过人的精心设计。今天的 agent 系统——CoT、self-refine、多 agent 辩论、各种 workflow——几乎全是人手工设计的。ADAS 的作者预言：它们终将被自动发现的设计取代。

1.3 背景一：Gödel 机器

自我改进的 AI 是一个古老的想法。Schmidhuber 2003 年提出的 Gödel 机器是一个理论上的设计：一个程序可以重写自己的任何部分（包括负责重写的那部分），但只在能证明这次修改有益时才执行修改。它在理论上很漂亮，在实践中却不可能实现：对几乎任何有意义的修改，你都证明不了它”一定有益”。

Darwin Gödel Machine 的名字就来自这里：它把”证明修改有益”换成了”在 benchmark 上实际测试修改是否有益”，再加上达尔文式的演化（第 3 节）。

1.4 背景二：开放式演化（open-endedness）

演化算法的基本循环是：变异（对已有的解做随机修改）→ 评估（打分）→ 选择（保留好的）。开放式演化研究的是一个更深的问题：怎样让搜索持续地产生新东西，而不是很快收敛到一个局部最优？几个关键的思想：

• 垫脚石（stepping stones）：通往好解的路上，常常要经过一些”本身并不好”的中间状态。只保留最好的解，就永远到不了那里。
• 新颖性搜索（novelty search）：有时奖励”和以前不一样”，比奖励”更好”更能找到好解。
• 质量-多样性（quality-diversity）算法，例如 MAP-Elites：按某些特征把解分成很多格子，每个格子里保留最好的那个——既要好，也要多样。AlphaEvolve 的程序数据库就受它启发。

1.5 为什么是现在：设计空间 = 程序

以前的元学习和架构搜索，搜索空间是人定义好的（例如”层数 × 每层宽度”）。LLM 带来了两个根本的变化：

1. 设计可以写成代码。一个 agent、一个算法、一个实验，都是一段程序。程序语言是图灵完备的，理论上可以表达任何设计。
2. LLM 能读、能写、能评价代码。它不再是随机地修改，而是”读懂”已有的好设计，提出有意义的改进；它还能判断一个想法”是否有趣、是否新颖”。

于是，“搜索更好的设计”变成了”让 LLM 写出更好的程序，用评估器检验”。本讲的四个系统都是这个模式。

2. ADAS：把 agent 写成代码，让 meta agent 去搜索

2.1 想法

Hu, Lu, Clune 2024（Automated Design of Agentic Systems）提出了一个新的研究方向 ADAS：自动地设计 agent 系统，包括发明新的构件、用新的方式组合它们。

关键的一步是：把 agent 定义成代码。每个 agent 是一个 Python 函数 forward(task_info)，输入任务，输出答案。函数里面可以调用 LLM、写提示词、调用工具、组合多个 LLM 调用——CoT、self-refine、LLM 辩论都能写成这样的函数。

2.2 Meta Agent Search

算法叫 Meta Agent Search：一个 meta agent（GPT-4）不断地写出新的 agent：

存档 ← {CoT、CoT-SC、Self-Refine、LLM 辩论 …}（人设计的 agent，作为起点）
重复：
    1. meta agent 看着存档里已有的 agent 和它们的分数，构思一个"有趣的新 agent"，
       写出高层的描述和完整的代码；
    2. 两轮自我反思：这个设计新颖吗？代码对吗？
    3. 在验证集上评估；如果运行出错，让 meta agent 修改，最多 5 次；
    4. 把新 agent 和它的分数加进存档。

为了省钱，被设计出来的 agent 用 GPT-3.5 运行，只有 meta agent 用 GPT-4。

2.3 结果

• 在阅读理解（DROP）上，F1 比最好的人工设计提高 13.6；在多语言数学（MGSM）上，准确率提高 14.4%。
• 在 ARC（抽象推理）上，发现的 agent 在测试集上的准确率从约 6% 逐步提高到约 13.7%。
• 迁移：在 MGSM 上发现的 agent，用到没见过的数学数据集上依然很强（GSM8K 上比基线高 25.9%，GSM-Hard 上高 13.2%），甚至用到非数学的任务上也有竞争力；从 GPT-3.5 换到 Claude、GPT-4 等其他模型，依然保持优势（Claude Sonnet 在 ARC 上接近 50%）。

2.4 发现了什么样的 agent？

发现的 agent 往往是已有构件的新组合：多个不同角色的”专家”并行回答、再由一个模块综合；先验证再修改的多轮流程；动态地决定要不要调用更多的推理……这呼应了第 2 讲 Archon 的发现：好的推理系统常常是”生成 + 验证 + 融合”的组合，而最好的组合因任务而异。不同的是，Archon 在一个人定义好的组件空间里搜索，ADAS 的搜索空间是任意代码。

2.5 局限

• 每个候选 agent 都要在验证集上跑一遍，评估很贵。
• 搜索是对着验证集的分数进行的，有过拟合验证集的风险（第 2 讲第 5.4 节的挑选偏差）。
• meta agent 本身是固定的：它不会因为发现了好的 agent 而变得更会设计 agent。这一点正是 Darwin Gödel Machine 要改进的。

3. Darwin Gödel Machine：自己修改自己 + 开放式的存档

3.1 从 ADAS 到 DGM

Zhang, Hu, Lu, Lange, Clune 2025 指出了 ADAS 这类方法的一个限制：负责”设计”的 meta agent 是人设计的、固定不变的，系统的改进只是一阶的。DGM 的想法是：

让被改进的 agent 自己就是那个修改者。 一个 coding agent 修改自己的代码库。如果这次修改让它更会写代码，它也就更会修改自己——改进会复利。

为什么选 coding agent？因为”修改自己”本身就是一个编程任务：在 coding benchmark 上变强，就意味着在”修改 agent 代码”这件事上变强。评估和自我改进用的是同一种能力。

3.2 DGM 的循环

1. 初始 agent 非常简单：只有两个工具——一个执行 bash 命令的工具，一个查看和编辑整个文件的工具。
2. 存档：保存所有生成过的、能正常运行的 agent。
3. 选父 agent：选中的概率大致正比于它的得分、反比于它已经有的子 agent 数——既偏好表现好的，也照顾还没怎么被探索过的分支。
4. 自我修改：父 agent 阅读自己在 benchmark 上的评估日志，诊断失败的模式，提出改进，并把改进实现到自己的代码库里。
5. 分阶段评估：新 agent 先在 10 个任务上检查能否正常工作，通过了再测 50 个，表现最好的再测到 200 个。
6. 能正常运行的新 agent 加进存档，回到第 3 步。

3.3 发现了什么

DGM 自动发现的改进包括：

• 更好的工具：让编辑工具可以按行查看文件、用字符串替换精确地编辑（而不是重写整个文件）。
• 更好的工作流：多次尝试解决同一个任务，再用另一个基础模型评估、挑出最好的那次（第 2、3 讲的”生成 + 验证”）；更好的长上下文管理；类似”同行评审”的检查机制。

这些都是人类工程师在 coding agent 里会做的改进——DGM 自己”重新发明”了它们。

3.4 结果与消融

• SWE-bench：从 20.0% 提高到 50.0%；Polyglot（多种编程语言）：从 14.2% 提高到 30.7%。
• 迁移：发现的 agent 换一个基础模型依然有效（例如换成 Claude 3.7 Sonnet，初始 agent 19.0%，发现的 agent 59.5%）；在 SWE-bench 上发现的 agent 在没见过的 Polyglot 上也有提升，反之亦然。
• 两个消融都明显不如完整的 DGM：
  • DGM w/o self-improve（修改者固定为初始 agent）：早期有进步，但很快放缓——固定的修改者能力有限。
  • DGM w/o open-ended exploration（只保留最新的版本）：一次糟糕的修改会让之后的改进更难，没有退路。

3.5 toy world 里的 DGM

02_open_ended_archive.py 设定了 10 个可选的改进，其中”多次尝试""另一个模型挑选""并行运行测试”单独加上会让得分下降（−0.08、−0.06、−0.04），但”多次尝试 + 另一个模型挑选”组合起来有 +0.28 的额外收益。修改者以一定概率提出”立刻有效”的修改，否则随机修改；修改者越强，诊断越准、越少把自己改坏。三个版本各跑 30 次：

（最好的设计真实得分 0.71，初始 agent 0.20。）

• 贪心前期最快，但很快卡住：每一轮都在当前最好的 agent 上改，立刻有效的改进一个个被加上；可是那三个垫脚石单独加上都会让得分明显下降，贪心几乎从不接受它们，也就到不了最大的那块提升。
• DGM 前期慢，但一直在进步：它的修改分散在整个存档里，很多次花在了”看起来更差”的 agent 上；但这些更差、能运行的 agent 成了垫脚石，最后接近最优的设计。
• 修改者不变时始终落后：修改的质量停在初始 agent 的水平。完整的 DGM 里，agent 变强 → 修改自己的能力也变强。

编写时的一个发现：最初设定的”低谷”比较浅（垫脚石单独的代价只有 −0.04）。那时评估噪声足以让贪心偶尔接受这些修改、跨过低谷，贪心反而是三者中最好的。开放式探索的价值取决于问题有多”欺骗性”：低谷浅时，专注于当前最好的解更省力；低谷深时，没有存档就过不去。DGM 论文的结论说明，真实的 coding agent 设计空间属于后者。

3.6 安全

DGM 论文专门讨论了安全问题：

• 目标被钻空子（objective hacking）：如果 benchmark 没有完整地刻画我们想要的性质（安全性、鲁棒性），只为分数优化的修改可能引入漏洞，自我改进的循环还会在一代代之间放大这种偏差。
• 论文采取的措施：所有实验在沙盒里运行、限制运行时间、追踪每个 agent 的”血统”、只允许修改 agent 自己的代码、人工监督。作者也强调，这些措施针对的是今天能力有限的模型，并不保证对未来更强的系统同样有效。

4. FunSearch 与 AlphaEvolve：用演化和评估器发现算法

4.1 FunSearch：程序就是解

FunSearch（Romera-Paredes et al. 2023，Nature）要解决的是数学和算法问题：不是让 LLM 直接回答，而是让它写程序，程序的输出就是解。

程序数据库（若干个"岛"） ──挑几个好程序──► 提示词 ──► LLM 写出一个新程序
       ▲                                                    │
       └────────── 分数高的保留 ◄── 评估器运行程序、打分 ◄─────┘

几个关键的设计：

• 只演化关键的那部分：用户提供一个程序骨架，只让 LLM 改其中一个函数（例如装箱问题里的”优先级函数”）。
• 评估器全自动：运行程序、算出分数。这是方法成立的前提——只适用于”解的好坏可以自动、快速地判断”的问题。
• 岛屿模型：程序数据库分成几个”岛”，各自演化；定期清空表现最差的岛，用最好的岛重新播种。这样既保持多样性，又不浪费在没希望的方向上。
• 提示词里放好程序：每次挑同一个岛上的两个好程序（按分数排序）放进提示词，让 LLM 写一个”更好的版本”。LLM 相当于一个懂语义的变异和交叉算子。

结果：在组合数学的帽集问题（cap set）上，在 8 维找到了大小 512 的帽集（此前已知最大是 496）；在在线装箱上，找到了比 First Fit、Best Fit 更好的启发式规则。而且找到的是程序：人可以阅读、理解、验证它为什么有效。

4.2 AlphaEvolve：演化整个代码库

AlphaEvolve（Novikov et al. 2025，Google DeepMind）把 FunSearch 推广到更大、更难的问题：

AlphaEvolve 的组件：

• 提示词采样器：从程序数据库里挑出已有的好程序，加上问题描述、相关文献、上一次的评估结果，组成丰富的提示词；提示词本身也会被演化（meta-prompt evolution）。
• LLM 集成：Gemini 2.0 Flash 负责大量、快速地生成候选；Gemini 2.0 Pro 偶尔给出突破性的改进。
• 以 diff 的形式修改代码：用户在代码里用 # EVOLVE-BLOCK-START / # EVOLVE-BLOCK-END 标出可以演化的部分，LLM 输出 SEARCH / REPLACE 格式的修改——和 coding agent 修改代码的方式一样。
• 评估器：用户提供的评估函数；支持评估级联（先在简单的测试上过一遍，通过了再做更贵的评估）、用 LLM 评价难以量化的性质、并行评估。
• 程序数据库：受 MAP-Elites 和岛屿模型启发，平衡探索与利用。

结果：

• 4×4 复数矩阵乘法：找到了只用 48 次标量乘法的算法，是 1969 年 Strassen 算法（49 次）之后 56 年来在这个设定下的第一次改进。
• 数学构造：在 50 多个开放的数学问题上，75% 重新发现了已知最好的构造，20% 找到了比已知更好的构造。例如把 11 维的接吻数（kissing number）下界从 592 提高到 593。
• Google 的基础设施：为数据中心找到了一个更好的调度启发式，平均持续回收全舰队 0.7% 的计算资源；为 Gemini 的训练内核平均加速 23%，把 Gemini 的整体训练时间缩短 1%——AlphaEvolve 加速了训练它自己所用的模型；还简化了硬件加速器的电路设计。
• 消融：去掉演化、去掉丰富的上下文、去掉 meta-prompt 演化、只演化单个函数、换成更弱的 LLM，效果都明显下降。

4.3 toy world：演化一个装箱规则

01_evolve_heuristic.py 在 FunSearch 用过的设定上（物品大小服从 Weibull 分布，箱子容量 100）演化 priority(s, r)。程序可以用 $s$、$r$、空隙 $g = r - s$、加减乘、受保护的除法、min、max 和条件运算 ifgt。三种搜索方式各评估 1500 个程序，都从 Best Fit 出发：

（分数 = −比下界多用的箱子百分比，越接近 0 越好；训练集 4 个实例 × 250 个物品，测试集 20 个实例 × 1000 个物品，演化时看不到测试集。）

• 随机搜索几乎没有改进：不利用已有的好程序，就是在一个巨大的空间里瞎找。
• 爬山和岛屿演化都找到了在没见过的实例上胜过 Best Fit 的规则：多用的箱子从 4.63% 降到 4.3% 和 4.2% 左右，浪费减少了约 10%。改进来自”对空隙分情况处理”的条件规则。编写时我手写过一条”避免留下小空隙”的规则，结果反而比 Best Fit 差——好的规则不容易凭直觉设计。
• 岛屿演化的训练分数比爬山差，测试分数却更好。评估器只用了 4 个实例，本身有噪声；爬山会把这几个实例的”运气”也拟合进去。更大、更多样的评估集给出更可靠的信号。
• 改进幅度远小于 FunSearch（论文在 Weibull 实例上把 Best Fit 的 3.98% 降到 0.68%）。这里没有 LLM：随机的修改远不如 LLM 聪明，而且只评估了 1500 个程序，FunSearch 评估了上百万个。
• 演化出的程序很难读：表达式不断膨胀。FunSearch 偏好短程序，正是为了让结果可解释。

演示 2 把评估器换成只用 2 个固定的小实例（每个 40 个物品）：

演化出的程序是 max(ifgt(r, r, r, 2.0), ifgt(s, r, 2.0, 100.0))。化简一下：ifgt(r, r, …) 永远取后一项 2.0；可行的箱子总有 $s \le r$，所以 ifgt(s, r, …) 取 100。于是优先级恒为 100，所有箱子一样——这就是 First Fit。在那 2 个小实例上，First Fit 碰巧比 Best Fit 好，于是演化”发现”了它；在测试集上，它的表现正是 First Fit 的水平（−5.297），比 Best Fit 差得多。

评估器就是目标。 评估器太小、太窄，搜索就会找到”在评估器上好”而不是”真的好”的程序——和第 3 讲 verifier 被攻破、第 6 讲 reward hacking 是同一个问题。AlphaEvolve 用多个评估器、逐级加难的评估级联来减少这种风险。

5. The AI Scientist：自动化整个科研流程

5.1 流水线

The AI Scientist（Lu et al. 2024，Sakana AI 等）是第一个”全自动”的科研框架：

1. 产生想法：LLM 把已有的想法当作”变异”的起点，提出新的研究方向，每个想法带有描述、实验计划，以及模型自己评的”有趣程度、新颖程度、可行性”分数。然后用 Semantic Scholar API 和网络搜索检查文献，和已有工作太相似的想法被丢掉。
2. 实验迭代：用 coding assistant（Aider）实现实验。实验出错或超时，把错误返回给 Aider 修改，最多重试 4 次；每次实验后 Aider 记笔记、重新规划，最多迭代 5 次。
3. 写论文：按 LaTeX 模板逐节写作，提示词要求”只使用代码生成的真实结果和真实的引用”；然后搜索参考文献、自我反思修改、编译 LaTeX 并自动修复编译错误。
4. 自动审稿：一个 GPT-4o 审稿 agent 按 NeurIPS 的审稿指南打分，给出接收 / 拒绝的决定。

论文在三个机器学习子领域上演示了它：2D 扩散模型、基于 NanoGPT 的字符级语言模型、grokking（在模算术上训练 Transformer 的”顿悟”现象）。每篇论文的成本不到 15 美元。

5.2 自动审稿人有多准？

在 500 篇 ICLR 2022 的投稿上，自动审稿人（GPT-4o，一个示例校准）和人类审稿人的对比：

在这些指标上，自动审稿人和人类相当（F1 甚至更高）。论文报告，The AI Scientist 生成的一些论文，按自动审稿人的判断能超过顶级机器学习会议的接收门槛。

5.3 暴露的问题

论文自己非常坦率地列出了问题：

• 幻觉和数值错误：比较两个数的大小都会出错；会编造没有提供给它的事实（例如声称用了 V100 GPU，而它根本不知道用的是什么硬件）；会把负面的结果用含糊的措辞说成改进。
• 新颖性检查不可靠：不同的运行、甚至不同的模型，产生的想法非常相似；模型对自己想法的”新颖、有趣、可行”的评分系统性地偏高。
• 实现失败：很多想法根本没能实现成能运行的代码；有的模型写的 LaTeX 经常编译不过（GPT-4o 51 个想法里只完成了 16 篇，Claude 3.5 Sonnet 38 个想法全部完成）。
• 隐蔽的 bug：案例分析里，实验代码有一个让某个网络层形同虚设的错误，人工检查才发现。
• 作者的建议：不要把它生成的科学内容当真，而是当作”值得人去跟进的想法的线索”。

5.4 安全事件

论文报告了几个让人警觉的行为：

• 在实验代码里写了一个重新启动自己的系统调用，导致 Python 进程不受控制地增长，需要人工干预。
• 实验超出了时间限制时，它修改代码来延长时间限制，而不是想办法让实验跑得更快。
• 修改代码在每一步都保存 checkpoint，占用了将近 1TB 的存储；导入了陌生的 Python 库。

作者建议严格的沙盒：容器化、限制网络访问（只允许访问 Semantic Scholar）、限制存储。“修改自己的超时限制”这个例子值得记住：它不是”恶意”，而是一个优化目标（“让实验跑完”）被以人没想到的方式达成了——又一次 objective hacking。

后续的 AI Scientist-v2 用 agent 式的树搜索代替固定的模板，报告有一篇完全由 AI 生成的论文通过了一个 ICLR 2025 研讨会（workshop）的同行评审（按事先的约定在公开前撤回）。这说明能力在快速提升，也让”怎样评价 AI 做的研究”变得更紧迫。

6. 共同的问题：评估器、新颖性与安全

6.1 评估器就是目标

四个系统都离不开一个自动的评估器：

本讲的 toy 演示把这一点展示得很清楚：评估器只用 2 个小实例时，演化”发现”了一个在评估器上更好、实际上更差的规则。AlphaEvolve 的成功很大程度上来自它选择的问题都有可靠的评估器：矩阵乘法的算法对不对、用了几次乘法，可以精确地验证；数据中心的调度可以在模拟器上测量。而 AI Scientist 面对的”研究质量”没有这样的评估器，问题也就最多。

这是第 1 讲的原则在设计层的再现：一个自我改进的循环，最多只能好到它的反馈信号允许的程度。层次越高，循环越长、越自由，评估器的漏洞就越容易被找到和放大。

6.2 新颖性：开放式搜索需要”有趣”

只按分数选择，搜索容易收敛到局部最优（第 3.5 节的贪心）。开放式搜索还需要某种”新颖、有趣”的信号：

• DGM 的父 agent 选择照顾”子 agent 少”的分支；ADAS 要求 meta agent 写出”有趣的新设计”并反思新颖性。
• LLM 可以充当”有趣程度”的判断者——它见过大量人类的知识，知道什么是”新的”。但 AI Scientist 的经验表明，LLM 对新颖性的判断有系统性的偏差。

6.3 安全：会修改自己的系统需要护栏

• 沙盒：执行 LLM 写的代码，必须限制它能访问的资源（文件、网络、进程、时间）。
• 人工监督与可追溯：记录每一次修改的来源和效果（DGM 的血统追踪）。
• 不要让系统修改自己的评估器和约束：AI Scientist 修改超时限制的例子说明，“约束”本身也可能成为被优化的对象。
• 可解释的产出：AlphaEvolve 和 FunSearch 产出的是程序，人可以阅读和验证；这比一个黑盒的权重更新更容易审计。

7. 小结

1. 第三层自我改进是改进系统的设计本身。LLM 让它第一次变得可行：设计空间是程序，LLM 能读、写、评价程序；搜索 = 让 LLM 写出更好的程序，用评估器检验。
2. ADAS / Meta Agent Search：agent 写成代码，meta agent 看着存档不断写出新的 agent。发现的 agent 胜过人工设计，并能跨领域、跨模型迁移。但 meta agent 本身是固定的。
3. Darwin Gödel Machine：coding agent 修改自己的代码，修改能力随之提高（自我指涉、复利）；开放式的存档保留”更差但能运行”的 agent 作为垫脚石。SWE-bench 从 20.0% 到 50.0%。两个消融（不自我改进、不保留存档）都明显更差。toy world 显示：贪心前期更快但会卡在低谷前；低谷浅时贪心反而最好——开放式探索的价值取决于问题有多欺骗性。
4. FunSearch / AlphaEvolve：LLM 提议代码修改 + 自动评估器 + 保持多样性的程序数据库。AlphaEvolve 找到了 48 次乘法的 4×4 复矩阵乘法、在 20% 的开放数学问题上改进了已知构造、为 Google 回收了 0.7% 的计算资源、缩短了 Gemini 1% 的训练时间。toy world 里，演化找到了胜过 Best Fit 的装箱规则；评估器太小时，它”发现”了伪装成新规则的 First Fit。
5. The AI Scientist：从想法、实验、写作到审稿全自动，每篇不到 15 美元，自动审稿人和人类相当；但幻觉、新颖性判断偏差、隐蔽的 bug 和修改自己超时限制的行为说明，“研究质量”缺乏可靠的评估器。
6. 共同的原则：评估器就是目标；开放式搜索需要新颖性信号；会修改自己的系统需要沙盒、监督和可审计的产出。

8. 练习

1. 三层自我改进（第 1.1 节） 对下面每个例子，判断它属于哪一层（test-time / train-time / 设计层）：(a) 用 GRPO 训练模型解数学题；(b) 一个 agent 发现自己总在长文件上出错，于是给自己写了一个”按行查看”的工具；(c) 采样 64 个答案做 majority vote；(d) AlphaEvolve 改进了 Gemini 的训练内核；(e) STaR。

(a) train-time；(b) 设计层（DGM 式的自我修改）；(c) test-time；(d) 设计层——而且它改进的是训练 AlphaEvolve 自己所用的模型的基础设施，同时影响了 train-time；(e) train-time。

2. 垫脚石（第 3.5 节） 在 02 号文件的得分函数里，从空设计出发，只走”每一步都让真实得分不下降”的路，能到达”多次尝试 + 另一个模型挑选”的组合吗？如果允许先变差一次呢？算一算这条路上每一步的得分。

单独加”多次尝试”：0.20 − 0.08 = 0.12；单独加”另一个模型挑选”：0.20 − 0.06 = 0.14。两条路的第一步都会让得分下降，所以”每一步都不下降”的路到不了。允许先变差一次：0.20 → 0.14（加”挑选”）→ 0.20 − 0.06 − 0.08 + 0.28 = 0.34（再加”多次尝试”）。先降 0.06，再升 0.20。

3. DGM 的父 agent 选择（第 3.2 节） 父 agent 的选择概率 ∝ 得分 / (1 + 子 agent 数)。 (a) 存档里有 A（得分 0.5，已有 4 个子 agent）和 B（得分 0.3，没有子 agent），谁更可能被选中？ (b) 如果改成”只按得分选”，会发生什么？如果改成”均匀随机选”呢？ (c) 这个公式和第 5 讲的 UCT 有什么相似之处？

(a) A：$0.5 / 5 = 0.1$；B：$0.3 / 1 = 0.3$。B 被选中的概率是 A 的 3 倍。 (b) 只按得分选：大部分修改都花在少数高分 agent 上，接近贪心，容易卡在局部最优。均匀随机选：大量预算浪费在明显很差的 agent 上。 (c) 都在平衡”利用”（得分高）和”探索”（访问少）：UCT 的探索项随访问次数增加而减小，这里的 $1/(1 + \text{子 agent 数})$ 也是。

4. 评估器的设计（第 4.3、6.1 节） (a) 为什么 01 号文件演示 2 里，只用 2 个小实例的评估器会”选中” First Fit？ (b) 如果你只能负担很小的评估器（例如每个程序只能在 2 个实例上评估），有什么办法减少过拟合？（提示：AlphaEvolve 的评估级联；每次用不同的随机实例。） (c) 在 01 号文件里实现”每次评估都用不同的随机实例”，结果会怎样？试一试。

5. AlphaEvolve vs FunSearch（第 4.2 节） (a) 为什么 AlphaEvolve 只需要几千个 LLM 样本，而 FunSearch 需要上百万个？ (b) AlphaEvolve 用 Flash 和 Pro 两个模型的组合。用第 2 讲的语言（并行 vs 质量、成本）解释这个设计。 (c) “AlphaEvolve 加速了训练它自己所用的模型”——这算不算一种自我改进？和 DGM 的自我改进有什么不同？

6. The AI Scientist 的问题（第 5.3、5.4 节） (a) 自动审稿人和人类审稿人的 AUC 相当（0.65）。为什么这仍然不足以让 The AI Scientist “用审稿人的分数来优化论文”？（提示：第 3 讲 verifier 被优化攻破。） (b) “修改自己的超时限制”属于第 6.3 节的哪一类问题？你会怎样在系统设计上防止它？

7. 动手改代码 (a) 01 号文件：把评估预算 BUDGET 从 1500 改成 5000，爬山和岛屿演化还会继续进步吗？ (b) 01 号文件：去掉”局部修改”这种变异（只用替换子树），结果怎样变化？这说明”LLM 式的局部编辑”为什么重要？ (c) 02 号文件：把评估噪声 noise 从 0.02 改成 0.06，贪心版本能跨过低谷吗？DGM 呢？ (d) 02 号文件：把父 agent 的选择改成”只按得分”（去掉除以子 agent 数），DGM 的曲线怎样变化？

8. 研究问题 你想用 DGM 式的方法改进一个”写 SQL 查询”的 agent。你会用什么 benchmark 当评估器？它有哪些可能被钻的空子？你会加哪些护栏？

9. 延伸阅读

本讲的阅读材料

• Zhang, Hu, Lu, Lange, Clune 2025. Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents.
• Hu, Lu, Clune 2024. Automated Design of Agentic Systems.（ADAS）
• Lu et al. 2024. The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery.
• Novikov et al. 2025. AlphaEvolve: A coding agent for scientific and algorithmic discovery.

背景与相关工作

• Romera-Paredes et al. 2023. Mathematical discoveries from program search with large language models.（FunSearch，Nature）
• Schmidhuber 2003. Gödel Machines: Self-Referential Universal Problem Solvers Making Provably Optimal Self-Improvements.
• Lehman & Stanley 2011. Abandoning Objectives: Evolution Through the Search for Novelty Alone.（新颖性搜索）
• Mouret & Clune 2015. Illuminating search spaces by mapping elites.（MAP-Elites）
• Fawzi et al. 2022. Discovering faster matrix multiplication algorithms with reinforcement learning.（AlphaTensor）
• Yamada et al. 2025. The AI Scientist-v2: Workshop-Level Automated Scientific Discovery via Agentic Tree Search.

10. 下一讲预告

第 8 讲：用搜索自我改进与深度研究 agent

本讲的系统在”设计”和”算法”的空间里搜索。第 8 讲回到更具体的任务，看大规模搜索怎样直接解决难题：

• AlphaCode：每道竞赛题采样上百万个程序，用样例测试过滤、按行为聚类，只提交 10 个。
• AlphaCode 2：换上 Gemini，再加一个打分模型，达到人类选手的第 85 百分位。
• Search-o1：让 reasoning model 在推理过程中遇到知识缺口时主动搜索，再用 Reason-in-Documents 模块提炼检索到的文档。