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

2
00:00:06,382 --> 00:00:14,350
这一集讲智能体工程，也就是一个只会聊天的模型，怎么变成一个真能替你把事做完的东西。

3
00:00:14,350 --> 00:00:16,730
先说本集解决什么问题。

4
00:00:16,730 --> 00:00:23,737
很多人以为智能体的关键是模型够不够聪明，于是把精力全花在换更大的模型上。

5
00:00:23,737 --> 00:00:31,454
但真实情况恰恰相反，智能体工程里大约百分之八十是脚手架，只有百分之二十是模型。

6
00:00:31,454 --> 00:00:38,052
大多数项目失败，败在错误处理不够健壮，模型够不够聪明反倒是次要的。

7
00:00:38,052 --> 00:00:40,612
这一集就讲那百分之八十。

8
00:00:40,612 --> 00:00:43,449
再说为什么产品经理要关心。

9
00:00:43,449 --> 00:00:48,088
因为这一层几乎全是产品决策，而不是技术决策。

10
00:00:48,088 --> 00:00:51,382
每个工具算不算危险操作，由你定。

11
00:00:51,382 --> 00:00:54,242
循环最多跑几轮，由你定。

12
00:00:54,242 --> 00:00:58,257
失败了是自己重试还是停下来问人，由你定。

13
00:00:58,257 --> 00:01:03,437
用户能不能看见它在干什么、花了多少钱，还是由你定。

14
00:01:03,437 --> 00:01:06,911
这些事推给工程，工程只能替你猜。

15
00:01:06,911 --> 00:01:09,302
还有一层更现实的考虑。

16
00:01:09,302 --> 00:01:16,826
智能体和聊天机器人有个本质区别，它会真的去动你的文件、调你的接口、花你的钱。

17
00:01:16,826 --> 00:01:23,605
聊天机器人说错了，最坏的结果是尴尬；智能体做错了，代价可能是不可逆的破坏。

18
00:01:23,605 --> 00:01:29,266
所以它需要的不是更聪明的脑子，而是刹车、护栏和仪表盘。

19
00:01:29,266 --> 00:01:33,149
这一集讲的就是这三样东西怎么设计。

20
00:01:33,290 --> 00:01:36,569
先看清智能体到底是怎么干活的。

21
00:01:36,519 --> 00:01:41,940
它的工作方式是一个循环，思考、行动、观察、再思考。

22
00:01:41,940 --> 00:01:46,675
思考和行动这两个词合起来，就是这套方法的名字。

23
00:01:46,675 --> 00:01:50,125
一问一答只是这个循环里的其中一轮。

24
00:01:50,125 --> 00:01:51,915
举个真实的任务。

25
00:01:51,915 --> 00:01:57,817
你让它把项目里所有的调试日志删掉，然后跑一遍测试确保没问题。

26
00:01:57,817 --> 00:02:03,310
这件事看起来只是一句话，实际执行下来经历了十四轮循环。

27
00:02:03,310 --> 00:02:13,165
它要先想清楚从哪儿找，动手去搜索，看看搜出来什么，再决定下一步；中间还会发现自己想错了，退回去换一条路。

28
00:02:13,165 --> 00:02:16,747
这个过程里你会看到三样东西在滚动。

29
00:02:16,747 --> 00:02:24,199
思考是它这一步的理由，行动是它实际调用的工具和参数，观察是工具返回的结果。

30
00:02:24,199 --> 00:02:29,403
旁边还有两个计数器，一个是当前轮次，一个是累计消耗的词元。

31
00:02:29,403 --> 00:02:35,906
这两个数字正是产品经理最该盯的，前者对应用户体验，后者对应成本。

32
00:02:35,906 --> 00:02:44,944
一个看起来很简单的任务要跑十四轮，意味着你必须为失败和重试预留预算，而不是按一轮成功来估。

33
00:02:44,944 --> 00:02:50,028
这里的关键是最后那半句，它会根据执行结果调整策略。

34
00:02:50,028 --> 00:02:54,415
这正是智能体和普通聊天机器人的本质区别。

35
00:02:54,415 --> 00:03:00,137
聊天机器人给你一段话就结束了，你拿去执行，执行得怎么样它不知道。

36
00:03:00,137 --> 00:03:04,560
智能体是自己执行、自己看结果、自己改主意。

