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

2
00:00:06,382 --> 00:00:15,516
这一集讲一个正在发生的迁移，优化的对象正在从提示词内容，一层一层往上搬到管理机制的代码本身。

3
00:00:15,516 --> 00:00:18,750
先把这张梯子摆出来，一共五级。

4
00:00:18,750 --> 00:00:27,067
第一级指令提示词，第二级结构化上下文，第三级工作流，第四级 Harness 代码，第五级优化器代码。

5
00:00:27,067 --> 00:00:34,218
背后的规律是，模型越智能、越强大，我们能优化的目标就越复杂、方法也越通用。

6
00:00:34,218 --> 00:00:39,699
这条演进线从调提示词，一路走到优化写优化器的代码。

7
00:00:39,699 --> 00:00:41,574
为什么要往上搬。

8
00:00:41,574 --> 00:00:49,086
因为随着智能体任务变长，上下文管理不再是可选项，它正在成为 Harness 优化的核心战场。

9
00:00:49,086 --> 00:00:56,718
把所有工具响应和模型生成简单追加到上下文里，随着任务时长增加会迅速失控。

10
00:00:56,718 --> 00:01:01,177
而失控的方式很隐蔽，不是报错，是注意力被稀释。

11
00:01:01,177 --> 00:01:07,415
这一集分两半，前半讲上下文工程三级跳，ACE、MCE、Meta-Harness。

12
00:01:07,415 --> 00:01:12,175
后半讲工作流设计怎么从手工变成自动搜索。

13
00:01:12,320 --> 00:01:16,236
先说 ACE，它是 Agentic Context Engineering 的缩写。

14
00:01:16,186 --> 00:01:22,460
说人话是这样，上下文就是 AI 的工作记忆，它眼前能看到的所有资料。

15
00:01:22,460 --> 00:01:28,470
ACE 的思路是，别让记忆变成一锅粥，要维护一本条理清晰的工作手册。

16
00:01:28,470 --> 00:01:36,330
干活的人照手册干活，复盘的人总结经验教训，管手册的人把教训一条条整理进手册。

17
00:01:36,330 --> 00:01:39,623
手册越用越精，不会越用越厚。

18
00:01:39,623 --> 00:01:41,967
三个组件分工明确。

19
00:01:41,967 --> 00:01:47,484
生成器执行任务、生成轨迹，参考手册里的条目作为指引。

20
00:01:47,484 --> 00:01:53,001
反思器从成功和失败的轨迹中提炼洞察，萃取经验教训。

21
00:01:53,001 --> 00:01:59,659
策展器用增量的、条目化的更新去维护结构化上下文，定期精炼去重。

22
00:01:59,659 --> 00:02:02,292
关键设计在策展器这一环。

23
00:02:02,292 --> 00:02:11,775
它输出结构化的条目，每条有一个标识和一段描述，然后用确定性的逻辑合并进手册，从不重写整块提示词。

24
00:02:11,775 --> 00:02:25,116
这一点是整个框架的命门，它避免了迭代重写时的两个经典问题，一个是上下文坍缩，越重写越短；另一个是简洁偏差，越重写越泛，最后只剩下正确的废话。

25
00:02:25,116 --> 00:02:31,835
这里有个值得记住的判断，上下文是不断演进的剧本，不能任由提示词不断增长。

26
00:02:31,835 --> 00:02:37,568
增长和演进是两回事，增长是往里加，演进是加的同时也在整理。

27
00:02:37,568 --> 00:02:42,724
为什么重写整块提示词这条路走不通，值得多说两句。

28
00:02:42,724 --> 00:02:53,518
每次让模型把整份上下文重新压缩一遍，它都会倾向于保留那些放之四海皆准的内容，丢掉那些看着琐碎但关键的具体经验。

29
00:02:53,518 --> 00:03:04,275
压缩十次之后，你手里剩下的是一份政治正确的通用指南，而真正让它在这个任务上做得好的那些细节，早就被当作噪音抹掉了。

30
00:03:04,275 --> 00:03:10,597
这就是简洁偏差，它不是模型的错，是重写这个动作本身的结构性后果。

