1
00:00:00,100 --> 00:00:06,432
本内容改编自小山学堂《学 AI 产品，从入门到精通》，为二次演绎配音版。

2
00:00:06,382 --> 00:00:11,394
这一集解决一个很有野心的问题，能不能让 Agent 改进它自己。

3
00:00:11,394 --> 00:00:18,485
前面所有讲的东西，无论是提示词、工具还是上下文治理，都是人在改机器。

4
00:00:18,485 --> 00:00:21,442
这一集反过来，让机器改自己。

5
00:00:21,442 --> 00:00:27,596
这件事听起来像科幻，但它已经有一批具体的系统和一批具体的论文了。

6
00:00:27,596 --> 00:00:29,627
今天我们走三段。

7
00:00:29,627 --> 00:00:38,725
第一段看两条技术路线，一条叫 STOP，改善的是改善器本身，另一条叫 Self-Harness，让 Agent 给自己做绩效复盘。

8
00:00:38,725 --> 00:00:44,783
第二段看进化搜索，为什么在 Harness 这个设计空间里，进化比梯度更务实。

9
00:00:44,783 --> 00:00:53,774
第三段回到现实，自我改进路上还有七道关没过去，以及你今天就能给自己的 Agent 立起来的三条长跑规矩。

10
00:00:53,932 --> 00:00:58,329
第一条路线叫 STOP，二零二三年 Zelikman 他们的工作。

11
00:00:58,279 --> 00:01:01,103
它的思路可以用一个比喻说清楚。

12
00:01:01,103 --> 00:01:03,603
想象一个会磨刀的工匠。

13
00:01:03,603 --> 00:01:08,231
普通做法是用刀切菜，也就是用工具去解决问题。

14
00:01:08,231 --> 00:01:12,978
STOP 的做法是先练好磨刀的手艺，刀自然越来越锋利。

15
00:01:12,978 --> 00:01:21,103
更妙的是，磨刀这门手艺本身也可以被磨，用改进的方法来改进改进方法本身，一层套一层。

16
00:01:21,103 --> 00:01:28,351
落到技术上，它的核心思想是，不改善一个解，而是改善产生更好解的那个改善器。

17
00:01:28,351 --> 00:01:36,536
种子改善器接受三个输入，初始解、效用函数、还有一个黑盒语言模型，返回改善后的解。

18
00:01:36,536 --> 00:01:47,077
关键洞察在于，改善器本身也是文本，它是一段提示词或者一段代码，因此可以把同样的改善逻辑作用在改善器自己身上。

19
00:01:47,077 --> 00:01:53,483
那个递归公式看着吓人，其实只有一句话，让今天的自己去升级昨天的自己。

20
00:01:53,483 --> 00:01:58,747
就像你用三点零版的学习方法，总结出四点零版的学习方法。

21
00:01:58,747 --> 00:02:00,574
结果很有意思。

22
00:02:00,574 --> 00:02:11,692
改善后的改善器自动发现了遗传算法、分解改进、多臂老虎机、模拟退火、定向搜索这些经典优化策略，没有任何人类预设。

23
00:02:11,692 --> 00:02:14,408
但这里有一条非常重要的警示。

24
00:02:14,408 --> 00:02:16,548
递归不等于必然改善。

25
00:02:16,548 --> 00:02:23,002
实验里 GPT-4 能持续改善，而 GPT-3.5 和 Mixtral 反而退化。

26
00:02:23,002 --> 00:02:28,327
也就是说，递归结构只给出了改善的可能性，不保证收敛。

27
00:02:28,327 --> 00:02:35,382
弱模型在元级操作里缺乏足够的编程直觉，反而会放大噪声，结果不进反退。

28
00:02:35,382 --> 00:02:43,387
这提示我们一件很实际的事，自我改进系统的安全性，必须建立在对基座能力的准确评估之上。

29
00:02:43,387 --> 00:02:46,872
不是所有模型都配跑这套循环。

30
00:02:47,020 --> 00:02:51,657
第二条路线叫 Self-Harness，二零二六年 Zhang 他们的工作。