37
00:03:04,560 --> 00:03:10,906
所以做产品的时候，你要设计的不是一句提示词，而是这个循环的边界。

38
00:03:10,906 --> 00:03:18,598
它最多能转多少圈，每一圈允许它动什么，什么时候必须停下来问人，做完了怎么向你交代。

39
00:03:18,598 --> 00:03:22,444
循环本身模型会跑，边界得你来画。

40
00:03:22,590 --> 00:03:26,927
智能体不是万能的，它有五种典型的卡死模式。

41
00:03:26,877 --> 00:03:31,985
好的产品设计正视这些问题，为每一种都预设好应对方案。

42
00:03:31,985 --> 00:03:34,401
第一种是参数格式错误。

43
00:03:34,401 --> 00:03:40,494
它调用工具的时候把参数写错了，比如该给数字的地方给了一段文字。

44
00:03:40,494 --> 00:03:45,362
应对是参数校验，在真正执行之前先按格式验一遍。

45
00:03:45,362 --> 00:03:47,490
第二种是幻觉工具。

46
00:03:47,490 --> 00:03:52,345
它调用了一个根本不存在的工具，或者自己编了一个函数名。

47
00:03:52,345 --> 00:03:57,550
应对是工具验证，只允许它用白名单里真实存在的那几个。

48
00:03:57,550 --> 00:03:59,593
第三种是无限递归。

49
00:03:59,593 --> 00:04:04,268
它绕不出去了，两个步骤互相触发，一轮一轮空转。

50
00:04:04,268 --> 00:04:10,482
应对是循环检测，比如检测到同样的动作重复出现，就强制打断。

51
00:04:10,482 --> 00:04:12,646
第四种是信息不足。

52
00:04:12,646 --> 00:04:18,295
它其实没搞清你要什么，但又不问，硬着头皮往下做，越做越偏。

53
00:04:18,295 --> 00:04:24,929
应对是主动提问机制，让它在信息不够的时候必须先开口问，而不是自己猜。

54
00:04:24,929 --> 00:04:27,021
第五种是接口异常。

55
00:04:27,021 --> 00:04:30,963
外部服务超时、报错、返回了一堆脏东西。

56
00:04:30,963 --> 00:04:36,324
应对是超时兜底，超了就退出并如实报告，不要假装成功。

57
00:04:36,324 --> 00:04:41,083
还有一个容易被忽略的点，这五种模式会互相叠加。

58
00:04:41,083 --> 00:04:49,917
信息不足的时候，它更容易编出不存在的工具；而工具调用失败之后，又更容易陷入反复重试的死循环。

59
00:04:49,917 --> 00:05:00,482
所以防护不能只做一道，参数校验、工具白名单、循环检测、主动提问、超时兜底，这五道是并列关系，不是五选一。

60
00:05:00,482 --> 00:05:05,783
这五种不是理论清单，是上线之后你一定会遇到的五类工单。

61
00:05:05,783 --> 00:05:10,651
写方案的时候逐条写下应对，比事后救火便宜得多。

62
00:05:10,810 --> 00:05:16,048
智能体能做什么、不能做什么，是这个产品最核心的决策。

63
00:05:15,998 --> 00:05:18,931
常见的有三种权限模式。

64
00:05:18,931 --> 00:05:23,774
第一种是确认模式，每个危险操作都要用户点一下确认。

65
00:05:23,774 --> 00:05:28,738
最安全，也最慢，每次弹窗都会打断用户的流程。

66
00:05:28,738 --> 00:05:33,666
第二种是自动模式，所有操作自动放行，不需要确认。

67
00:05:33,666 --> 00:05:38,522
最快，也最危险，一次误判就可能删掉用户的数据。

68
00:05:38,522 --> 00:05:47,200
第三种是智能模式，用一个模型分类器去评估风险等级，低风险的自动放行，高风险的拦截确认。

69
00:05:47,200 --> 00:05:49,856
这是效率和安全之间的折中。

70
00:05:49,856 --> 00:05:53,895
但这里藏着三个必须由产品经理拍板的问题。

71
00:05:53,895 --> 00:06:04,351
第一，权限设计的本质是安全和效率的取舍，每次确认都在打断用户，不确认又可能造成不可逆破坏，你的产品选哪一边。