31
00:03:10,597 --> 00:03:21,042
反过来看条目化更新的好处，它是单调的，一条经验写进去就不会在下一轮被顺手删掉，除非显式地触发去重或者精炼。

32
00:03:21,042 --> 00:03:29,022
这个单调性听着不起眼，但它保证了学习成果可以累积，而累积正是自我改进的前提。

33
00:03:29,170 --> 00:03:36,283
ACE 是把手册整理好，MCE 追问了一个更深的问题，整理手册的方法本身是不是也能优化。

34
00:03:36,233 --> 00:03:45,007
比如按时间排还是按主题排，记大纲还是记细节，这些选择过去是拍脑袋定的，MCE 说这些也可以被搜索。

35
00:03:45,007 --> 00:03:52,507
它把记什么和怎么记分开，两头一起进化，不仅笔记越来越好，记笔记的方法也越来越聪明。

36
00:03:52,507 --> 00:04:00,440
具体机制是把如何管理上下文的机制，与上下文中有什么内容分离，在两个层面同时优化。

37
00:04:00,440 --> 00:04:10,344
一个技能定义了上下文函数，其中静态组件是提示词、知识库、代码库，动态算子是搜索、选择、过滤、格式化。

38
00:04:10,344 --> 00:04:13,817
双层优化用大白话说就是两句话。

39
00:04:13,817 --> 00:04:18,132
内层，用当前的记笔记方法，把笔记写到最好。

40
00:04:18,132 --> 00:04:22,952
外层，比较不同的记笔记方法，选出最好的那套方法。

41
00:04:22,952 --> 00:04:26,690
先优化内容，再优化方法，轮流来。

42
00:04:26,690 --> 00:04:36,293
还有个设计很务实，技能数据库会跟踪历史，记录每一套方法配出来的上下文、在训练集和验证集上分别拿了多少分。

43
00:04:36,293 --> 00:04:40,572
这样进化就有记忆，不会把试过的路再走一遍。

44
00:04:40,572 --> 00:04:52,639
落到实现上，一个上下文函数被实例化为专用目录里的文件集合，静态文件存任务最重要的知识，动态文件存上下文数据和执行记录。

45
00:04:52,639 --> 00:05:08,545
也就是说，这套看起来很理论的东西，最后是落在一堆文件上的，优化过程本身就在标准编码环境里跑，用的工具就是读取、写入、编辑、命令行、文件匹配、内容搜索这些最普通的东西。

46
00:05:08,545 --> 00:05:10,780
这一点特别给人启发。

47
00:05:10,780 --> 00:05:18,244
它意味着你不需要为自进化再造一套专用基础设施，文件系统加一套基础工具就够了。

48
00:05:18,244 --> 00:05:25,996
优化的对象是文件的内容和目录的组织方式，而优化的手段就是最平常的读写改。

49
00:05:25,996 --> 00:05:31,730
把复杂机制的落点放在最成熟的原语上，这件事本身就是好设计。

50
00:05:31,730 --> 00:05:35,227
再补一个 Inner Loop 和 Outer Loop 的节奏问题。

51
00:05:35,227 --> 00:05:44,674
内层优化跑得勤，因为它的成本只是重新组织内容；外层优化跑得稀，因为每换一套方法都要重新验证一遍。

52
00:05:44,674 --> 00:05:56,369
这两个循环的周期差着一个量级，设计的时候别把它们混在同一个频率上跑，否则要么内层被外层拖慢，要么外层还没验证充分就被换掉。

53
00:05:56,510 --> 00:06:00,774
再往外一层是 Meta-Harness，这是套娃的最外层。

54
00:06:00,724 --> 00:06:07,816
ACE 优化笔记内容，MCE 优化记笔记的方法，Meta-Harness 直接优化整个工作台的源代码。

55
00:06:07,816 --> 00:06:13,236
相当于让 AI 重新装修整个车间，远不止换工具、换方法。

56
00:06:13,236 --> 00:06:21,878
被优化的不再是上下文内容，而是决定什么信息应该被存储、检索和呈现给模型的代码本身。