31
00:02:51,607 --> 00:02:56,379
它更像一个员工自己给自己做绩效复盘，一共三步。

32
00:02:56,379 --> 00:03:02,557
第一步，翻出所有搞砸的案例，找出反复踩的坑，这一步叫弱点挖掘。

33
00:03:02,557 --> 00:03:09,492
它不是简单地数失败次数，而是把失败轨迹聚类成有验证器支撑的失败模式。

34
00:03:09,492 --> 00:03:19,588
每一条失败记录要包含三样东西，终端验证器给出的原因、相关 Agent 行为的因果状态、以及这条轨迹暴露出来的抽象机制。

35
00:03:19,588 --> 00:03:23,278
三样都有，才算一条能用的失败模式。

36
00:03:23,278 --> 00:03:28,422
第二步，针对性地改自己的工作手册，这一步叫提出修改方案。

37
00:03:28,422 --> 00:03:36,343
模型拿到四样东西，可编辑面、失败模式摘要、通过行为的记录、以及已经尝试过的编辑历史。

38
00:03:36,343 --> 00:03:41,607
它优先选择那些可寻址的、重复出现的错误模式去改。

39
00:03:41,607 --> 00:03:48,951
第三步，用新手册试运行一段时间，确认老本事没退步、新毛病没出现，才正式采用。

40
00:03:48,951 --> 00:03:54,371
这一步用留出集和保留集分别验证，只接受没有回归的编辑。

41
00:03:54,371 --> 00:04:05,934
跟 STOP 最大的差别在于，Self-Harness 操作的不是纯文本改善器，而是 Agent 真正的运行时编排系统，包括 system prompt、工具调度策略、验证规则。

42
00:04:05,934 --> 00:04:14,047
实验在 Terminal-Bench-2 上对几个不同模型跑下来，同一个框架为不同基座学到了模型特定的指令。

43
00:04:14,047 --> 00:04:21,956
这个结果很有说服力，它说明 Harness 改进确实是上下文敏感的，不存在一套通吃的最优配置。

44
00:04:21,956 --> 00:04:24,732
这里还藏着一个安全边界问题。

45
00:04:24,732 --> 00:04:30,513
如果程序被允许编辑操作系统层面的配置，抽象边界就被打破了。

46
00:04:30,513 --> 00:04:39,576
所以可编辑面必须精心设计，权限控制和安全层要在改进循环之外，由人类或者不可篡改的机制保障。

47
00:04:39,576 --> 00:04:43,614
没有边界的自我改进，是失控的自我改进。

48
00:04:43,756 --> 00:04:46,602
第二条大路线是进化搜索。

49
00:04:46,552 --> 00:04:50,434
先回答一个问题，为什么是进化，不是别的。

50
00:04:50,434 --> 00:05:05,883
因为 Harness 由提示词、工具调用策略、上下文管理逻辑和代码片段共同组成，这些组件的组合空间庞大而且形状奇特，没法用梯度直接优化，但是评估一个候选 harness 的好坏却很容易。

51
00:05:05,883 --> 00:05:10,847
能打分、不能求解，这正是进化搜索最擅长的领域。

52
00:05:10,847 --> 00:05:14,356
说人话就是大自然选育庄稼的套路。

53
00:05:14,356 --> 00:05:22,157
种一大片，长得好的留种，长得差的淘汰，偶尔杂交变异一下，一代代下来庄稼越来越好。

54
00:05:22,157 --> 00:05:24,429
具体有三个契合条件。

55
00:05:24,429 --> 00:05:32,397
第一，搜索空间庞大而且高度离散，自然语言、代码、配置混在一起，组合爆炸。

56
00:05:32,397 --> 00:05:40,558
第二，梯度不可用但评估容易，你没法对一段提示词求导，但可以在基准测试上直接跑出分数。

57
00:05:40,558 --> 00:05:48,575
第三，多样性本身有价值，不同任务可能需要不同风格的 harness，而进化天然维护种群多样性。

58
00:05:48,575 --> 00:05:57,782
这一条常常被忽略，但很重要，因为我们最终要的不是某一个最强解，而是一批能应对不同场景的解。