72
00:06:04,351 --> 00:06:14,856
第二，智能模式用模型来判断风险，而模型的判断本身也可能出错，一次误判就可能删掉用户数据，这个风险你能不能接受。

73
00:06:14,856 --> 00:06:24,363
第三，只读和破坏性是工具级别的标记，你要决定每个工具属于哪个风险等级，这是产品决策，不能推给工程。

74
00:06:24,363 --> 00:06:26,142
举个具体场景。

75
00:06:26,142 --> 00:06:34,123
假设它一口气想执行五个操作，读两个文件、改一个文件、删一个文件、再执行一条命令。

76
00:06:34,123 --> 00:06:48,558
在确认模式下，后三个都要弹窗；在自动模式下，五个全部放行；在智能模式下，读文件被判为低风险直接放行，删除和执行命令被判为高风险，拦下来等人确认。

77
00:06:48,558 --> 00:06:56,034
你要做的，是提前把这张风险分级表写出来，而不是等它执行到那一步再临时判断。

78
00:06:56,034 --> 00:07:02,128
一句话总结，全部确认最安全但最慢，全部放行最快但最危险。

79
00:07:02,128 --> 00:07:08,210
真正的产品功力，体现在你怎么给中间那一大片灰色的操作分级。

80
00:07:08,360 --> 00:07:11,735
接下来的概念很朴素，但收益极大。

81
00:07:11,685 --> 00:07:21,048
所谓技能，就是一份流程说明加上工具调用指引，目的是让那个思考行动观察的循环尽可能短、尽可能高效。

82
00:07:21,048 --> 00:07:26,084
它的本质其实就是把经验写成文档，算不上什么新技术。

83
00:07:26,084 --> 00:07:32,635
用自然语言告诉模型，遇到这类任务先做什么、再做什么、调哪个工具。

84
00:07:32,635 --> 00:07:39,726
相当于让它出门之前就想清楚，一趟全搞完，而不是走一步发现忘带东西再折回来。

85
00:07:39,726 --> 00:07:43,344
看一个发版任务的对比，差距非常直观。

86
00:07:43,344 --> 00:07:51,144
没有技能的时候，它靠通用能力摸索，试错了十二轮，花掉一万五千词元，还出了三个错。

87
00:07:51,144 --> 00:07:57,863
有技能的时候，按手册逐步执行，五轮搞定，只花四千词元，零错误。

88
00:07:57,863 --> 00:08:00,808
效率差距在三点七五倍以上。

89
00:08:00,808 --> 00:08:03,488
所以技能的颗粒度很讲究。

90
00:08:03,488 --> 00:08:09,377
最佳点是一个完整的工作流，太粗没有指导意义，太细不值得封装。

91
00:08:09,377 --> 00:08:13,524
写技能的人是领域专家，用技能的人是智能体。

92
00:08:13,524 --> 00:08:16,385
课程里用了一个很形象的比方。

93
00:08:16,385 --> 00:08:26,817
没有技能的智能体，像让你去阳台收衣服，你先走出去看看，发现没拿衣架，回来拿，再走出去，发现衣服要分开收，又回来一趟。

94
00:08:26,817 --> 00:08:34,125
有技能的智能体，是出门之前就把衣架、收纳袋和先后顺序都想好了，一趟搞定。

95
00:08:34,125 --> 00:08:37,767
差的不是手脚，是出门之前那一份清单。

96
00:08:37,767 --> 00:08:42,106
再看三个真实技能的设计，能看出取舍的分寸。

97
00:08:42,106 --> 00:08:58,672
内容创作技能的关键是，先分析你的写作风格再动笔，不给模型直接生成的机会，这样每次产出都贴合你个人的味道，避开那种通用的机器腔；它允许联网搜索，但禁止直接发布，发布必须过人工审核。

98
00:08:58,672 --> 00:09:09,658
网页导入技能会自动识别几种不同的网页类型，背后走三套抓取逻辑，但对需要登录才能访问的页面一律不保存，避免隐私泄露。

99
00:09:09,658 --> 00:09:18,840
标签整理技能则是合并前先给建议、等用户确认后才执行，绝不自动合并，而且只做合并不做删除。

100
00:09:18,840 --> 00:09:22,350
这里也有四个产品经理必须回答的问题。

101
00:09:22,350 --> 00:09:25,126
为哪些高频操作预装技能？

102
00:09:25,126 --> 00:09:27,590
允许用户自己建技能吗？