57
00:06:21,878 --> 00:06:24,595
它是优化 Harness 的 Harness。

58
00:06:24,595 --> 00:06:26,818
几个实现细节值得记。

59
00:06:26,818 --> 00:06:31,734
提出者本身就是一个编码智能体，不是某种专门的优化器。

60
00:06:31,734 --> 00:06:36,770
输出是一组位于帕累托前沿上的候选，不是一个所谓最优解。

61
00:06:36,770 --> 00:06:44,426
执行历史通过文件系统访问，编码智能体按需检索和读取，避免全塞进提示词。

62
00:06:44,426 --> 00:06:51,734
每个提出的 harness 是文件系统里的一个字典，包含源码、分数、轨迹和状态更新。

63
00:06:51,734 --> 00:06:58,897
它的威力最大，因为优化空间最大，但也最烧算力，每改一版都要完整试运行打分。

64
00:06:58,897 --> 00:07:04,763
这是个很实在的约束，意味着它不适合频繁迭代，更适合阶段性重构。

65
00:07:04,763 --> 00:07:07,708
三种方法放在一起看就清楚了。

66
00:07:07,708 --> 00:07:15,063
ACE 从轨迹中学习，用规则化的管线维护结构化条目，但更新规则仍然手工设计。

67
00:07:15,063 --> 00:07:20,123
MCE 进化管理机制，不固定上下文格式，机制本身可变。

68
00:07:20,123 --> 00:07:25,364
Meta-Harness 优化整个系统代码，最通用但计算最重。

69
00:07:25,500 --> 00:07:29,163
这里有一条核心教训，值得单独拎出来。

70
00:07:29,113 --> 00:07:37,154
一旦 harness 设计变成可执行的搜索空间，强编码智能体就能利用人类工程师使用的同一设计空间。

71
00:07:37,154 --> 00:07:49,474
这句话的分量在于，它说的是 AI 不是在发明某种人类看不懂的诡异结构，它是在人类原本就在用的那个设计空间里搜索，只是搜索得快得多、也彻底得多。

72
00:07:49,474 --> 00:07:57,960
由此推出的结论是，上下文工程的未来是让系统自动学会什么时候存什么、怎么检索、怎么呈现。

73
00:07:57,960 --> 00:08:01,349
再聪明的手写提示词也只是过渡。

74
00:08:01,349 --> 00:08:05,075
注意这句话的措辞，是过渡，不是没用。

75
00:08:05,075 --> 00:08:10,496
就像当年手写汇编被编译器取代，但理解汇编依然有价值。

76
00:08:10,496 --> 00:08:22,287
手写提示词的能力仍然重要，只是它不再是竞争力的主要来源，竞争力的来源变成了你能不能把自己的任务表达成一个可被搜索和评估的形式。

77
00:08:22,450 --> 00:08:24,539
下半场换到工作流。

78
00:08:24,489 --> 00:08:32,806
工作流就是给 AI 安排的做事流程表，就像新员工入职，你得告诉他先做 A，再做 B，出问题找 C 核对。

79
00:08:32,806 --> 00:08:36,220
以前这张流程表全靠人一步步写。

80
00:08:36,220 --> 00:08:39,297
先看两个手工设计的最强例子。

81
00:08:39,297 --> 00:08:43,840
第一个是 AI Scientist，构建完整的科研自动化管线。

82
00:08:43,840 --> 00:08:50,775
流程是提出研究想法、写代码、跑实验、分析结果、写论文、同行评审。

83
00:08:50,775 --> 00:09:00,511
关键创新是每一步都由模型驱动，形成端到端的自动化科研系统，评审环节引入模型当裁判进行质量把关。

84
00:09:00,511 --> 00:09:07,674
第二个是 Autodata，一个数据科学家智能体，核心是自动合成难度恰到好处的数据。

85
00:09:07,674 --> 00:09:13,756
它有一套角色体系，出题者、弱解题者、强解题者、验证裁判。