59
00:05:57,940 --> 00:05:59,909
两个代表性系统。

60
00:05:59,859 --> 00:06:05,868
AlphaEvolve 是二零二五年 Novikov 他们的工作，把选育庄稼用在程序代码上。

61
00:06:05,868 --> 00:06:15,039
它维护一个候选程序池，用冻结的语言模型生成代码改动来改进程序，反复评估并保留表现最好的。

62
00:06:15,039 --> 00:06:20,111
谷歌用它真的发现了比人类已知更快的矩阵乘法算法。

63
00:06:20,111 --> 00:06:22,948
它的设计里有几个细节值得学。

64
00:06:22,948 --> 00:06:28,452
可改进的区域是用显式标记圈出来的，不是整个文件随便改。

65
00:06:28,452 --> 00:06:33,272
指令和上下文本身也参与共同进化，不会固定不变。

66
00:06:33,272 --> 00:06:43,645
而且消融实验证明了进化流程、上下文、元提示、全文件进化、更强的模型，各自都有独立贡献，不是某一项在撑着。

67
00:06:43,645 --> 00:06:45,412
DGM 更激进。

68
00:06:45,412 --> 00:06:53,669
它进化的对象是 Agent 自己的操作系统，也就是它自己的 harness 代码，已经超出了改别人代码的范畴。

69
00:06:53,669 --> 00:07:06,385
流程是初始化、按性能概率选父代、父代反思自己的评估日志并提出改进方案、修改自己的代码产生新 Agent、评估、只有性能足够高才回到池子里。

70
00:07:06,385 --> 00:07:17,864
基于 Claude 3.5 Sonnet 的实验里，SWE-bench Verified 从百分之二十涨到百分之五十，Polyglot 从百分之十四点二涨到百分之三十点七，全程没有人类介入。

71
00:07:17,864 --> 00:07:20,520
但进化搜索不是万能的。

72
00:07:20,520 --> 00:07:30,255
它适合候选解可自动评估、指标容易量化的场景，比如矩阵乘法加速、算子优化、算法竞赛、数据中心调度。

73
00:07:30,255 --> 00:07:36,950
不适合评估很慢、标准模糊或者主观、预算有限、需要人工审核的场景。

74
00:07:36,950 --> 00:07:45,556
而且计算开销不可忽视，每一代要多少次评估和每代能提升多少，这个平衡仍然是开放问题。

75
00:07:45,700 --> 00:07:51,960
进展是真的，但通往完整递归自我改进的路还很长，研究者列了七道关。

76
00:07:51,910 --> 00:07:54,229
我们挑最要命的几道讲。

77
00:07:54,229 --> 00:07:57,018
第一道，弱且模糊的评估器。

78
00:07:57,018 --> 00:08:03,737
编程有单元测试，数学有证明，但很多研究声明没有快速精确的验证器。

79
00:08:03,737 --> 00:08:09,097
研究品味、新颖性、长期科学价值，这些极难衡量。

80
00:08:09,097 --> 00:08:16,465
有个比方很贴切，健身有体重秤，代码有测试，但一篇论文有没有价值，没有秤可称。

81
00:08:16,465 --> 00:08:21,657
没有秤，再努力的减肥计划也不知道自己是瘦了还是胖了。

82
00:08:21,657 --> 00:08:25,624
反馈信号一旦模糊，改进方向就可能是错的。

83
00:08:25,624 --> 00:08:29,157
第二道，上下文与记忆的生命周期。

84
00:08:29,157 --> 00:08:33,664
记忆需求会随着 Agent 自主性增长而爆炸式增长。

85
00:08:33,664 --> 00:08:40,684
当前的上下文工程大多还停留在软件系统层，但它应该成为智能本身的核心部分。

86
00:08:40,684 --> 00:08:46,813
一个不能管理自己记忆的 Agent，没法完成跨天、跨周的复杂研究任务。

87
00:08:46,813 --> 00:08:49,313
第三道，多样性坍缩。

88
00:08:49,313 --> 00:08:59,229
进化算法天然倾向于利用已知的高奖励模式，当种群里所有候选解都坍缩成同一方案的微小变体，创新就停止了。