103
00:09:27,590 --> 00:09:30,054
两个技能冲突了怎么办？

104
00:09:30,054 --> 00:09:32,338
谁来负责维护和更新？

105
00:09:32,338 --> 00:09:37,302
这几个问题不答，技能就会变成一堆没人管的僵尸文档。

106
00:09:37,450 --> 00:09:43,505
一份完整的技能文件由四部分组成，每一部分都是一个产品决策点。

107
00:09:43,455 --> 00:09:45,354
先看执行步骤。

108
00:09:45,354 --> 00:09:58,491
以发版技能为例，它是一条七步管线，检查代码仓库状态、运行测试、打包应用、更新版本号、写发布日志、上传到对象存储、最后同步落地页。

109
00:09:58,491 --> 00:10:05,330
为什么是先测试再打包，因为打包完才发现测试不过，那一轮的时间和词元就白花了。

110
00:10:05,330 --> 00:10:10,306
这个顺序不是技术细节，是你对这件事正确做法的判断。

111
00:10:10,306 --> 00:10:14,994
第一部分是元信息，技能名称、功能描述、触发词。

112
00:10:14,994 --> 00:10:24,381
触发词的覆盖度决定了召回率，写得太少，用户说了本该触发的话却没触发；写得太泛，不该触发的时候又误触。

113
00:10:24,381 --> 00:10:29,116
好的触发词，是把用户可能的自然表达尽量穷举一遍。

114
00:10:29,116 --> 00:10:33,383
第二部分是适用条件，也就是防止误触的保险。

115
00:10:33,383 --> 00:10:40,739
比如一个发版技能会判断两个条件，用户有没有说触发词，当前在不在那个项目目录里。

116
00:10:40,739 --> 00:10:45,871
两条都满足才触发，否则静默退出，不干扰正常对话。

117
00:10:45,871 --> 00:10:53,575
没有这一层，用户在任何项目里说一句发版都会触发别人的发版流程，这是灾难级的问题。

118
00:10:53,575 --> 00:10:55,931
第三部分是执行步骤。

119
00:10:55,931 --> 00:11:00,030
步骤的顺序至关重要，先测试还是先打包？

120
00:11:00,030 --> 00:11:05,234
顺序就是你认为正确的标准流程，它会严格按顺序执行。

121
00:11:05,234 --> 00:11:08,720
第四部分是允许工具，这是安全边界。

122
00:11:08,720 --> 00:11:18,936
限制它在执行这个技能期间能用的武器，比如禁止删除文件，防止误删；禁止再派生子智能体，是为了让执行链可预测。

123
00:11:18,936 --> 00:11:23,263
最后是安全约束，这是一份技能里最重要的部分。

124
00:11:23,263 --> 00:11:28,852
步骤写错了，它只是做错事；约束缺失了，它可能做危险的事。

125
00:11:28,852 --> 00:11:42,193
好的约束是明确的禁令加上失败时的降级策略，比如不允许强推覆盖别人的代码，无论多紧急测试不通过就不发版，失败时停下来报告，不自己重试。

126
00:11:42,350 --> 00:11:46,194
前面讲的是单个技能，现在看整个工程。

127
00:11:46,144 --> 00:11:50,074
一个生产级的智能体，需要四层东西撑起来。

128
00:11:50,074 --> 00:11:52,021
第一层是脚手架。

129
00:11:52,021 --> 00:11:58,367
业内有个说法，智能体工程等于百分之八十的脚手架加百分之二十的模型。

130
00:11:58,367 --> 00:12:04,221
大多数项目失败，败在错误处理不够健壮，而不是模型不够聪明。

131
00:12:04,221 --> 00:12:11,168
这一层包括工具注册、状态管理、错误恢复这些不起眼但决定生死的部分。

132
00:12:11,168 --> 00:12:13,560
第二层是五道工程护栏。

133
00:12:13,560 --> 00:12:18,283
智能体的核心能力来自模型，但稳定性来自护栏。

134
00:12:18,283 --> 00:12:26,829
迭代上限防死循环，输出截断防撑爆，超时控制防卡死，中断恢复防损坏，上下文急救防崩溃。

135
00:12:26,829 --> 00:12:30,699
没有护栏的智能体，等于没有刹车的跑车。