86
00:09:13,756 --> 00:09:25,955
关键创新是用难度差作为数据质量信号，只有同时满足强者能解、弱者不能解的题目才被保留，确保合成数据对提升模型有最大价值。

87
00:09:25,955 --> 00:09:35,895
这两个例子说明手工设计能做到很高水平，但也暴露了手工的天花板，它依赖设计者的经验和直觉，而你没法穷举。

88
00:09:35,895 --> 00:09:43,359
注意这两个例子还有个共同点值得学，它们都把质量把关做成了系统里的一个显式环节。

89
00:09:43,359 --> 00:09:47,770
AI Scientist 有同行评审，Autodata 有验证裁判。

90
00:09:47,770 --> 00:09:58,275
这不是巧合，一个长流程如果没有中间的质量闸口，错误会一路累积到终点才被发现，而那时候返工的成本已经高到不能接受。

91
00:09:58,275 --> 00:10:03,708
所以看一个工作流设计得好不好，先看它的验证节点放在哪。

92
00:10:03,708 --> 00:10:08,035
另外 Autodata 那个难度差的思路值得单独记一下。

93
00:10:08,035 --> 00:10:19,237
它用强弱两个解题者的差集来定义什么叫好数据，这比让人去标注数据质量要可靠得多，因为它把主观判断换成了一个可测量的信号。

94
00:10:19,237 --> 00:10:27,193
凡是能用差值、比值这类可测量信号替代主观评分的地方，自动化的空间都会大很多。

95
00:10:27,350 --> 00:10:30,004
于是有了自动搜索这条线。

96
00:10:29,954 --> 00:10:37,887
ADAS 的思路是让一个元智能体在智能体设计空间中自动搜索最优方案，取代手工设计架构。

97
00:10:37,887 --> 00:10:51,360
工作机制四步，先生成一个高层描述，把高层描述实现为可执行代码，通过自我修正检查新颖性确保不是简单重复，最后在基准任务上评估保留最好的设计。

98
00:10:51,360 --> 00:10:59,329
关键创新是用代码作为智能体设计的搜索空间表示，使设计可以被自动生成、修改和评估。

99
00:10:59,329 --> 00:11:05,074
AFlow 更进一步，用下棋 AI 同款的棋盘推演法来找最优流程。

100
00:11:05,074 --> 00:11:16,168
就像下棋前会在脑子里推演几百步，如果我走这里对方会怎样，AFlow 也是在推演几百种流程改法，哪条路线得分高就往哪边深挖。

101
00:11:16,168 --> 00:11:25,302
它把工作流表示成有向图，节点是模型调用动作，边是代码中的逻辑操作，条件分支、循环、数据传递。

102
00:11:25,302 --> 00:11:31,012
然后用蒙特卡洛树搜索在这个图空间里自动寻找最优工作流。

103
00:11:31,012 --> 00:11:48,419
流程是初始化起始工作流作为根节点，用分数与均匀探索的混合策略选择待扩展节点，让模型生成修改后的变体，在目标任务上执行并评估，有改进就加回搜索树，重复直到收敛或者算力用完。

104
00:11:48,570 --> 00:11:52,390
看一次具体的搜索过程，数字很直观。

105
00:11:52,340 --> 00:11:56,895
起始工作流最简单，规划然后执行，得分五十二。

106
00:11:56,895 --> 00:12:00,405
没有反思，没有验证，没有并行。

107
00:12:00,405 --> 00:12:03,470
第一轮扩展，模型提出三个变体。

108
00:12:03,470 --> 00:12:09,287
加反思的得六十一，加验证的得五十八，加任务分解的得五十五。

109
00:12:09,287 --> 00:12:14,996
评估之后选父节点，六十一最高，选它作为下一轮扩展的基础。

110
00:12:14,996 --> 00:12:22,460
注意这一步就是探索与利用的平衡，不是每次都选当前最优，但要保证好方向能被深挖。

111
00:12:22,460 --> 00:12:28,710
第二轮从它再扩展两个方案，双重反思得六十五，反思加验证得七十八。