89
00:08:59,229 --> 00:09:06,693
有个比方很形象，全班都抄第一名的作业，短期分数好看，但再也不会有人想出新解法。

90
00:09:06,693 --> 00:09:08,893
第四道，奖励黑客。

91
00:09:08,893 --> 00:09:17,823
优化单元测试会过拟合测试用例，优化评判模型会学会钻空子，优化榜单分数会利用榜单漏洞。

92
00:09:17,823 --> 00:09:21,765
这是自我改进循环里最危险的反模式之一。

93
00:09:21,765 --> 00:09:28,496
解法只有一个，评估器和权限控制必须在进化循环之外，由独立机制维护。

94
00:09:28,496 --> 00:09:34,938
用考试打个比方，如果只看分数，学生就会背题库、找漏洞、甚至改成绩单。

95
00:09:34,938 --> 00:09:38,917
所以出卷人和改卷人绝不能是学生自己。

96
00:09:38,917 --> 00:09:46,645
这一条放在工程上也很具体，谁写的代码，谁就不能同时维护评价这段代码的标准。

97
00:09:46,780 --> 00:09:51,633
顺带说一个容易混淆的事，能写论文不等于能做科学。

98
00:09:51,583 --> 00:09:58,567
已经有系统能协调自动研究循环的大部分环节，但论文产出并不等于科学发现。

99
00:09:58,567 --> 00:10:06,283
系统可以写出看似合理的论文，却可能包含虚假引用、实现漂移或者薄弱的实验结果。

100
00:10:06,283 --> 00:10:13,086
有研究系统测试了从想法到论文的全流程，总结出六种反复出现的失败模式。

101
00:10:13,086 --> 00:10:18,867
训练数据默认值偏好，倾向于用旧库、过时命令和标准模板。

102
00:10:18,867 --> 00:10:24,756
执行压力下的实现漂移，遇到复杂度墙就转向更简单的替代方案。

103
00:10:24,756 --> 00:10:29,708
记忆与上下文退化，长期项目里逐渐丢失关键细节。

104
00:10:29,708 --> 00:10:34,432
过度乐观，宣称显著优于基线但实际充满噪声。

105
00:10:34,432 --> 00:10:41,115
领域智能不足，缺少那些论文不会写、但实验室里每个人都知道的隐性技艺。

106
00:10:41,115 --> 00:10:47,196
以及科学品味薄弱，实验能执行，但判断不了这个问题值不值得问。

107
00:10:47,196 --> 00:10:51,812
这六种不是偶发的 bug，是当前自动研究的结构性瓶颈。

108
00:10:51,812 --> 00:10:58,290
它们还有一个共同点，全部都跟评估有关，要么评估不了，要么评估得不准。

109
00:10:58,290 --> 00:11:02,966
所以别急着给研究循环加更多算力，先把秤造出来。

110
00:11:02,966 --> 00:11:13,446
最后一条尤其值得琢磨，科学品味这种东西，恰恰是最难写成评估指标的，而它又恰恰决定了整个循环的方向对不对。

111
00:11:13,588 --> 00:11:17,360
讲完很远的东西，回到你今天就能做的事。

112
00:11:17,310 --> 00:11:21,937
所有自我改进的前提，是先有一个能长跑的 Harness。

113
00:11:21,937 --> 00:11:25,098
它跑十轮很聪明，跑五十轮呢。

114
00:11:25,098 --> 00:11:29,966
用户说它聊着聊着变笨了，背后是一条很具体的曲线。

115
00:11:29,966 --> 00:11:41,432
上下文占用一轮一轮往上爬，爬满之后系统只能悄悄扔东西，而扔掉的往往是最早的消息，也就是你一开始交代的那些最重要的规矩。

116
00:11:41,432 --> 00:11:50,218
不做任何管理的话，连续对话二十轮，大概第十四轮就撞上阈值，之后每一轮都在悄悄丢最早的消息。

117
00:11:50,218 --> 00:11:52,947
三条规矩，对应三种失忆。

118
00:11:52,947 --> 00:11:57,430
第一，压缩阈值，占用到线就压，别等报错。