136
00:12:30,699 --> 00:12:36,721
常见的两个数字是，最大迭代五十轮，单次输出限制二十万字符。

137
00:12:36,721 --> 00:12:39,209
第三层是多智能体协作。

138
00:12:39,209 --> 00:12:49,161
复杂任务不靠一个智能体硬撑，而是拆成多个专职角色，调研员负责读代码，开发者负责改代码，测试员负责验证。

139
00:12:49,161 --> 00:12:57,550
只读任务可以并行加速，写入任务必须串行保安全，两个角色同时改同一个文件，结果是灾难。

140
00:12:57,550 --> 00:13:02,274
父一级还可以随时中止子一级，这是最后一道保险。

141
00:13:02,274 --> 00:13:04,365
第四层是可观测性。

142
00:13:04,365 --> 00:13:17,718
通过事件流，你可以实时看到它在想什么、做什么、花了多少钱，包括总耗时、模型调用次数、工具调用次数、输入词元、输出词元、预估费用和文件变更。

143
00:13:17,718 --> 00:13:26,264
没有可观测性就等于黑箱，当用户问起为什么这么慢、这次怎么花了这么多钱，你没有数据可以回答。

144
00:13:26,264 --> 00:13:31,528
这一层还有个细节，每种事件类型本身都是一个产品决策点。

145
00:13:31,528 --> 00:13:39,786
文本事件用于流式展示，工具开始和结束用于进度条，用量事件用于计费，错误事件用于告警。

146
00:13:39,786 --> 00:13:47,754
你可以按通用的可观测标准，把这些都记录成标准化的片段，之后用任何性能分析工具去查。

147
00:13:47,754 --> 00:13:51,192
把这四层叠起来，就是那张全景图。

148
00:13:51,192 --> 00:13:59,004
模型提供智能，工具提供能力，记忆提供连续性，循环提供自主性，工程提供稳定性。

149
00:13:59,004 --> 00:14:04,269
五个缺一不可，而前四个的成败，最后都落在第五个上。

150
00:14:04,410 --> 00:14:08,686
最后给你一份可以马上用的判断清单，一共五条。

151
00:14:08,636 --> 00:14:12,495
第一条，把精力从选模型移到画边界。

152
00:14:12,495 --> 00:14:18,144
智能体工程里大约百分之八十是脚手架，只有百分之二十是模型。

153
00:14:18,144 --> 00:14:26,605
你要设计的是循环最多转几圈、每圈能动什么、什么时候必须停下来问人，而不是纠结用哪个模型。

154
00:14:26,605 --> 00:14:30,944
第二条，为五种卡死模式逐条写下应对方案。

155
00:14:30,944 --> 00:14:41,701
参数格式错误配参数校验，幻觉工具配工具白名单，无限递归配循环检测，信息不足配主动提问，接口异常配超时兜底。

156
00:14:41,701 --> 00:14:45,908
这五类不是理论，是上线后一定会来的工单。

157
00:14:45,908 --> 00:14:49,430
第三条，权限分级必须你自己拍板。

158
00:14:49,430 --> 00:14:56,088
确认模式、自动模式、智能模式，本质是在安全和效率之间选位置。

159
00:14:56,088 --> 00:15:02,422
同时记住，只读和破坏性是工具级别的标记，这个决定不能推给工程。

160
00:15:02,422 --> 00:15:05,692
第四条，把高频操作写成技能。

161
00:15:05,692 --> 00:15:10,535
技能就是流程说明加工具调用指引，把摸索变成执行。

162
00:15:10,535 --> 00:15:21,437
写的时候盯紧四件事，触发词够不够全、适用条件能不能防误触、步骤顺序是不是你认可的标准流程、约束条款有没有写死红线。

163
00:15:21,437 --> 00:15:25,439
第五条，上线之前先装仪表盘和护栏。

164
00:15:25,439 --> 00:15:37,098
五道护栏是迭代上限、输出截断、超时控制、中断恢复、上下文急救；可观测性至少要看得到耗时、调用次数、词元和预估费用。

165
00:15:37,098 --> 00:15:41,737
没有这些，你既没法优化成本，也没法排查故障。

166
00:15:41,737 --> 00:15:48,540
这五条的共同点是，智能体的能力来自模型，但它的可靠性来自你写的工程。

167
00:15:48,540 --> 00:15:52,158
模型负责聪明，你负责让它可控。