112
00:12:28,710 --> 00:12:30,429
后者大幅领先。

113
00:12:30,429 --> 00:12:41,486
最后是剪枝与收敛，分数低于阈值的工作流被剪掉，反思加验证这个组合确认为搜索到的最优方案，比手工设计高出百分之五十。

114
00:12:41,486 --> 00:12:48,313
有个细节值得停下来想，为什么反思加验证这个组合能赢，而不是双重反思。

115
00:12:48,313 --> 00:12:59,455
单看两个组件，反思和验证都是加东西，但作用机制不同，反思是让模型回头看自己的输出，验证是引入一个独立的判断标准。

116
00:12:59,455 --> 00:13:11,739
两个反思叠在一起，第二次反思面对的还是同一套判断标准，容易在原地打转；而反思加验证引入了新信息源，相当于给循环加了一个外部参照。

117
00:13:11,739 --> 00:13:14,984
这个观察可以直接指导手工设计。

118
00:13:14,984 --> 00:13:22,532
当你想往流程里加环节的时候，先问它带来的是同一标准的重复执行，还是一个新的信息源。

119
00:13:22,532 --> 00:13:26,607
前者收益递减得很快，后者才可能带来阶跃。

120
00:13:26,607 --> 00:13:34,070
这个过程的价值不在于它找到了某个具体的工作流，而在于它展示了一种可重复的方法。

121
00:13:34,070 --> 00:13:42,700
你不需要知道最优工作流长什么样，你只需要能把候选生成出来、能把分数打出来、能把搜索组织起来。

122
00:13:42,860 --> 00:13:44,853
最后收几条原则。

123
00:13:44,803 --> 00:13:47,723
第一，别让上下文靠追加增长。

124
00:13:47,723 --> 00:13:52,351
增长和演进是两回事，演进是加的同时也在整理。

125
00:13:52,351 --> 00:14:03,252
用条目的、增量的方式更新，并且用确定性逻辑合并，不要每次重写整块提示词，那样迟早会撞上上下文坍缩和简洁偏差。

126
00:14:03,252 --> 00:14:05,909
第二，把内容和机制分开。

127
00:14:05,909 --> 00:14:10,860
记什么和怎么记是两件事，分开之后两层可以各自进化。

128
00:14:10,860 --> 00:14:20,127
这个思路不只适用于上下文，凡是你在手工维护某种方法的地方，都可以问一句，这个方法本身能不能也被优化。

129
00:14:20,127 --> 00:14:23,745
第三，优化对象可以一层层往上搬。

130
00:14:23,745 --> 00:14:29,923
从提示词到上下文，到工作流，到 Harness 代码，再到优化器代码。

131
00:14:29,923 --> 00:14:34,659
每往上搬一级，通用性变强，代价是算力变重。

132
00:14:34,659 --> 00:14:38,697
选哪一级取决于你的评估成本和迭代频率。

133
00:14:38,697 --> 00:14:43,961
第四，一旦设计变成可执行的搜索空间，自动化就能接手。

134
00:14:43,961 --> 00:14:51,197
前提是三件事，候选能被自动生成，分数能被自动打出，搜索能被有效组织。

135
00:14:51,197 --> 00:14:54,334
缺任何一件，自动化都跑不起来。

136
00:14:54,334 --> 00:14:59,983
所以做不了自动搜索的时候，先补评估，评估是自动化的地基。

137
00:14:59,983 --> 00:15:05,199
第五，再聪明的手写也只是过渡，但过渡不等于没用。

138
00:15:05,199 --> 00:15:14,815
手写提示词的能力依然有价值，只是竞争力的主要来源变了，变成你能不能把任务表达成一个可被搜索和评估的形式。

139
00:15:14,815 --> 00:15:19,875
最后一句提醒，这几讲的方法都建立在可评估的前提上。

140
00:15:19,875 --> 00:15:27,964
如果你的任务没有可靠的打分方式，那么越往上搬越危险，因为搜索会在错误的方向上高效地收敛。

141
00:15:27,964 --> 00:15:31,125
先把尺子做对，再谈搜索。