119
00:11:57,430 --> 00:12:06,949
第二，永不删除清单，用户的原话、定好的需求、安全约束，这些进了摘要就找不回来，必须钉死在上下文里。

120
00:12:06,949 --> 00:12:12,562
第三，落盘笔记，重要结论写进文件，下次开工先读文件。

121
00:12:12,562 --> 00:12:14,762
第三条的份量最重。

122
00:12:14,762 --> 00:12:19,533
这就是文件系统持久记忆，也是 Harness 自我改进的起点。

123
00:12:19,533 --> 00:12:23,908
它连自己上次学到什么都记不住，就谈不上改进自己。

124
00:12:23,908 --> 00:12:26,576
给你三个可以立刻动手的清单。

125
00:12:26,576 --> 00:12:34,028
第一，翻出你最长的一次对话，找到它第一次忘掉前面交代过的事是在第几轮，记下这个数。

126
00:12:34,028 --> 00:12:44,473
第二，把三条规矩写具体，占用到百分之多少触发压缩，哪些内容永远不进压缩区，注意要列清单，别写重要内容这种废话。

127
00:12:44,473 --> 00:12:51,264
第三，跑通一次落盘再读回，关掉会话开个全新的，第一句就让它读笔记继续干。

128
00:12:51,264 --> 00:12:57,394
新会话能无缝接上，你就亲手实现了最朴素也最管用的长期记忆。

129
00:12:57,394 --> 00:13:11,841
这三条里，第一花十五分钟，第二花一小时，第三花半天，你可以按自己的场景挑一个开始，不必一次做完，但至少要把第二条写具体，因为它决定了你后面所有优化的上限。

130
00:13:11,980 --> 00:13:15,030
最后给你几条能直接拿走的东西。

131
00:13:14,980 --> 00:13:19,031
把这四节课连起来看，有一条很清楚的分界线。

132
00:13:19,031 --> 00:13:31,411
前两节讲的是已经跑通的循环，后两节讲的是还没过去的关卡，而决定一条技术落在哪一侧的，往往不是算法有多巧，而是你有没有一个可靠的打分办法。

133
00:13:31,411 --> 00:13:35,810
先想清楚这一件事，剩下的判断都会变得简单。

134
00:13:35,810 --> 00:13:39,752
第一，先问能不能打分，再决定用什么方法。

135
00:13:39,752 --> 00:13:47,180
搜索空间庞大、梯度不可用、但评估容易，这时候进化比任何精巧的梯度方案都务实。

136
00:13:47,180 --> 00:13:54,235
反过来，如果你的评估很慢或者很主观，任何自动改进循环都是在噪声里瞎跑。

137
00:13:54,235 --> 00:13:58,586
第二，评估器和权限控制必须在改进循环之外。

138
00:13:58,586 --> 00:14:04,295
这是奖励黑客那道题的唯一解法，也是自我改进系统安全的底线。

139
00:14:04,295 --> 00:14:09,752
让被优化的对象去维护评价标准，等于让学生自己改成绩单。

140
00:14:09,752 --> 00:14:12,817
第三，记住递归不等于必然改善。

141
00:14:12,817 --> 00:14:16,615
基座能力不够的时候，递归只会放大噪声。

142
00:14:16,615 --> 00:14:21,399
上这套循环之前，先诚实评估你的模型够不够强。

143
00:14:21,399 --> 00:14:25,233
第四，先立长跑规矩，再谈自我改进。

144
00:14:25,233 --> 00:14:32,877
压缩阈值、永不删除清单、落盘笔记，这三条今天就能写进你的配置里，而且立刻见效。

145
00:14:32,877 --> 00:14:36,759
第五，人在栈里向上移动，不是退出循环。

146
00:14:36,759 --> 00:14:45,738
随着 AI 接管越来越多的执行层，人的价值在于在正确的层级提供监督，设定目标、判断方向、守住底线。

147
00:14:45,738 --> 00:14:49,668
完全自主不是终点，人机协作的质量才是。

148
00:14:49,668 --> 00:14:51,771
这一集就到这里。