1
00:00:00,000 --> 00:00:03,940
接下来我们来讲一下

2
00:00:03,940 --> 00:00:05,460
Codex Sub-Agents

3
00:00:05,460 --> 00:00:08,060
多智能体协同与复杂论物分发

4
00:00:08,060 --> 00:00:10,540
那么这个一般是用在什么场景呢

5
00:00:10,540 --> 00:00:13,580
比如说大家要做一个非常复杂的一个任务

6
00:00:13,580 --> 00:00:15,320
比如说我们要做一个大项目

7
00:00:15,320 --> 00:00:17,560
这个项目里面涉及到一些需求分析

8
00:00:17,560 --> 00:00:20,840
然后开发测试

9
00:00:20,840 --> 00:00:22,380
包括部署等等的

10
00:00:22,380 --> 00:00:24,760
非常多的一些细节问题的时候

11
00:00:24,760 --> 00:00:27,420
那这时候我们要对一个大项目

12
00:00:27,420 --> 00:00:28,740
做一个任务的一个拆分

13
00:00:28,740 --> 00:00:32,200
按需求按开发按测试按部署等等

14
00:00:32,200 --> 00:00:34,420
我们要把任务拆出来

15
00:00:34,420 --> 00:00:35,860
拆出来之后的话

16
00:00:35,860 --> 00:00:40,100
我们这个任务应该怎么来执行呢

17
00:00:40,100 --> 00:00:40,640
是吧

18
00:00:40,640 --> 00:00:42,080
那么在Codex里面的话

19
00:00:42,080 --> 00:00:45,000
就有一个叫做Subagents的这么一个组件

20
00:00:45,000 --> 00:00:47,760
那这个翻译过来叫做子智能体

21
00:00:47,760 --> 00:00:50,200
也就是说大家可以把Codex

22
00:00:50,200 --> 00:00:53,040
整个看作一个大的一个智能体的话

23
00:00:53,040 --> 00:00:58,000
那它去单独可以去开一些子的一个智能体

24
00:00:58,000 --> 00:00:59,540
去帮我们去完成一个任务

25
00:00:59,540 --> 00:01:02,520
就相当于我们现在是一个公司是吧

26
00:01:02,520 --> 00:01:04,180
那Codex相当于这个公司

27
00:01:04,180 --> 00:01:05,740
那现在有员工啊

28
00:01:05,740 --> 00:01:07,840
每个部门有负责人是吧

29
00:01:07,840 --> 00:01:10,340
然后他要带头去做不同的项目

30
00:01:10,340 --> 00:01:13,860
有这个具体的这个同事负责不同的这个工作

31
00:01:13,860 --> 00:01:16,820
你就可以把这些个同事看作这个子agent

32
00:01:16,820 --> 00:01:19,800
那么你可以把它看作成一个小团队

33
00:01:19,800 --> 00:01:21,760
他可以做不同的这个任务

34
00:01:21,760 --> 00:01:23,740
这个就是决策定义

35
00:01:23,740 --> 00:01:24,860
然后并且的话

36
00:01:24,860 --> 00:01:26,440
这里面有个非常关键的点

37
00:01:26,440 --> 00:01:27,900
就是他可以并行

38
00:01:28,000 --> 00:01:28,660
什么意思呢

39
00:01:28,660 --> 00:01:29,760
就是我这个任务啊

40
00:01:29,760 --> 00:01:32,380
我不是说要等是吧

41
00:01:32,380 --> 00:01:34,420
那我这个开发跟测试

42
00:01:34,420 --> 00:01:36,220
我这个测试的文档

43
00:01:36,220 --> 00:01:37,360
是不是可以先生成了

44
00:01:37,360 --> 00:01:37,760
是吧

45
00:01:37,760 --> 00:01:38,960
那你需求出来之后

46
00:01:38,960 --> 00:01:40,320
我这个这个代码

47
00:01:40,320 --> 00:01:41,440
是不是就可以开始写了

48
00:01:41,440 --> 00:01:43,280
然后测试的一些规范

49
00:01:43,280 --> 00:01:44,500
是不是就可以开始做了

50
00:01:44,500 --> 00:01:45,420
就有些工作

51
00:01:45,420 --> 00:01:46,720
它是可以并行的啊

52
00:01:46,720 --> 00:01:48,900
它不是说依赖于上面那个工作

53
00:01:48,900 --> 00:01:50,700
完成了才能做下一刻

54
00:01:50,700 --> 00:01:53,160
我们是可以做一些编排的啊

55
00:01:53,160 --> 00:01:54,460
就多个整体之间

56
00:01:54,460 --> 00:01:55,600
它是可以协作的

57
00:01:55,600 --> 00:01:56,860
那么Codex的话

58
00:01:56,860 --> 00:01:58,680
就可以通过这种并行的方式

59
00:01:58,680 --> 00:02:00,820
启动多个专用的这种智能体

60
00:02:00,820 --> 00:02:05,060
帮我们一起同时的去做各自的一些工作

61
00:02:05,060 --> 00:02:06,280
然后做完之后的话

62
00:02:06,280 --> 00:02:08,340
给它做一些合并

63
00:02:08,340 --> 00:02:08,760
是吧

64
00:02:08,760 --> 00:02:10,800
然后把这个结果做一下这个归纳

65
00:02:10,800 --> 00:02:13,400
比如说我整个一个项目是有需求

66
00:02:13,400 --> 00:02:14,840
有开发有测试

67
00:02:14,840 --> 00:02:15,200
是吧

68
00:02:15,200 --> 00:02:16,280
有部署等等的

69
00:02:16,280 --> 00:02:18,920
我希望它并行可以去完成一些事情

70
00:02:18,920 --> 00:02:21,320
就是我有一些工作完成之后

71
00:02:21,320 --> 00:02:24,460
我可以交由智能体自动的去切换

72
00:02:24,460 --> 00:02:25,400
然后去协作

73
00:02:25,400 --> 00:02:28,440
最终我的目标是这个项目要上线

74
00:02:28,440 --> 00:02:30,780
我只关注这个目标就可以了

75
00:02:30,780 --> 00:02:32,780
那么其他的步骤怎么来分的话

76
00:02:32,780 --> 00:02:35,020
我们可以让Codex里面

77
00:02:35,020 --> 00:02:37,120
这个叫Subagents的一个组件

78
00:02:37,120 --> 00:02:38,180
去做这个事情

79
00:02:38,180 --> 00:02:40,860
那么目前Codex的话

80
00:02:40,860 --> 00:02:41,780
最新版本

81
00:02:41,780 --> 00:02:45,080
它是默认启用了一个Subagents的话

82
00:02:45,080 --> 00:02:47,080
大家可以正常的去使用

83
00:02:47,080 --> 00:02:50,360
那么一般我们可以把它用在一个

84
00:02:50,360 --> 00:02:51,540
什么样的一个场景呢

85
00:02:51,540 --> 00:02:53,160
比如说啊

86
00:02:53,160 --> 00:02:56,180
我们可以去做一个非常大型的项目

87
00:02:56,180 --> 00:02:58,660
比如说我现在要针对这个PR是吧

88
00:02:58,660 --> 00:02:59,320
做审查

89
00:02:59,320 --> 00:03:01,160
我要审查的安全问题

90
00:03:01,160 --> 00:03:02,440
代码质量bug

91
00:03:02,440 --> 00:03:04,380
这种场景的话

92
00:03:04,380 --> 00:03:06,960
就特别适合用这个subagents

93
00:03:06,960 --> 00:03:09,260
因为它前后的这个任务

94
00:03:09,260 --> 00:03:10,300
没有关联项

95
00:03:10,300 --> 00:03:11,900
它都可以并行的去执行

96
00:03:11,900 --> 00:03:14,240
它不是说先要把安全问题查出来

97
00:03:14,240 --> 00:03:15,680
再把代码质量分析一下

98
00:03:15,680 --> 00:03:16,240
再去查bug

99
00:03:16,240 --> 00:03:18,380
这同时可以去

100
00:03:18,380 --> 00:03:19,940
同步的去跑

101
00:03:19,940 --> 00:03:22,780
跑出来之后给一个汇总的结果就可以了

102
00:03:22,780 --> 00:03:23,720
所以这种任务

103
00:03:23,720 --> 00:03:24,600
它特别适合

104
00:03:24,600 --> 00:03:25,780
于用这个Codex

105
00:03:25,780 --> 00:03:27,580
像我们刚刚讲的

106
00:03:27,580 --> 00:03:28,380
那个软件的

107
00:03:28,380 --> 00:03:29,500
这个开发工作流的话

108
00:03:29,500 --> 00:03:31,080
它还是会有一些依赖的

109
00:03:31,080 --> 00:03:33,360
文档可以同时去生成

110
00:03:33,360 --> 00:03:35,700
但是你得先把代码写出来

111
00:03:35,700 --> 00:03:36,640
才得去测试

112
00:03:36,640 --> 00:03:37,180
是吧

113
00:03:37,180 --> 00:03:39,060
所以它还是有一定的依赖的

114
00:03:39,060 --> 00:03:40,460
但是做代码审查

115
00:03:40,460 --> 00:03:42,220
就特别适合于这种场景

116
00:03:42,220 --> 00:03:43,840
那么这个Codex

117
00:03:43,840 --> 00:03:45,640
它就会做各种各样的编码

118
00:03:45,640 --> 00:03:46,940
比如说它会去生成

119
00:03:46,940 --> 00:03:48,600
新的一个子智能体

120
00:03:48,600 --> 00:03:50,880
然后给不同的智能体

121
00:03:50,880 --> 00:03:52,720
去录有我们后续的一个指令

122
00:03:52,720 --> 00:03:54,540
然后就等待一些结果

123
00:03:54,540 --> 00:03:56,940
最后每个智能体

124
00:03:56,940 --> 00:03:59,360
子智能体它的一个任务完成之后

125
00:03:59,360 --> 00:04:01,460
我们再把这个子线上给关闭掉

126
00:04:01,460 --> 00:04:04,420
所以说这个就是一步的方式

127
00:04:04,420 --> 00:04:06,000
那么Codex它也会等待

128
00:04:06,000 --> 00:04:07,580
所有的这个结果完成之后

129
00:04:07,580 --> 00:04:09,080
再做一个汇总答复

130
00:04:09,080 --> 00:04:11,300
所以说我们可以

131
00:04:11,300 --> 00:04:12,780
以这个提示式的方式

132
00:04:12,780 --> 00:04:14,360
让Codex来跑一下

133
00:04:14,360 --> 00:04:16,740
这个当前的一些个情况

134
00:04:16,740 --> 00:04:17,200
是吧

135
00:04:17,200 --> 00:04:18,400
然后再看一下

136
00:04:18,400 --> 00:04:20,620
这里面我们首先给大家来演示一下

137
00:04:20,620 --> 00:04:24,980
那我现在我这个低盘下面有一个Codex目录啊

138
00:04:24,980 --> 00:04:27,840
那这里我是把Codex的一个开源项目拉下来

139
00:04:27,840 --> 00:04:29,940
我们就以这个项目为例啊

140
00:04:29,940 --> 00:04:33,180
然后让他去分析一下这个PR是吧

141
00:04:33,180 --> 00:04:34,620
随便找一个PR吧

142
00:04:34,620 --> 00:04:37,460
嗯

143
00:04:37,460 --> 00:04:40,260
然后的话就是当前PR

144
00:04:40,260 --> 00:04:41,920
就随便

145
00:04:41,920 --> 00:04:44,080
下Codex

146
00:04:44,080 --> 00:04:45,280
我就找一个啊

147
00:04:45,280 --> 00:04:46,260
看一下他的一个PR

148
00:04:46,260 --> 00:04:54,660
我们最开始给大家提供了一个项目

149
00:04:54,660 --> 00:04:56,400
就是Codex的一个开源项目

150
00:04:56,400 --> 00:05:00,220
然后去找到这个整个的一个PR

151
00:05:00,220 --> 00:05:02,660
看一下

152
00:05:02,660 --> 00:05:06,700
就我就随便找一个PR了

153
00:05:06,700 --> 00:05:07,660
那我就用这个

154
00:05:07,660 --> 00:05:09,920
我把这个PR复制一下

155
00:05:09,920 --> 00:05:12,880
然后的话这里面

156
00:05:12,880 --> 00:05:15,860
我们进入Codex

157
00:05:15,860 --> 00:05:18,460
比如这个是一个PR是吧

158
00:05:18,460 --> 00:05:20,880
那我们就给它分析一下

159
00:05:20,880 --> 00:05:22,380
复制一下

160
00:05:22,380 --> 00:05:25,340
我们现在想分析一下

161
00:05:25,340 --> 00:05:26,900
别人现在开源是吧

162
00:05:26,900 --> 00:05:28,220
它提交了一个PR上来

163
00:05:28,220 --> 00:05:29,700
我现在想审查一下这个PR

164
00:05:29,700 --> 00:05:32,060
然后我再加进来

165
00:05:32,060 --> 00:05:33,380
我们就看一下

166
00:05:33,380 --> 00:05:34,460
让它去分析了

167
00:05:34,460 --> 00:05:37,600
那我们在这里就可以看到

168
00:05:37,600 --> 00:05:41,060
整个它会有一个

169
00:05:41,060 --> 00:05:43,080
这个subagents的一个概念

170
00:05:43,080 --> 00:05:44,360
看它这里有没有启动

171
00:05:44,360 --> 00:05:45,180
这个subagents

172
00:05:45,180 --> 00:05:55,120
你看他现在就开始在工作了

173
00:05:55,120 --> 00:05:55,280
是吧

174
00:05:55,280 --> 00:05:58,580
他会执行这个命令去查询这个PR

175
00:05:58,580 --> 00:05:59,020
是吧

176
00:05:59,020 --> 00:06:00,500
执行这个GH命令

177
00:06:00,500 --> 00:06:01,920
这个GH命令的话

178
00:06:01,920 --> 00:06:04,620
是Github提供的一个CLI工具啊

179
00:06:04,620 --> 00:06:06,420
这个首先大家要做一个登录啊

180
00:06:06,420 --> 00:06:09,460
如果说公关公关仓库的话

181
00:06:09,460 --> 00:06:11,520
默认应该是不需要授权的

182
00:06:11,520 --> 00:06:13,160
如果说弹出来要一个token的话

183
00:06:13,160 --> 00:06:14,980
这个最好大家去配一下啊

184
00:06:14,980 --> 00:06:16,540
因为你如果不配置token的话

185
00:06:16,540 --> 00:06:18,540
有些情况下可能会被限制

186
00:06:18,540 --> 00:06:21,920
所以执行一个JH login这个命令

187
00:06:21,920 --> 00:06:25,000
然后就把它去登录一下

188
00:06:25,000 --> 00:06:26,460
这个JH怎么安装

189
00:06:26,460 --> 00:06:28,020
大家可以去找一下这个教程

190
00:06:28,020 --> 00:06:28,540
很简单

191
00:06:28,540 --> 00:06:31,200
把这个JH CLI工具给它装一下

192
00:06:31,200 --> 00:06:35,080
然后我们就可以看一下

193
00:06:35,080 --> 00:06:38,520
看一下它的这个subagents

194
00:06:38,520 --> 00:06:39,540
看一下

195
00:06:39,540 --> 00:06:43,240
你看它这个斜钢命令里面有一个agents

196
00:06:43,240 --> 00:06:44,800
我们这里面可以看一下

197
00:06:44,800 --> 00:06:49,020
你看当前是有一个主线程

198
00:06:49,020 --> 00:06:49,460
是吧

199
00:06:49,460 --> 00:06:50,360
主线程

200
00:06:50,360 --> 00:06:53,240
然后这个里面我们可以去看一下啊

201
00:06:54,240 --> 00:06:56,740
看一下它的一个逻辑

202
00:06:56,740 --> 00:06:58,860
现在是只有一个主线程

203
00:06:58,860 --> 00:07:05,240
那现在这个里面还是在去拉代码啊

204
00:07:05,240 --> 00:07:12,160
这个里面我们可以切换啊

205
00:07:12,160 --> 00:07:16,760
就是当前如果他启动了一个子智能体的话

206
00:07:16,760 --> 00:07:21,080
我们可以看到一些这个细节啊

207
00:07:21,080 --> 00:07:23,100
比如说切换到当前活动的

208
00:07:23,100 --> 00:07:26,160
到目前为止他还只有一个啊

209
00:07:27,160 --> 00:07:31,440
目前为止还有一个

210
00:07:31,440 --> 00:07:35,940
那我们等一下看他有没有执行多个

211
00:07:35,940 --> 00:07:41,040
你看你是PR的审查子代理

212
00:07:41,040 --> 00:07:42,740
主要负责什么什么是吧

213
00:07:42,740 --> 00:07:46,000
然后他这里就是开始去分配这个subagents了

214
00:07:46,000 --> 00:07:46,480
是吧

215
00:07:46,480 --> 00:07:50,300
这里面我们先让他跑着

216
00:07:50,300 --> 00:07:52,900
我开另外一个窗口同步的来看啊

217
00:07:52,900 --> 00:07:54,680
因为这个消息太多了

218
00:07:54,680 --> 00:07:56,940
有时候看得有点晕啊

219
00:07:56,940 --> 00:07:58,540
就是有点混乱了

220
00:07:58,540 --> 00:08:00,000
我这里再切一个窗口啊

221
00:08:01,431 --> 00:08:16,651
然后codex

222
00:08:16,651 --> 00:08:21,511
sub-agents

223
00:08:21,511 --> 00:08:28,691
它在这个里面

224
00:08:28,691 --> 00:08:30,051
把它当前会晃

225
00:08:30,051 --> 00:08:31,131
subo agents

226
00:08:32,131 --> 00:08:33,131
agents

227
00:08:38,731 --> 00:08:42,091
你看现在这里大家是不是就可以看到多个agents了

228
00:08:42,091 --> 00:08:43,051
是吧

229
00:08:43,051 --> 00:08:45,971
有做这种各种什么提问的呀

230
00:08:45,971 --> 00:08:46,291
是吧

231
00:08:46,291 --> 00:08:47,931
然后各种细节处理的呀

232
00:08:47,931 --> 00:08:48,731
是吧

233
00:08:48,731 --> 00:08:53,011
它会相当于给你单独去加几个这个出来啊

234
00:08:53,011 --> 00:08:56,291
那你可以把这个拿来分析一下

235
00:08:56,291 --> 00:08:59,051
让我推出去

236
00:08:59,051 --> 00:09:11,211
帮我分析下agents中

237
00:09:11,211 --> 00:09:14,131
因为开了多个

238
00:09:14,131 --> 00:09:15,371
我这里都有点卡了

239
00:09:15,371 --> 00:09:24,631
有具体的分工

240
00:09:24,631 --> 00:09:28,591
其实上面日志已经打出来

241
00:09:28,591 --> 00:09:30,091
但是比较多啊

242
00:09:30,091 --> 00:09:32,431
所以这个我们有点看不出来啊

243
00:09:32,431 --> 00:09:34,931
我们现在让这个分析一下

244
00:09:34,931 --> 00:09:40,451
因为这个正在执行啊

245
00:09:40,451 --> 00:09:42,151
所以他这个消息阻塞了

246
00:09:42,151 --> 00:09:43,771
不过没关系啊

247
00:09:43,771 --> 00:09:44,791
我们的这个效果已经

248
00:09:44,791 --> 00:09:48,391
我们可以切换到具体的agents里面去啊

249
00:09:48,391 --> 00:09:51,011
我们可以比如说切换到这个里面去

250
00:09:51,011 --> 00:09:53,391
然后你可以看这个子agent里面

251
00:09:53,391 --> 00:09:55,271
他在做不同的逻辑是吧

252
00:09:55,271 --> 00:09:58,691
他有的是在做安全问题

253
00:09:58,691 --> 00:10:00,531
有些是在做代码质量的

254
00:10:00,531 --> 00:10:03,111
大家可以自由的去切换啊

255
00:10:03,111 --> 00:10:04,251
比如说在这个里面

256
00:10:04,251 --> 00:10:05,611
我可以看出来

257
00:10:05,611 --> 00:10:07,291
主线程

258
00:10:07,291 --> 00:10:10,831
你可以自由的去切啊

259
00:10:10,831 --> 00:10:12,791
那我这个得关一下

260
00:10:12,791 --> 00:10:13,951
不然这个有点卡

261
00:10:13,951 --> 00:10:18,191
把它关一下

262
00:10:18,191 --> 00:10:20,771
这有点卡住了

263
00:10:20,771 --> 00:10:25,051
所以这个你开的越多的话

264
00:10:25,051 --> 00:10:28,191
整个可能就是对性能消耗也比较大

265
00:10:28,191 --> 00:10:31,171
所以我们这里面还是要给他先关掉

266
00:10:31,171 --> 00:10:33,311
不然这个太卡了

267
00:10:33,311 --> 00:10:36,071
就在这个里面啊

268
00:10:36,071 --> 00:10:38,031
在这个里面我们也是可以看得到的

269
00:10:38,031 --> 00:10:41,091
但这个他没有加载出来啊

270
00:10:42,211 --> 00:10:44,211
没关系

271
00:10:44,211 --> 00:10:45,911
刚刚那个我已经中断了

272
00:10:45,911 --> 00:10:47,751
这个会有点卡

273
00:10:47,751 --> 00:10:55,631
所以我们其实可以通过不同的这个子agent

274
00:10:55,631 --> 00:10:59,011
然后的话就是去执行各种各样的任务

275
00:10:59,011 --> 00:10:59,711
然后最终的话

276
00:10:59,711 --> 00:11:02,351
我们其实只关注这个结果有没有

277
00:11:02,351 --> 00:11:02,771
是吧

278
00:11:02,771 --> 00:11:05,571
所以大家可以通过这种方式的话

279
00:11:05,571 --> 00:11:07,511
你就可以去做各种各样的一些

280
00:11:07,511 --> 00:11:09,831
这个分析类的一些工作

281
00:11:09,831 --> 00:11:11,051
因为这种的话

282
00:11:11,051 --> 00:11:12,851
它是没有前后依赖的

283
00:11:12,851 --> 00:11:14,771
大家想怎么用就怎么用

284
00:11:14,771 --> 00:11:15,751
是吧

285
00:11:15,751 --> 00:11:18,051
他你不用考虑前后的依赖关系的话

286
00:11:18,051 --> 00:11:18,551
最终

287
00:11:18,551 --> 00:11:20,071
并行的去跑

288
00:11:20,071 --> 00:11:21,531
跟串行的去跑

289
00:11:21,531 --> 00:11:22,911
其实是

290
00:11:22,911 --> 00:11:25,151
效率不一样的

291
00:11:25,151 --> 00:11:27,091
你并行的去跑的话

292
00:11:27,091 --> 00:11:28,751
这个里面啊

293
00:11:28,751 --> 00:11:30,711
他的一个效率就会更高

294
00:11:30,711 --> 00:11:32,631
因为他可以同时去干活

295
00:11:32,631 --> 00:11:33,951
最终给你一个结果

296
00:11:33,951 --> 00:11:35,931
相当于同样是十秒钟

297
00:11:35,931 --> 00:11:37,471
一个任务

298
00:11:37,471 --> 00:11:39,331
如果是串行的去跑的话

299
00:11:39,331 --> 00:11:40,851
六个任务就是一分钟

300
00:11:40,851 --> 00:11:41,631
他才能跑完

301
00:11:41,631 --> 00:11:43,451
如果说是并行的话

302
00:11:43,451 --> 00:11:44,631
就是十秒钟

303
00:11:44,631 --> 00:11:45,851
把所有任务都跑完了

304
00:11:45,851 --> 00:11:47,651
这个效率是完全不一样的

305
00:11:47,651 --> 00:11:50,711
然后大家也可以通过这个

306
00:11:50,711 --> 00:11:52,911
斜杠agents命令

307
00:11:52,911 --> 00:11:54,571
然后去看一下

308
00:11:54,571 --> 00:11:56,211
当前正在运行的现成

309
00:11:56,211 --> 00:11:58,371
就是你也这个不能开太多了

310
00:11:58,371 --> 00:11:59,191
开太多的话

311
00:11:59,191 --> 00:11:59,891
这个会会

312
00:11:59,891 --> 00:12:01,171
电脑会很卡

313
00:12:01,171 --> 00:12:03,511
所以这个大家需要酌情去考虑

314
00:12:03,511 --> 00:12:04,931
基本上开个

315
00:12:04,931 --> 00:12:06,751
两三个就差不多了

316
00:12:06,751 --> 00:12:07,731
开太多的话

317
00:12:07,731 --> 00:12:11,151
反而就是这个执行会

318
00:12:11,151 --> 00:12:12,611
电脑会有一些影响

319
00:12:12,611 --> 00:12:14,831
但具体得看大家的实际情况

320
00:12:14,831 --> 00:12:16,271
有的你电脑配置高的话

321
00:12:16,271 --> 00:12:16,911
这也不所谓

322
00:12:16,911 --> 00:12:20,151
然后这个子制中体的话

323
00:12:20,151 --> 00:12:22,251
它的权限是怎么样的呢

324
00:12:22,251 --> 00:12:25,451
它会继承我们当前绘画的一个杀相策略啊

325
00:12:25,451 --> 00:12:26,991
也就是说你的主线程

326
00:12:26,991 --> 00:12:30,231
当前比如说用的是bypass模式啊

327
00:12:30,231 --> 00:12:32,191
给了所有的权限的话

328
00:12:32,191 --> 00:12:35,291
那它就是所有权限全开的

329
00:12:35,291 --> 00:12:38,311
如果说你给的是一个需要授权啊

330
00:12:38,311 --> 00:12:39,251
就需要用户确认的话

331
00:12:39,251 --> 00:12:41,111
它会也会继承你这个对话权限

332
00:12:41,111 --> 00:12:43,751
所以关键是看大家就是你想

333
00:12:43,751 --> 00:12:46,351
给一个什么样的权限

334
00:12:46,351 --> 00:12:48,531
比如说你想不要他在用户确认了

335
00:12:48,531 --> 00:12:50,351
你就把权限全放开就可以了

336
00:12:50,351 --> 00:12:53,031
这个就看大家的一个事情情况

337
00:12:53,031 --> 00:12:56,351
然后这个里面啊

338
00:12:56,351 --> 00:12:58,111
他主要就是子真正体的话

339
00:12:58,111 --> 00:12:59,551
他其实很多选项的话

340
00:12:59,551 --> 00:13:01,851
都是通过这个继承了

341
00:13:01,851 --> 00:13:06,271
这个主线程的这么一个真正体去处理的

342
00:13:06,271 --> 00:13:08,611
所以大家去设置这个权限的时候

343
00:13:08,611 --> 00:13:09,991
你也可以去关注一下

344
00:13:09,991 --> 00:13:12,551
就是你的主线程

345
00:13:12,551 --> 00:13:14,171
怎么来设定这个权限

346
00:13:14,171 --> 00:13:18,151
然后的话就是Codex里面

347
00:13:18,151 --> 00:13:21,111
它自带了三种类件的这个智能体

348
00:13:21,111 --> 00:13:22,771
就是我们可以去配置

349
00:13:22,771 --> 00:13:26,691
默认的话就是一个通用回退型的

350
00:13:26,691 --> 00:13:27,451
这么一个智能体

351
00:13:27,451 --> 00:13:29,651
然后Worker它是偏执行的

352
00:13:29,651 --> 00:13:32,711
适合去做一些实现和修复类的工作

353
00:13:32,711 --> 00:13:34,791
Explorer的话就是止读

354
00:13:34,791 --> 00:13:38,411
我们刚刚看到打印的这个日志的话

355
00:13:38,411 --> 00:13:39,751
有些就是Explorer的

356
00:13:39,751 --> 00:13:41,731
因为我们上面提到一个需求

357
00:13:41,731 --> 00:13:43,011
它都是查询嘛

358
00:13:43,011 --> 00:13:43,271
是吧

359
00:13:43,271 --> 00:13:44,391
只是做分析的

360
00:13:44,391 --> 00:13:46,131
它不需要执行一些

361
00:13:46,131 --> 00:13:47,511
这么修改类的一些任务

362
00:13:47,511 --> 00:13:49,611
所以这个就是Explorer

363
00:13:49,611 --> 00:13:51,571
这是Codex

364
00:13:51,571 --> 00:13:54,351
它会根据你当前的一些任务的一些情况

365
00:13:54,351 --> 00:13:55,731
分析出来

366
00:13:55,731 --> 00:13:58,951
它的一个结果应该是怎么样的

367
00:13:58,951 --> 00:13:59,251
是吧

368
00:13:59,251 --> 00:14:00,191
这个东西

369
00:14:00,191 --> 00:14:04,231
它是会根据实际情况去调整的

370
00:14:04,231 --> 00:14:05,651
如果说你拿去改代码的话

371
00:14:05,651 --> 00:14:08,071
它可能会选择这个Worker

372
00:14:08,071 --> 00:14:11,791
所以这个就是它具体的一个执行逻辑

373
00:14:11,791 --> 00:14:13,531
这个我们回头来验一下

374
00:14:13,531 --> 00:14:17,571
然后的话就是我们自定义这个整体的话

375
00:14:17,571 --> 00:14:23,271
它在这个.codex目入下面有一个.agents

376
00:14:23,271 --> 00:14:24,471
文件夹

377
00:14:24,471 --> 00:14:25,951
这个我们可以看一下

378
00:14:25,951 --> 00:14:29,631
就是你可以在当前这个项目下面

379
00:14:29,631 --> 00:14:33,391
你去建一个这个agents

380
00:14:33,391 --> 00:14:36,971
它的一个文件夹

381
00:14:36,971 --> 00:14:39,031
然后的话你可以去配这个agents

382
00:14:39,031 --> 00:14:41,731
然后的话就是你也可以什么呢

383
00:14:41,731 --> 00:14:43,191
在项目级别啊

384
00:14:43,191 --> 00:14:44,331
一个是在全局的

385
00:14:44,331 --> 00:14:45,451
一个是在项目的

386
00:14:45,451 --> 00:14:47,831
那我们等一下来先配一个项目级

387
00:14:47,831 --> 00:14:48,931
比如说

388
00:14:48,931 --> 00:14:53,691
我一个是这个分析

389
00:14:53,691 --> 00:14:55,331
我们就参考前面那几个嘛

390
00:14:55,331 --> 00:14:55,631
是吧

391
00:14:55,631 --> 00:14:58,611
我就让他分析代码问题跟质量

392
00:14:58,611 --> 00:15:00,471
我配两个这个agents

393
00:15:00,471 --> 00:15:01,631
让他去跑一下

394
00:15:01,631 --> 00:15:03,851
看一下能不能跑出效果出来

395
00:15:03,851 --> 00:15:04,231
是吧

396
00:15:04,231 --> 00:15:06,351
那其实就很简单

397
00:15:06,351 --> 00:15:09,371
那比如说我们现在就把这两个给复制一下

398
00:15:09,371 --> 00:15:11,411
怎么来弄呢

399
00:15:11,411 --> 00:15:13,651
首先我们打开这个里面

400
00:15:13,651 --> 00:15:18,031
然后我就直接在这个里面操作了

401
00:15:18,031 --> 00:15:22,091
你就直接在当前这个项目下面

402
00:15:22,091 --> 00:15:24,071
比如说这个project2下面

403
00:15:24,071 --> 00:15:26,111
然后找一个有代码的

404
00:15:26,111 --> 00:15:27,671
比如说这个里面

405
00:15:27,671 --> 00:15:28,871
myproject

406
00:15:28,871 --> 00:15:32,311
我现在找一个项目

407
00:15:32,311 --> 00:15:39,111
这个下面有我之前写的一些小游戏的项目

408
00:15:39,111 --> 00:15:41,391
那我就在这个下面吧

409
00:15:41,391 --> 00:15:44,651
比如说我们现在打开这个目录是吧

410
00:15:44,651 --> 00:15:46,191
然后在这个目录里面

411
00:15:46,191 --> 00:15:48,431
我们切换到这个Codex

412
00:15:48,431 --> 00:15:51,771
来我们这个是

413
00:15:51,771 --> 00:15:56,271
我要用终端展开啊

414
00:16:00,535 --> 00:16:02,135
之前是不是开了一个

415
00:16:02,135 --> 00:16:03,235
好在这个里面

416
00:16:03,235 --> 00:16:05,355
我切换到这个map project里面去

417
00:16:09,735 --> 00:16:10,735
map project

418
00:16:10,735 --> 00:16:11,595
那这个下面

419
00:16:11,595 --> 00:16:13,335
由我之前写的一些这个

420
00:16:13,335 --> 00:16:15,935
生成的一些小游戏的示例吗

421
00:16:15,935 --> 00:16:21,055
那现在我现在相当于我要做一个子智能体啊

422
00:16:21,055 --> 00:16:22,195
我要开两个智能体

423
00:16:22,195 --> 00:16:26,035
一个是去教验这个安全问题

424
00:16:26,035 --> 00:16:27,995
还有一个是教验这个代码质量问题

425
00:16:27,995 --> 00:16:29,075
我要写两个嘛

426
00:16:29,075 --> 00:16:30,495
所以应该怎么来弄呢

427
00:16:30,495 --> 00:16:32,135
我们进入codex

428
00:16:32,135 --> 00:16:40,155
比如说帮我配置两个子智能体

429
00:16:41,595 --> 00:16:44,355
或者你叫subagency也可以啊

430
00:16:44,355 --> 00:16:46,095
能体或者叫子代理

431
00:16:46,095 --> 00:16:47,235
他应该也能识别出来

432
00:16:47,235 --> 00:16:50,055
然后这个是

433
00:16:50,055 --> 00:16:54,415
这是我两个的一个需求是吧

434
00:16:54,415 --> 00:16:56,655
你就这么来写就可以了

435
00:16:56,655 --> 00:16:58,555
然后他默认就会在这个下面去

436
00:16:58,555 --> 00:17:01,375
新建这个agency.文件夹

437
00:17:01,375 --> 00:17:04,575
然后帮你把这个子智能体给他配进去

438
00:17:04,575 --> 00:17:05,515
你看啊

439
00:17:05,515 --> 00:17:07,995
他首先会看你这个里面有没有一个叫

440
00:17:07,995 --> 00:17:10,155
subagency的这么一个配置是吧

441
00:17:10,155 --> 00:17:10,895
没有的话

442
00:17:10,895 --> 00:17:12,015
他就会帮你去创建

443
00:17:12,015 --> 00:17:13,955
这是差的一个规范

444
00:17:13,955 --> 00:17:15,375
所以大家

445
00:17:15,375 --> 00:17:16,875
你其实直接让Codex

446
00:17:16,875 --> 00:17:19,335
帮你去配置就完了

447
00:17:19,335 --> 00:17:22,655
你不需要去看这个文档

448
00:17:22,655 --> 00:17:23,015
是吧

449
00:17:23,015 --> 00:17:25,135
但如果说你要调一些细节参数的话

450
00:17:25,135 --> 00:17:26,275
你还是要知道

451
00:17:26,275 --> 00:17:27,315
这里面那些规范的

452
00:17:27,315 --> 00:17:27,815
比如说

453
00:17:27,815 --> 00:17:29,715
这个子制整体的名称是什么

454
00:17:29,715 --> 00:17:30,515
描述是什么

455
00:17:30,515 --> 00:17:31,755
然后包括一些

456
00:17:31,755 --> 00:17:34,455
一些参数是吧

457
00:17:34,455 --> 00:17:36,535
它的一个含义是什么

458
00:17:36,535 --> 00:17:37,315
大家需要知道

459
00:17:37,315 --> 00:17:40,375
就你只是简单的配一个

460
00:17:40,375 --> 00:17:41,855
子制容体的话

461
00:17:41,855 --> 00:17:44,055
你就直接让它去执行就完了

462
00:17:44,055 --> 00:17:47,675
所以整个过程会比较简单

463
00:17:47,675 --> 00:17:49,475
诶

464
00:17:49,475 --> 00:17:51,015
那个是到哪里了

465
00:17:51,015 --> 00:17:52,675
这里有一个

466
00:17:52,675 --> 00:17:54,555
确认啊

467
00:17:54,555 --> 00:17:57,315
他说允许

468
00:17:57,315 --> 00:17:58,035
fine manage

469
00:17:58,035 --> 00:18:00,755
这是一个

470
00:18:00,755 --> 00:18:02,395
这是一个mcp服务

471
00:18:02,395 --> 00:18:05,215
这是允许

472
00:18:07,315 --> 00:18:10,075
你看接下来他会用补丁的方式

473
00:18:10,075 --> 00:18:12,195
添加两个agency.md文件

474
00:18:12,195 --> 00:18:15,575
并且在agency.md里面去补充一段子

475
00:18:15,575 --> 00:18:16,455
智能体的配置

476
00:18:16,455 --> 00:18:21,955
所以这些个参数大家需要知道啊

477
00:18:21,955 --> 00:18:25,635
比如说允许打开的智能体的一个现成的上限啊

478
00:18:25,635 --> 00:18:29,495
然后就是这个参数啊

479
00:18:29,495 --> 00:18:31,095
这个什么嵌套的深度啊

480
00:18:31,095 --> 00:18:31,655
是吧

481
00:18:31,655 --> 00:18:33,595
但这个大家需要的时候再去看啊

482
00:18:33,595 --> 00:18:34,675
你可能会不太理解

483
00:18:34,675 --> 00:18:37,075
什么叫深层的嵌套深度啊

484
00:18:37,075 --> 00:18:37,715
就是一个对话

485
00:18:37,715 --> 00:18:39,835
那当你遇到这个问题的时候

486
00:18:39,835 --> 00:18:40,535
你再去查

487
00:18:40,535 --> 00:18:43,815
就其实你也不用太关心这几个参数

488
00:18:43,815 --> 00:18:47,235
只是说你要知道有这么些内容就可以

489
00:18:47,235 --> 00:18:49,315
包括它的一个文件结构描述

490
00:18:49,315 --> 00:18:49,715
是吧

491
00:18:49,715 --> 00:18:52,575
你看现在已经好了

492
00:18:52,575 --> 00:18:53,515
你看配置了

493
00:18:53,515 --> 00:18:56,955
这样Codex目录下面有一个这个agency

494
00:18:56,955 --> 00:18:59,835
然后下面有两个子制容体

495
00:18:59,835 --> 00:19:00,235
是吧

496
00:19:00,235 --> 00:19:02,655
一个是做安全问题审查的

497
00:19:02,655 --> 00:19:04,975
还有一个是做代码质量审查的

498
00:19:04,975 --> 00:19:06,455
我们看一下

499
00:19:06,455 --> 00:19:10,115
在myproject下面

500
00:19:10,115 --> 00:19:12,055
有个点codex目录

501
00:19:12,055 --> 00:19:14,035
codex目录下面有个agents目录

502
00:19:14,035 --> 00:19:15,615
agents目录下面有个

503
00:19:15,615 --> 00:19:18,255
你看这个是做代码审查的子生体

504
00:19:18,255 --> 00:19:20,315
它的名称是什么

505
00:19:20,315 --> 00:19:21,775
你看对应到我们这个文档是吧

506
00:19:21,775 --> 00:19:22,655
名称描述

507
00:19:22,655 --> 00:19:24,875
实际我们用的最多的

508
00:19:24,875 --> 00:19:25,615
就是这两个参数

509
00:19:25,615 --> 00:19:26,575
其他的话

510
00:19:26,575 --> 00:19:27,875
没有特殊需求

511
00:19:27,875 --> 00:19:28,715
一般不用挑

512
00:19:28,715 --> 00:19:30,315
有需要的时候

513
00:19:30,315 --> 00:19:32,295
你让codex帮你生成就完了

514
00:19:32,295 --> 00:19:33,835
就你给它提需求就行了

515
00:19:33,835 --> 00:19:35,935
你不用单独去记这些个参数

516
00:19:35,935 --> 00:19:38,995
但是你需要知道有这么个概念在里面

517
00:19:38,995 --> 00:19:41,995
就是他支持这些个参数就可以了

518
00:19:41,995 --> 00:19:43,675
这个是做代码审查的

519
00:19:43,675 --> 00:19:45,555
你看审查子质整体

520
00:19:45,555 --> 00:19:46,575
论物是什么什么

521
00:19:46,575 --> 00:19:47,455
关注范围是什么

522
00:19:47,455 --> 00:19:48,435
审查原则是什么

523
00:19:48,435 --> 00:19:49,475
输出格式是什么

524
00:19:49,475 --> 00:19:51,815
另外一个是安全问题审查

525
00:19:51,815 --> 00:19:55,495
然后因为我们这个项目里面

526
00:19:55,495 --> 00:19:57,475
又有python又有html的项目

527
00:19:57,475 --> 00:19:59,055
所以他这里面输出了两种

528
00:19:59,055 --> 00:20:01,055
html单文件

529
00:20:01,055 --> 00:20:02,415
他的细节是什么

530
00:20:02,415 --> 00:20:05,715
python他的这个细节有什么

531
00:20:05,715 --> 00:20:06,775
审查原则是什么

532
00:20:06,775 --> 00:20:07,675
输出格是什么

533
00:20:07,675 --> 00:20:09,375
好

534
00:20:09,375 --> 00:20:10,415
然后完了之后

535
00:20:10,415 --> 00:20:11,875
我们可以通过这个

536
00:20:11,875 --> 00:20:12,955
看一下

537
00:20:12,955 --> 00:20:14,075
subagents

538
00:20:14,075 --> 00:20:16,515
这个是查看的

539
00:20:16,515 --> 00:20:17,515
agents

540
00:20:17,515 --> 00:20:24,055
这个是我们现在还没跑

541
00:20:24,055 --> 00:20:24,795
还没跑

542
00:20:24,795 --> 00:20:27,315
接下来你就可以让它去运行一下

543
00:20:27,315 --> 00:20:29,415
比如说

544
00:20:29,415 --> 00:20:32,835
针对当前

545
00:20:32,835 --> 00:20:35,535
项目

546
00:20:35,535 --> 00:20:40,135
代码使用智智能体

547
00:20:40,135 --> 00:20:49,355
同时进行

548
00:20:49,355 --> 00:20:52,655
两个场景啊

549
00:20:52,655 --> 00:20:54,995
同时进行代码质量审查

550
00:20:54,995 --> 00:20:57,035
还有安全问题审查

551
00:20:57,035 --> 00:21:04,935
你会看一下我们写的这个subagents

552
00:21:04,935 --> 00:21:06,275
到底能不能生效是吧

553
00:21:06,275 --> 00:21:09,195
然后我们现在你看agents

554
00:21:09,195 --> 00:21:10,815
现在这个是没有的是吧

555
00:21:10,815 --> 00:21:11,635
现在就一个吧

556
00:21:11,635 --> 00:21:14,135
然后我们现在等到跑的时候

557
00:21:14,135 --> 00:21:15,155
我们再来看一下

558
00:21:15,155 --> 00:21:16,855
它会不会起多个啊

559
00:21:16,855 --> 00:21:18,595
现在就只有一个

560
00:21:18,595 --> 00:21:20,995
因为它没有启动那个子智能体呢

561
00:21:20,995 --> 00:21:23,995
这里大家是看不出来的啊

562
00:21:23,995 --> 00:21:26,935
然后你看啊

563
00:21:26,935 --> 00:21:28,795
你是本项目的安全审查

564
00:21:28,795 --> 00:21:31,295
子制成体然后工作目录是啥啥啥

565
00:21:31,295 --> 00:21:33,155
现在已经起了一个了

566
00:21:33,155 --> 00:21:34,575
再退出去看一下

567
00:21:34,575 --> 00:21:35,995
agents

568
00:21:35,995 --> 00:21:38,895
然后大家看这个是不是

569
00:21:38,895 --> 00:21:39,395
一个

570
00:21:39,395 --> 00:21:42,395
主线程是什么是吧

571
00:21:42,395 --> 00:21:43,735
然后目标是吧

572
00:21:43,735 --> 00:21:46,735
然后相当于它都是做一个tolo

573
00:21:46,735 --> 00:21:49,075
就是探索这个主要是做一些分析

574
00:21:49,075 --> 00:21:51,255
类的然后两个两个角色

575
00:21:51,255 --> 00:21:53,775
这个应该是它生成的一个角色名

576
00:21:53,775 --> 00:21:54,995
每次都不一样

577
00:21:54,995 --> 00:21:57,015
然后这个是相当于

578
00:21:57,015 --> 00:21:59,335
他给你生成两个虚拟的数字员工

579
00:21:59,335 --> 00:22:01,975
所以这个里面

580
00:22:01,975 --> 00:22:03,555
他干活的就这两个

581
00:22:03,555 --> 00:22:04,175
是吧

582
00:22:04,175 --> 00:22:06,635
干活的就这两个

583
00:22:06,635 --> 00:22:07,895
他都是Expolo

584
00:22:07,895 --> 00:22:10,895
如果大家你想让他去改单法的话

585
00:22:10,895 --> 00:22:12,875
他应该会生成这个

586
00:22:12,875 --> 00:22:15,975
Worker的这么一个执行的一个Subagents

587
00:22:15,975 --> 00:22:18,695
我们其实可以再给他加一下

588
00:22:18,695 --> 00:22:21,175
就bug修正是吧

589
00:22:21,175 --> 00:22:23,235
我先给他退出去

590
00:22:23,235 --> 00:22:26,995
我现在才想再加一下

591
00:22:26,995 --> 00:22:30,595
恢复到之前那个对话吧

592
00:22:30,595 --> 00:22:40,295
Codex resume

593
00:22:40,295 --> 00:22:45,995
然后恢复到之前那个对话

594
00:22:53,235 --> 00:22:55,975
agents

595
00:22:55,975 --> 00:22:58,375
现在那个已经中断了

596
00:22:58,375 --> 00:22:59,795
然后

597
00:22:59,795 --> 00:23:02,615
再帮我

598
00:23:02,615 --> 00:23:04,195
开发一个

599
00:23:04,195 --> 00:23:07,235
代码

600
00:23:07,235 --> 00:23:12,535
代码修正

601
00:23:12,535 --> 00:23:16,335
的

602
00:23:16,335 --> 00:23:19,095
智能体

603
00:23:19,095 --> 00:23:24,415
配置一个

604
00:23:24,415 --> 00:23:30,415
我们主要是要看到这个代码开发的话

605
00:23:30,415 --> 00:23:32,315
就是Walker啊

606
00:23:32,315 --> 00:23:33,895
比较看一下这个区别就可以了

607
00:23:33,895 --> 00:23:36,855
这个是做执行任务的啊

608
00:23:36,855 --> 00:23:40,455
主要是要区分一下两种agents

609
00:23:40,455 --> 00:23:43,495
就以后大家你加了各种各样的这个子agent

610
00:23:43,495 --> 00:23:43,975
是吧

611
00:23:43,975 --> 00:23:45,955
那你需要知道

612
00:23:45,955 --> 00:23:48,575
这个它的类型是用来干嘛的

613
00:23:48,575 --> 00:23:50,935
应该这个是fix

614
00:23:50,935 --> 00:23:53,795
你就随便跑一个

615
00:23:53,795 --> 00:23:55,835
比如说我现在

616
00:23:58,802 --> 00:24:01,942
想让他去做代码修复

617
00:24:05,902 --> 00:24:07,062
使用

618
00:24:07,062 --> 00:24:12,302
自

619
00:24:12,302 --> 00:24:22,702
针对当前项目代码进行修复

620
00:24:22,702 --> 00:24:26,122
你就直接这么跟他说啊

621
00:24:26,122 --> 00:24:28,802
他会去起这个整体去修复代码

622
00:24:28,802 --> 00:24:34,602
但虽然我这个需求没有写明确啊

623
00:24:34,602 --> 00:24:35,562
他还是会扫一遍

624
00:24:35,562 --> 00:24:36,622
先把问题扫出来

625
00:24:36,622 --> 00:24:38,162
然后再去做这个事情

626
00:24:38,162 --> 00:24:42,582
然后我们看一下这个

627
00:24:42,582 --> 00:24:44,082
到底用的Worker是什么

628
00:24:44,082 --> 00:24:45,122
就是

629
00:24:45,122 --> 00:24:48,942
现在还是Exploro的

630
00:24:48,942 --> 00:24:53,162
等一下到具体修代码的时候

631
00:24:53,162 --> 00:24:53,782
才会那个

632
00:24:53,782 --> 00:24:54,922
所以这里得等

633
00:24:54,922 --> 00:24:57,822
等他先把问题给他分析出来

634
00:24:57,822 --> 00:24:59,822
然后再去跑

635
00:24:59,822 --> 00:25:03,222
所以他没到改代码之前的话

636
00:25:03,222 --> 00:25:05,462
他不会变成那个

637
00:25:05,462 --> 00:25:07,502
这个Worker的

638
00:25:07,502 --> 00:25:12,202
你看现在是不是变了

639
00:25:12,202 --> 00:25:14,562
现在是不是单独起了一个Worker在干活了

640
00:25:14,562 --> 00:25:16,022
这个就是改代码的

641
00:25:16,022 --> 00:25:17,842
做Fix的修正代码

642
00:25:17,842 --> 00:25:20,502
前面那几个都还是分析的

643
00:25:20,502 --> 00:25:22,442
这个大家需要注意一下

644
00:25:22,442 --> 00:25:23,942
并且前两个都是关闭的

645
00:25:23,942 --> 00:25:27,142
你看这个绿色的就表示在运行的

646
00:25:27,142 --> 00:25:30,542
这个灰掉的白色的就是没有运行的

647
00:25:30,542 --> 00:25:32,442
这个需要注意一下

648
00:25:32,442 --> 00:25:35,022
所以这几个类型

649
00:25:35,022 --> 00:25:35,882
大家要搞清楚

650
00:25:35,882 --> 00:25:37,902
一个是偏执行的

651
00:25:37,902 --> 00:25:39,002
修复代码的

652
00:25:39,002 --> 00:25:40,702
还有一个是只读的

653
00:25:40,702 --> 00:25:43,462
如果说你都没有加的话

654
00:25:43,462 --> 00:25:45,162
它可能会变成一个default

655
00:25:45,162 --> 00:25:47,762
那个man的

656
00:25:47,762 --> 00:25:48,302
我看一下

657
00:25:48,302 --> 00:25:50,562
默认的agents的

658
00:25:50,562 --> 00:25:52,702
这个你看man就是default

659
00:25:52,702 --> 00:25:54,542
主线程

660
00:25:54,542 --> 00:25:55,842
他啥都干

661
00:25:55,842 --> 00:25:57,622
就是用来回退的

662
00:25:57,622 --> 00:25:59,662
主线程的默认就是default

663
00:25:59,662 --> 00:26:02,402
一般我们开子制容体要么

664
00:26:02,402 --> 00:26:03,542
就是去帮你干活

665
00:26:03,542 --> 00:26:06,222
做一些实现跟修复嘛

666
00:26:06,222 --> 00:26:07,502
要么就是做分析

667
00:26:07,502 --> 00:26:08,502
只读的啊

668
00:26:08,502 --> 00:26:10,362
就是这个是可读可写

669
00:26:10,362 --> 00:26:12,562
这个是只读的啊

670
00:26:12,562 --> 00:26:13,542
或者说这个就是

671
00:26:13,542 --> 00:26:15,762
就是用来专门就是用来盖活子啊

672
00:26:15,762 --> 00:26:17,502
好

673
00:26:17,502 --> 00:26:18,482
这个是项目级的

674
00:26:18,482 --> 00:26:20,802
那么大家其实你也可以在这个

675
00:26:20,802 --> 00:26:24,182
我们整个的一个全局的啊

676
00:26:24,182 --> 00:26:27,562
Codex的全局的这个配置里面

677
00:26:27,562 --> 00:26:29,542
去加这个子智能体啊

678
00:26:33,542 --> 00:26:37,102
配置里面

679
00:26:37,102 --> 00:26:39,422
打开这个配置

680
00:26:39,422 --> 00:26:41,502
然后打开这个路径

681
00:26:41,502 --> 00:26:43,842
这个路径下面

682
00:26:43,842 --> 00:26:47,542
打开这个路径

683
00:26:47,542 --> 00:26:51,102
这个路径下面有一个agents

684
00:26:51,102 --> 00:26:53,582
咱现在没有那个文件奖啊

685
00:26:53,582 --> 00:26:56,322
大家可以在全局的这个当前用户目的下面

686
00:26:56,322 --> 00:26:59,442
去创建一个这个agents

687
00:26:59,442 --> 00:27:01,142
agents文件奖

688
00:27:01,142 --> 00:27:04,142
就跟咱们这个项目这里是一样的

689
00:27:04,142 --> 00:27:05,262
项目这里

690
00:27:05,262 --> 00:27:08,322
创建了这么一个agents

691
00:27:08,322 --> 00:27:09,502
是吧

692
00:27:09,502 --> 00:27:11,642
在这个里面

693
00:27:11,642 --> 00:27:13,942
就是他有一个agents

694
00:27:13,942 --> 00:27:15,302
然后在这个下面

695
00:27:15,302 --> 00:27:18,162
我们建三个子agents

696
00:27:18,162 --> 00:27:19,122
对吧

697
00:27:19,122 --> 00:27:21,102
就帮你可以去同时干活

698
00:27:21,102 --> 00:27:22,222
就这么意思

699
00:27:22,222 --> 00:27:26,282
然后这些个文件结构

700
00:27:26,282 --> 00:27:27,342
大家知道就行了

701
00:27:27,342 --> 00:27:28,542
主要就是这两个

702
00:27:28,542 --> 00:27:30,782
其他的话暂时都是用不上

703
00:27:30,782 --> 00:27:32,542
有需要的话你让AI

704
00:27:32,542 --> 00:27:34,842
帮你去加

705
00:27:34,842 --> 00:27:36,442
就你有特殊需求提出来

706
00:27:36,442 --> 00:27:38,702
他会自动的去帮你加这些参数

707
00:27:38,702 --> 00:27:41,262
只要他能匹配到这些个需求

708
00:27:41,262 --> 00:27:44,682
然后包括一些描述啊

709
00:27:44,682 --> 00:27:44,982
是吧

710
00:27:44,982 --> 00:27:46,262
然后大家你也可以

711
00:27:46,262 --> 00:27:48,042
他就是用markdown的方式去写的

712
00:27:48,042 --> 00:27:50,942
你看我们就正常跟写提示词一样

713
00:27:50,942 --> 00:27:52,702
其实这个所谓的子整体的话

714
00:27:52,702 --> 00:27:54,702
都是以提示词去驱动的

715
00:27:54,702 --> 00:27:56,522
整个的一个整体干活

716
00:27:56,522 --> 00:27:57,942
他就是参考了这个提示词

717
00:27:57,942 --> 00:27:59,482
就是他的一个工作流程啊

718
00:27:59,482 --> 00:28:01,302
所以这个里面的话

719
00:28:01,302 --> 00:28:03,602
其实也很好理解啊

720
00:28:03,602 --> 00:28:05,462
就是用TS调整大模型

721
00:28:05,462 --> 00:28:06,522
然后做一个理解

722
00:28:06,522 --> 00:28:08,922
然后在agents去做一个执行的

723
00:28:08,922 --> 00:28:13,722
所以说这个里面啊

724
00:28:13,722 --> 00:28:15,082
这就是它的一个规范

725
00:28:15,082 --> 00:28:19,702
那么大家你也可以通过去改一些这个

726
00:28:19,702 --> 00:28:25,482
用户级别的一些agents的一些规范

727
00:28:25,482 --> 00:28:29,462
比如说我们可以做一个拆分是吧

728
00:28:29,462 --> 00:28:32,202
有TiExplorer的

729
00:28:32,202 --> 00:28:33,402
有Review的

730
00:28:33,402 --> 00:28:37,082
然后就是可以做各种各样的一些处理的

731
00:28:37,082 --> 00:28:38,462
就大家你可以自定义

732
00:28:38,462 --> 00:28:40,802
就你想要什么一个真体的话

733
00:28:40,802 --> 00:28:42,122
你自己去定义就可以了

734
00:28:42,122 --> 00:28:43,162
再把规范写好

735
00:28:43,162 --> 00:28:45,562
他就可以去干这个事情

736
00:28:45,562 --> 00:28:47,162
兴起的话我们还可以在

737
00:28:47,162 --> 00:28:50,162
这个用户

738
00:28:50,162 --> 00:28:52,162
就是项目级别或者用户级别

739
00:28:52,162 --> 00:28:53,402
去加一些什么呢

740
00:28:53,402 --> 00:28:55,182
比如说他的最大线程

741
00:28:55,182 --> 00:28:57,222
有可能他卡太卡

742
00:28:57,222 --> 00:28:58,962
你比如说开十个线程

743
00:28:58,962 --> 00:28:59,762
电脑太卡了

744
00:28:59,762 --> 00:29:01,542
那你就改造三个

745
00:29:01,542 --> 00:29:02,662
或者一个线程

746
00:29:02,662 --> 00:29:06,122
就这个就是这个线程

747
00:29:06,122 --> 00:29:07,202
线程越多的话

748
00:29:07,202 --> 00:29:08,722
指线效率越高

749
00:29:08,722 --> 00:29:11,022
但是的话性能也会下降

750
00:29:11,022 --> 00:29:13,302
因为你的CPU运行资源

751
00:29:13,302 --> 00:29:14,182
可能不够的时候

752
00:29:14,182 --> 00:29:15,762
反正电脑会很卡

753
00:29:15,762 --> 00:29:18,222
所以这个大家需要去考虑

754
00:29:18,222 --> 00:29:19,322
应该设置多少

755
00:29:19,322 --> 00:29:22,322
然后包括一些什么深度啊

756
00:29:22,322 --> 00:29:22,662
是吧

757
00:29:22,662 --> 00:29:24,542
各种各样的一些参数啊

758
00:29:24,542 --> 00:29:25,362
比如说

759
00:29:25,362 --> 00:29:27,242
你还可以针对不同的

760
00:29:27,242 --> 00:29:28,762
这个子制整体

761
00:29:28,762 --> 00:29:29,722
去配置模型啊

762
00:29:29,722 --> 00:29:31,742
比如说有一些是写代码的

763
00:29:31,742 --> 00:29:34,682
那你建议用5.3的这个Codex版本

764
00:29:34,682 --> 00:29:37,362
有些是做那个分析的是吧

765
00:29:37,362 --> 00:29:40,202
一些个项目嘛是吧

766
00:29:40,202 --> 00:29:41,242
阅读代码的

767
00:29:41,242 --> 00:29:44,762
那我建议你可以用这个5.5是吧

768
00:29:44,762 --> 00:29:47,282
它比较适合你做一些推理分析的一些工作

769
00:29:47,282 --> 00:29:50,602
写代码的话就用Codex版本会比较好一些啊

770
00:29:50,602 --> 00:29:54,622
所以说这个子制中体里面

771
00:29:54,622 --> 00:29:57,422
你其实可以加各种各样的一些配置啊

772
00:29:57,422 --> 00:29:58,402
他的一些这个

773
00:29:58,402 --> 00:30:01,462
描述啊

774
00:30:01,462 --> 00:30:01,682
是吧

775
00:30:01,682 --> 00:30:02,602
模型啊

776
00:30:02,602 --> 00:30:04,462
然后包括他的一个

777
00:30:04,462 --> 00:30:05,182
沙相模式

778
00:30:05,182 --> 00:30:05,802
大家就可以改

779
00:30:05,802 --> 00:30:07,382
我们刚刚给他说的是

780
00:30:07,382 --> 00:30:08,002
沙相模式

781
00:30:08,002 --> 00:30:09,242
你如果不写的话

782
00:30:09,242 --> 00:30:11,842
他会默认用我们

783
00:30:11,842 --> 00:30:12,862
子线程

784
00:30:12,862 --> 00:30:13,802
就主线程

785
00:30:13,802 --> 00:30:16,102
带过来的这个权限

786
00:30:16,102 --> 00:30:17,282
如果大家配的话

787
00:30:17,282 --> 00:30:19,202
就以你配的这个为准

788
00:30:19,202 --> 00:30:20,762
包括模型的这个

789
00:30:20,762 --> 00:30:22,282
推理的这个等级

790
00:30:22,282 --> 00:30:22,602
是吧

791
00:30:22,602 --> 00:30:24,302
大家也可以做一个search

792
00:30:24,302 --> 00:30:26,122
就是子这种体

793
00:30:26,122 --> 00:30:28,042
它是可以单独进行配置的

794
00:30:28,042 --> 00:30:29,782
但是你如果没有配置的话

795
00:30:29,782 --> 00:30:34,322
它会默认的用主线程的那个配置计程过来

796
00:30:34,322 --> 00:30:35,382
这个是需要注意的

797
00:30:35,382 --> 00:30:37,442
所以大家可以根据实际情况

798
00:30:37,442 --> 00:30:38,322
你做一个调整

799
00:30:38,322 --> 00:30:40,682
把这些个子制容体的一些参数调一调

800
00:30:40,682 --> 00:30:43,282
然后让它就是没有什么问题

801
00:30:43,282 --> 00:30:47,262
然后的话就是这套配置的话

802
00:30:47,262 --> 00:30:49,022
我们还可以去加一些这个

803
00:30:49,022 --> 00:30:51,422
不同的这个提示词是吧

804
00:30:51,422 --> 00:30:53,682
就是你比如说你也不知道应该配什么的时候

805
00:30:53,682 --> 00:30:54,342
你就提要求

806
00:30:54,342 --> 00:30:57,302
比如说你说要子智能体具备一些

807
00:30:57,302 --> 00:30:58,742
超级管理员

808
00:30:58,742 --> 00:31:00,982
这个所有的权限都要给他

809
00:31:00,982 --> 00:31:03,062
并且这个模型要清晃到5.3

810
00:31:03,062 --> 00:31:04,922
然后退理等级用高

811
00:31:04,922 --> 00:31:07,822
你就把这些个参数告诉他

812
00:31:07,822 --> 00:31:09,542
让他自己去生成就可以了

813
00:31:09,542 --> 00:31:10,862
你自己不需要改这东西

814
00:31:10,862 --> 00:31:12,022
你让他去生成就完了

815
00:31:12,022 --> 00:31:13,662
但是你要把需求描述清楚

816
00:31:13,662 --> 00:31:17,142
然后我们还可以用子智能体

817
00:31:17,142 --> 00:31:18,442
去处理一些这个

818
00:31:18,442 --> 00:31:20,722
CSV的一些批样任务

819
00:31:20,722 --> 00:31:22,162
那么这个

820
00:31:22,162 --> 00:31:23,762
目前啊

821
00:31:23,762 --> 00:31:25,722
还是一个实验性的一个能力

822
00:31:25,722 --> 00:31:26,762
但后面啊

823
00:31:26,762 --> 00:31:28,302
最新更新的版本

824
00:31:28,302 --> 00:31:29,562
可能会把它变成一个

825
00:31:29,562 --> 00:31:30,962
这个正式版本

826
00:31:30,962 --> 00:31:34,642
那比如说我们现在要做数据分析工作

827
00:31:34,642 --> 00:31:34,962
是吧

828
00:31:34,962 --> 00:31:37,482
那现在你可以加一些这个子智能体

829
00:31:37,482 --> 00:31:39,702
专门去用来去完成一些

830
00:31:39,702 --> 00:31:41,382
CSV的一些数据啊

831
00:31:41,382 --> 00:31:43,882
读取一些那个结果

832
00:31:43,882 --> 00:31:44,242
是吧

833
00:31:44,242 --> 00:31:47,002
然后我们可以去生成Worker

834
00:31:47,002 --> 00:31:48,622
比如说

835
00:31:48,622 --> 00:31:51,302
这个就比较适合一座审计类的一些工作

836
00:31:51,302 --> 00:31:55,462
人家有一些他要去按行去审查文件啊

837
00:31:55,462 --> 00:31:56,322
一些表格嘛

838
00:31:56,322 --> 00:31:56,962
对吧

839
00:31:56,962 --> 00:31:58,682
一些数据啊

840
00:31:58,682 --> 00:32:00,042
一些PDF解析啊

841
00:32:00,317 --> 00:32:03,117
或者是一些一组数据啊

842
00:32:03,117 --> 00:32:03,337
是吧

843
00:32:03,337 --> 00:32:04,997
或者PR啊等等的啊

844
00:32:04,997 --> 00:32:05,837
或者等等的

845
00:32:05,837 --> 00:32:07,997
一些个啊

846
00:32:07,997 --> 00:32:10,137
需要分批去处理的

847
00:32:10,137 --> 00:32:12,897
这个就比较适合于用这个子制整体啊

848
00:32:12,897 --> 00:32:15,557
因为它可以一直工作嘛

849
00:32:15,557 --> 00:32:17,417
可以开多个任务

850
00:32:17,417 --> 00:32:18,377
然后的话就是

851
00:32:18,377 --> 00:32:21,217
我们可以去指定CSV的一个路径

852
00:32:21,217 --> 00:32:22,017
对吧

853
00:32:22,017 --> 00:32:24,377
包括它的一个Worker啊

854
00:32:24,377 --> 00:32:25,517
就干活的一个逻辑

855
00:32:25,517 --> 00:32:27,177
它的一个细节是什么

856
00:32:27,177 --> 00:32:29,397
并且的话就是它的一个

857
00:32:29,397 --> 00:32:31,937
整个的一些逻辑啊

858
00:32:31,937 --> 00:32:34,777
就你都可以去自定义啊

859
00:32:34,777 --> 00:32:37,797
所以这个里面啊

860
00:32:37,797 --> 00:32:40,477
它可以去调用各种各样的一些

861
00:32:40,477 --> 00:32:42,017
这个Agent啊

862
00:32:42,017 --> 00:32:42,637
去读取

863
00:32:42,637 --> 00:32:44,217
你看像这里的话

864
00:32:44,217 --> 00:32:45,257
我们就告诉他们

865
00:32:45,257 --> 00:32:47,797
这个里面有一些CSV数据是吧

866
00:32:47,797 --> 00:32:50,437
那你可以去做一些这个读取

867
00:32:50,437 --> 00:32:53,297
但你也可以通过Codex的一个

868
00:32:53,297 --> 00:32:56,577
非交互式的这个命令的方式去运行

869
00:32:56,577 --> 00:32:58,797
这样的话就特别适合于

870
00:32:58,797 --> 00:33:00,097
把它整合到一些

871
00:33:00,097 --> 00:33:01,877
塞藥脚本里面去

872
00:33:01,877 --> 00:33:03,157
因为我们以前

873
00:33:03,157 --> 00:33:05,877
这个比如说在服务器上跑

874
00:33:05,877 --> 00:33:07,457
都是跑塞藥脚本的是吧

875
00:33:07,457 --> 00:33:09,377
塞藥脚本里面就不太好用

876
00:33:09,377 --> 00:33:10,657
这种交互式的页面了

877
00:33:10,657 --> 00:33:11,957
就是说你要进入到一个

878
00:33:11,957 --> 00:33:13,577
TY的终端跟他对话

879
00:33:13,577 --> 00:33:15,857
他更多的是希望用

880
00:33:15,857 --> 00:33:18,077
这个非交互式的命令去运行

881
00:33:18,077 --> 00:33:21,877
所以你直接给他输入输出结果就可以了

882
00:33:21,877 --> 00:33:22,617
所以说

883
00:33:22,617 --> 00:33:25,177
看大家的一个应用场景

884
00:33:25,177 --> 00:33:27,197
如果说你想要把Codex

885
00:33:27,197 --> 00:33:29,117
变成一个这个

886
00:33:29,117 --> 00:33:31,557
后端的一个任务

887
00:33:31,557 --> 00:33:31,777
是吧

888
00:33:31,777 --> 00:33:33,777
就服务器端一个摄像脚本去运行的话

889
00:33:33,777 --> 00:33:35,957
那你就用非交互式的方式去运行

890
00:33:35,957 --> 00:33:37,497
如果说你只是自己

891
00:33:37,497 --> 00:33:40,017
用TY的对话方式去使用的话

892
00:33:40,017 --> 00:33:41,277
你就不需要加这个指令

893
00:33:41,277 --> 00:33:44,097
所以看大家大家的一个使用情况

894
00:33:44,097 --> 00:33:48,357
然后包括一些那个agents的一个最大线程数啊

895
00:33:48,357 --> 00:33:49,477
然后他的一个时间啊

896
00:33:49,477 --> 00:33:49,677
是不是

897
00:33:49,677 --> 00:33:56,557
然后比如说我们还要做一些什么前端集成调试是吧

898
00:33:56,557 --> 00:33:59,597
比如说一些前端兼容性的问题啊

899
00:33:59,597 --> 00:34:00,237
是吧

900
00:34:00,237 --> 00:34:02,437
然后回归测试啊

901
00:34:03,437 --> 00:34:06,237
那么大家就单独可以去开发一些子生体

902
00:34:06,237 --> 00:34:07,637
去什么呢

903
00:34:07,637 --> 00:34:08,657
比如说操作流暖器

904
00:34:08,657 --> 00:34:09,737
去做自动化测试

905
00:34:09,737 --> 00:34:10,577
去做验证

906
00:34:10,577 --> 00:34:11,897
然后生成一些色彩报告

907
00:34:11,897 --> 00:34:14,237
并且的话可以去什么呢

908
00:34:14,237 --> 00:34:16,457
去加一些这个配置

909
00:34:16,457 --> 00:34:16,957
是吧

910
00:34:16,957 --> 00:34:19,377
就是你可以做很多自动化的一些事情

911
00:34:19,377 --> 00:34:20,997
就是在前端

912
00:34:20,997 --> 00:34:23,357
你可以比如说针对浏览器做一些debug

913
00:34:23,357 --> 00:34:24,077
是吧

914
00:34:24,077 --> 00:34:26,897
然后去生成一些这个

915
00:34:26,897 --> 00:34:29,097
性能的一些报告

916
00:34:29,097 --> 00:34:29,997
截屏

917
00:34:29,997 --> 00:34:31,257
然后分析

918
00:34:31,257 --> 00:34:34,177
当前的这个UI上面有哪些问题

919
00:34:34,177 --> 00:34:35,817
包括它的一个设计

920
00:34:35,817 --> 00:34:37,577
设计我们可以通过截图来分析

921
00:34:37,577 --> 00:34:37,957
是吧

922
00:34:37,957 --> 00:34:40,577
那包括他整个的一些细节啊

923
00:34:40,577 --> 00:34:42,657
应该是怎么样的

924
00:34:42,657 --> 00:34:43,997
你都可以通过这个

925
00:34:43,997 --> 00:34:46,317
子整体去实现了

926
00:34:46,317 --> 00:34:50,297
所以说这个子整体能干的事情非常多啊

927
00:34:50,297 --> 00:34:51,217
就是做一些

928
00:34:51,217 --> 00:34:54,017
流水线工作的时候

929
00:34:54,017 --> 00:34:57,517
需要大量的这个分批次啊

930
00:34:57,517 --> 00:35:00,057
按照这个可以并行的去执行啊

931
00:35:00,057 --> 00:35:02,177
比如这个是做UI修复的

932
00:35:02,177 --> 00:35:06,017
上面是做浏览器bug的一个调试的是吧

933
00:35:06,017 --> 00:35:08,957
那你就可以去做各种各样的一个场景

934
00:35:08,957 --> 00:35:12,597
那这里面我给大家演示一下

935
00:35:12,597 --> 00:35:16,597
就首先是CSV批量数据是吧

936
00:35:16,597 --> 00:35:19,697
那这里面比如说我先建个文件夹

937
00:35:19,697 --> 00:35:24,197
我在这里面建一个文件夹

938
00:35:24,197 --> 00:35:25,857
叫做CSV

939
00:35:25,857 --> 00:35:29,037
那我让Codex帮我生成一些数据

940
00:35:29,037 --> 00:35:34,857
CSV

941
00:35:34,857 --> 00:35:39,857
然后我现在切换到这个目录里面去啊

942
00:35:39,857 --> 00:35:49,737
cssv

943
00:35:49,737 --> 00:35:56,597
然后帮我生成

944
00:35:56,597 --> 00:36:00,757
我们让他想做一个什么事情呢

945
00:36:00,757 --> 00:36:05,997
比如说我现在想去做一个

946
00:36:05,997 --> 00:36:09,757
先生成12个月的一个

947
00:36:09,757 --> 00:36:13,137
这个比如说产品的一个销售的一个情况

948
00:36:13,137 --> 00:36:13,517
是吧

949
00:36:13,517 --> 00:36:16,457
然后再把它会会总成一个年度的一个报告

950
00:36:16,457 --> 00:36:17,297
啊

951
00:36:17,297 --> 00:36:18,537
我们做这样一个情况

952
00:36:18,537 --> 00:36:20,137
这个实现啊

953
00:36:20,137 --> 00:36:23,577
帮我生成1到12月份

954
00:36:23,577 --> 00:36:28,237
你就生成1到12月份

955
00:36:28,237 --> 00:36:29,917
嗯

956
00:36:29,917 --> 00:36:34,617
销售数据的CSV

957
00:36:34,617 --> 00:36:36,937
视力

958
00:36:36,937 --> 00:36:43,557
电子产品吧

959
00:36:43,557 --> 00:36:46,537
电子产品销售数据的CSV

960
00:36:46,537 --> 00:36:47,957
文件

961
00:36:47,957 --> 00:36:52,257
总计12个文件

962
00:36:52,257 --> 00:36:55,417
要求

963
00:36:55,417 --> 00:36:58,297
数据

964
00:36:58,297 --> 00:37:00,897
尽量真实

965
00:37:00,897 --> 00:37:02,837
尽量真实一点

966
00:37:02,837 --> 00:37:06,877
这个就是我们的需求

967
00:37:06,877 --> 00:37:07,957
这是我们的需求

968
00:37:07,957 --> 00:37:10,297
然后我现在进入到Codex

969
00:37:10,297 --> 00:37:18,557
我先让他把CSV数据给他生产出来

970
00:37:18,557 --> 00:37:19,477
生产出来之后

971
00:37:19,477 --> 00:37:23,337
然后我让他并行的去处理12个月的数据

972
00:37:23,337 --> 00:37:28,257
最终我关注的是年度的这个销售数据的一个报告

973
00:37:28,257 --> 00:37:30,017
这个报告的话

974
00:37:30,017 --> 00:37:32,777
我想让它生成这个

975
00:37:32,777 --> 00:37:34,717
然后看一下

976
00:37:34,717 --> 00:37:36,297
生成一个PDF吧

977
00:37:36,297 --> 00:37:37,197
区分一下

978
00:37:37,197 --> 00:37:38,557
就生成PDF数据吧

979
00:37:38,557 --> 00:37:40,797
这样大家会看到更加清晰一些

980
00:37:40,797 --> 00:37:45,377
首先先生成

981
00:37:45,377 --> 00:37:46,837
先生成完之后的话

982
00:37:46,837 --> 00:37:48,217
然后再去处理

983
00:37:48,217 --> 00:37:52,817
这个就是我们想

984
00:37:52,817 --> 00:37:54,917
并行的去处理一个cell数据

985
00:37:54,917 --> 00:37:57,517
这只是一个案例

986
00:37:57,517 --> 00:37:58,997
就是大家你可以以后

987
00:37:58,997 --> 00:38:00,917
不管是CSV数据也好

988
00:38:00,917 --> 00:38:02,477
还是其他的各种各样的文件

989
00:38:02,477 --> 00:38:04,917
只要他需要分批处理的

990
00:38:04,917 --> 00:38:06,877
并且可以支持并且处理的

991
00:38:06,877 --> 00:38:09,597
然后需要做一个汇总的这种场景

992
00:38:09,597 --> 00:38:13,897
就特别适合用子智能体去做一个优化

993
00:38:13,897 --> 00:38:15,577
就提高它的一个效率

994
00:38:15,577 --> 00:38:18,917
所以这一块是大家可以去关注的一个点

995
00:38:27,517 --> 00:38:30,437
所以他生成完之后的话

996
00:38:30,437 --> 00:38:32,177
我们再来做一个汇总啊

997
00:38:32,177 --> 00:38:35,037
等下会让他开发一个SysV的一个

998
00:38:35,037 --> 00:38:37,257
这个Worker是吧

999
00:38:37,257 --> 00:38:41,217
然后再去分析数据啊

1000
00:38:41,217 --> 00:38:44,537
其实我现在可以同步开发

1001
00:38:44,537 --> 00:38:47,637
我再切换到一个这个里面去啊

1002
00:38:47,637 --> 00:38:50,017
我现在一边生成数据

1003
00:38:50,017 --> 00:38:52,457
一边去切换到这个

1004
00:38:52,457 --> 00:38:54,077
让他去开发这个agency

1005
00:38:54,077 --> 00:38:58,317
比如说agents

1006
00:38:58,317 --> 00:39:02,837
csv

1007
00:39:02,837 --> 00:39:05,377
比如说

1008
00:39:05,377 --> 00:39:08,137
我们进入到codex

1009
00:39:08,137 --> 00:39:12,777
帮我

1010
00:39:12,777 --> 00:39:14,917
你看12个月的数据基本上快生成完了

1011
00:39:14,917 --> 00:39:15,177
是吧

1012
00:39:15,177 --> 00:39:19,837
我首先让他开发一个这个subagents

1013
00:39:19,837 --> 00:39:24,757
帮我配置一个

1014
00:39:24,757 --> 00:39:33,477
CSV数据分析的子智能体

1015
00:39:33,477 --> 00:39:36,837
然后啊

1016
00:39:36,837 --> 00:39:41,317
能体和

1017
00:39:41,317 --> 00:39:44,757
CSV

1018
00:39:44,757 --> 00:39:49,997
想一下

1019
00:39:49,997 --> 00:39:52,597
一个是做数据分析的

1020
00:39:52,597 --> 00:39:57,097
就这个只是指分析给出这个结论是吧

1021
00:39:57,097 --> 00:39:59,177
指正体和

1022
00:40:00,413 --> 00:40:02,313
或者说怎么叫

1023
00:40:02,313 --> 00:40:04,573
CSV

1024
00:40:04,573 --> 00:40:07,593
数据

1025
00:40:07,593 --> 00:40:12,873
数据汇总

1026
00:40:15,413 --> 00:40:44,093
CSIVE年度销售数据贵总生成PDF报告的

1027
00:40:45,413 --> 00:40:48,893
子智能体

1028
00:40:48,893 --> 00:40:56,953
我们就分两类吧

1029
00:40:56,953 --> 00:40:59,153
一类叫数据分析

1030
00:40:59,153 --> 00:41:03,313
总结啊

1031
00:41:03,313 --> 00:41:04,033
一个叫总结

1032
00:41:04,033 --> 00:41:05,933
一个叫这个汇总啊

1033
00:41:05,933 --> 00:41:06,613
总结这里

1034
00:41:06,613 --> 00:41:09,893
总结我们就是输出txt啊

1035
00:41:09,893 --> 00:41:12,253
报告

1036
00:41:12,253 --> 00:41:16,293
和去生成PDF汇总报告

1037
00:41:16,293 --> 00:41:18,113
就是两种场景

1038
00:41:18,113 --> 00:41:20,613
我们都给它去加一下

1039
00:41:20,613 --> 00:41:27,413
就最后要看到两个文件

1040
00:41:27,413 --> 00:41:29,393
一个是用来去生成TXT的

1041
00:41:29,393 --> 00:41:31,233
一个是用来去生成PDF的

1042
00:41:31,233 --> 00:41:33,933
这个就是我们的需求

1043
00:41:33,933 --> 00:41:35,273
然后数据来源

1044
00:41:35,273 --> 00:41:36,513
就这些CSV数据

1045
00:41:36,513 --> 00:41:39,933
所以我们等一下来看一下

1046
00:41:39,933 --> 00:41:43,453
这两个Worker的一个工作逻辑

1047
00:42:09,933 --> 00:42:18,013
好

1048
00:42:18,013 --> 00:42:18,813
我们等它生成

1049
00:42:18,813 --> 00:42:21,893
然后我们首先来看一下这个数据啊

1050
00:42:21,893 --> 00:42:23,213
1月份

1051
00:42:23,213 --> 00:42:24,693
2月份

1052
00:42:24,693 --> 00:42:25,273
3月份

1053
00:42:25,273 --> 00:42:26,133
4月份

1054
00:42:26,133 --> 00:42:28,273
这个数据看上去没什么问题啊

1055
00:42:28,273 --> 00:42:30,253
都是一些电子产品的销售数据是吧

1056
00:42:30,253 --> 00:42:32,473
然后我们等一下看一下

1057
00:42:32,473 --> 00:42:34,813
这个生成出来的报告是什么样的

1058
00:42:34,813 --> 00:42:37,753
然后现在它在开发这个

1059
00:42:37,753 --> 00:42:39,233
Subagency

1060
00:42:39,233 --> 00:42:43,113
这里需要一点时间

1061
00:42:43,113 --> 00:42:55,993
他帮我去写了一个agents.md文件

1062
00:42:55,993 --> 00:42:59,313
因为我之前这个有一套规范

1063
00:42:59,313 --> 00:43:01,673
我定义了一套全局的ddt规范

1064
00:43:01,673 --> 00:43:05,193
所以他把这个领域的这个规范

1065
00:43:05,193 --> 00:43:07,433
也应用到了C4V的这个分析里面去了

1066
00:43:07,433 --> 00:43:10,333
其实是不需要这个规范的

1067
00:43:10,333 --> 00:43:12,433
但是我因为我当时写了全局规范了

1068
00:43:12,433 --> 00:43:13,793
所以他也把它考虑进去了

1069
00:43:13,793 --> 00:43:15,833
这个也没关系

1070
00:43:15,833 --> 00:43:19,873
我们只要看那个subagents能不能生成就完了

1071
00:43:19,873 --> 00:43:25,153
你看TOM语法教验通过

1072
00:43:25,153 --> 00:43:26,693
目录也预计生成

1073
00:43:26,693 --> 00:43:27,213
然后

1074
00:43:27,213 --> 00:43:29,653
他

1075
00:43:29,653 --> 00:43:31,133
看一下

1076
00:43:31,133 --> 00:43:33,573
这个子这张体

1077
00:43:37,433 --> 00:43:40,273
在Codex目录下面

1078
00:43:40,273 --> 00:43:41,593
有一个agents

1079
00:43:41,593 --> 00:43:43,313
agents下面生成了这个

1080
00:43:43,313 --> 00:43:45,153
首先是一个tom文件

1081
00:43:45,153 --> 00:43:47,653
你看这次的是一个tom文件的方式

1082
00:43:47,653 --> 00:43:49,953
它不是一个markdown了

1083
00:43:49,953 --> 00:43:51,433
就这个

1084
00:43:51,433 --> 00:43:54,353
我看一下应该也是可以的

1085
00:43:54,353 --> 00:43:55,273
tom文件

1086
00:43:55,273 --> 00:43:58,453
描述

1087
00:43:58,453 --> 00:44:01,713
然后包括一些这个细节啊

1088
00:44:01,713 --> 00:44:02,013
是吧

1089
00:44:02,013 --> 00:44:03,773
都是可以的

1090
00:44:03,773 --> 00:44:06,613
就他用markdown跟那个都是可以执行的

1091
00:44:06,613 --> 00:44:09,533
这个tome文件也是ok的

1092
00:44:09,533 --> 00:44:10,613
咱们都是配置文件

1093
00:44:10,613 --> 00:44:12,293
工作方式

1094
00:44:12,293 --> 00:44:13,453
然后年度汇总

1095
00:44:13,453 --> 00:44:15,093
这个是pdf的是吧

1096
00:44:15,093 --> 00:44:16,913
这是tst的

1097
00:44:16,913 --> 00:44:19,053
你看它的报告就不太一样了

1098
00:44:19,053 --> 00:44:19,313
是吧

1099
00:44:19,313 --> 00:44:21,253
现在我们就让它干活了

1100
00:44:21,253 --> 00:44:28,373
帮我生成

1101
00:44:28,373 --> 00:44:38,853
pdf报告

1102
00:44:38,853 --> 00:44:40,833
你就这么说

1103
00:44:40,833 --> 00:44:44,293
帮我分析当前所有

1104
00:44:44,293 --> 00:44:48,953
csv文件

1105
00:44:48,953 --> 00:44:51,133
然后输出

1106
00:44:51,133 --> 00:44:54,593
这里我们提一下

1107
00:44:54,593 --> 00:44:57,973
然后调用子智能体

1108
00:44:57,973 --> 00:45:06,933
生成TXT报告和PDF报告

1109
00:45:06,933 --> 00:45:09,273
好就完事了

1110
00:45:09,273 --> 00:45:12,193
然后这两个自动体

1111
00:45:12,193 --> 00:45:14,113
我们等一下看一下它的一个工作逻辑

1112
00:45:14,113 --> 00:45:15,973
现在还正在执行

1113
00:45:15,973 --> 00:45:18,773
就看一下它两个可以并行处理

1114
00:45:18,773 --> 00:45:21,973
同时生成这个TXT跟PDF

1115
00:45:27,973 --> 00:45:57,173
它会首先去分析这个SysV

1116
00:45:57,173 --> 00:45:58,633
里面的一些数据

1117
00:45:58,633 --> 00:46:01,333
然后包括一些任务

1118
00:46:01,333 --> 00:46:04,533
看一下这个agents有没有在工作了

1119
00:46:04,533 --> 00:46:06,293
agents

1120
00:46:06,293 --> 00:46:09,273
你看现在有一个在工作了

1121
00:46:09,273 --> 00:46:11,993
但是还没定性是不是worker

1122
00:46:11,993 --> 00:46:13,533
因为他没写文件了

1123
00:46:13,533 --> 00:46:14,353
他在做分析

1124
00:46:14,353 --> 00:46:17,173
所以这个是一个默认的

1125
00:46:17,173 --> 00:46:18,893
你看这个agents县层里面

1126
00:46:18,893 --> 00:46:19,733
他还在工作

1127
00:46:19,733 --> 00:46:23,493
我现在已经切换到这个直升体里面了

1128
00:46:23,493 --> 00:46:25,373
他现在还在执行

1129
00:46:25,373 --> 00:46:28,033
所以还看不出来它的一个类型

1130
00:46:28,033 --> 00:46:29,953
你看现在是不是就有了

1131
00:46:29,953 --> 00:46:31,213
当前的

1132
00:46:31,213 --> 00:46:34,053
你看下面两个再生成PDF跟Word了

1133
00:46:34,053 --> 00:46:35,533
跟这个DXT了

1134
00:46:35,533 --> 00:46:37,373
所以它是Walk了

1135
00:46:37,373 --> 00:46:39,613
就是切换到这个里面去

1136
00:46:39,613 --> 00:46:41,633
切换到这个子智能体里面

1137
00:46:41,633 --> 00:46:44,373
它现在再读取一些工具了

1138
00:46:44,373 --> 00:46:47,193
你看这个是读

1139
00:46:47,193 --> 00:46:49,393
这个是生成PDF的

1140
00:46:49,393 --> 00:46:51,533
我们再切换到另外一个

1141
00:46:51,533 --> 00:46:54,233
这个是看一下

1142
00:46:54,233 --> 00:46:57,433
这个就是txt了啊

1143
00:46:57,433 --> 00:47:03,233
就一个txt一个是这个pdf啊

1144
00:47:03,233 --> 00:47:05,473
然后还有一个这个是干嘛的

1145
00:47:09,433 --> 00:47:11,133
这个是之前的

1146
00:47:11,133 --> 00:47:14,393
这是之前去生成这个文件的

1147
00:47:18,593 --> 00:47:19,573
直读完成

1148
00:47:19,573 --> 00:47:19,893
没有

1149
00:47:19,893 --> 00:47:23,973
这是之前去生成agents的那些个

1150
00:47:23,973 --> 00:47:24,973
这个县城啊

1151
00:47:28,373 --> 00:47:30,913
目前你看这里有一个绿色的啊

1152
00:47:30,913 --> 00:47:34,013
绿色的就是正在工作的啊

1153
00:47:34,013 --> 00:47:35,313
活动的

1154
00:47:35,313 --> 00:47:38,633
然后这个白色的就是聪明已经关掉了啊

1155
00:47:38,633 --> 00:47:41,673
所以我们主要关注这两个worker就行了

1156
00:47:41,673 --> 00:47:46,773
一个生成pdf的一个生成这个txt的啊

1157
00:47:46,773 --> 00:47:49,613
所以他主要关注这两个就行了

1158
00:47:49,613 --> 00:47:52,633
啊在这个下面我们会看到他整个的一个报告

1159
00:47:52,633 --> 00:47:53,633
是吧

1160
00:47:53,973 --> 00:47:54,614
好

1161
00:47:56,314 --> 00:47:57,154
那等他跑完

1162
00:47:57,154 --> 00:47:57,614
跑完之后

1163
00:47:57,614 --> 00:47:58,814
我们就能看到那个报告了

1164
00:48:09,614 --> 00:48:17,754
编码入口修好了

1165
00:48:17,754 --> 00:48:20,394
然后再验证这个PowerShell到Python

1166
00:48:20,394 --> 00:48:21,854
可以保持UTF刚报

1167
00:48:21,854 --> 00:48:25,034
就是它这个中间会帮你去考虑一些编码问题

1168
00:48:25,034 --> 00:48:27,574
如果说你有一些编码问题的话

1169
00:48:27,574 --> 00:48:30,074
这个时候它可能会有一些问题

1170
00:48:30,074 --> 00:48:32,994
所以这个细节大家需要考虑一下

1171
00:48:32,994 --> 00:48:38,194
这里面有些进程它可能报错了

1172
00:48:38,194 --> 00:48:39,434
那你要去看一下

1173
00:48:39,434 --> 00:48:41,674
如果他跑了很久的话

1174
00:48:41,674 --> 00:48:42,634
你可以关注一下

1175
00:48:42,634 --> 00:48:44,474
当然他都会帮你去处理

1176
00:48:44,474 --> 00:48:47,474
只是这个时间可能会耗费比较久

1177
00:48:47,474 --> 00:48:56,234
你看报告已经写出来了

1178
00:48:56,234 --> 00:48:57,614
然后他会复合一下

1179
00:48:57,614 --> 00:49:01,134
但是他没写文件啊

1180
00:49:01,134 --> 00:49:02,754
他已经输出了

1181
00:49:02,754 --> 00:49:03,894
看一下

1182
00:49:03,894 --> 00:49:05,574
TXT的已经写完了啊

1183
00:49:05,574 --> 00:49:07,314
你看这个TXT的给了一个报告

1184
00:49:07,314 --> 00:49:10,374
总的一个情况

1185
00:49:10,374 --> 00:49:10,694
是吧

1186
00:49:10,694 --> 00:49:11,774
销售数据啊

1187
00:49:11,774 --> 00:49:12,794
品类啊

1188
00:49:12,794 --> 00:49:13,014
是吧

1189
00:49:13,014 --> 00:49:13,894
品牌啊

1190
00:49:13,894 --> 00:49:16,114
应该是不是都帮你分析的清清楚楚的

1191
00:49:16,114 --> 00:49:16,714
渠道啊

1192
00:49:16,714 --> 00:49:17,114
是吧

1193
00:49:17,114 --> 00:49:19,314
整个的都帮你分析了

1194
00:49:19,314 --> 00:49:21,094
然后还差一个PDF的

1195
00:49:21,094 --> 00:49:23,174
PDF的慢一点啊

1196
00:49:23,174 --> 00:49:24,834
因为他要去

1197
00:49:24,834 --> 00:49:26,074
叫PDF的一些库

1198
00:49:26,074 --> 00:49:28,854
然后我们看一下这个agency

1199
00:49:28,854 --> 00:49:31,054
有一个是已经终结了

1200
00:49:31,054 --> 00:49:32,934
但这里还在work

1201
00:49:32,934 --> 00:49:35,454
看一下这个

1202
00:49:35,454 --> 00:49:37,054
这个还在写啊

1203
00:49:37,314 --> 00:49:40,774
这个生日PDF的会稍微慢一点

1204
00:49:40,774 --> 00:49:42,674
因为他可能还要画一些图表啊

1205
00:49:42,674 --> 00:49:44,534
所以就慢一点

1206
00:49:44,534 --> 00:49:48,834
那这个数据还是挺完善的是吧

1207
00:49:48,834 --> 00:49:50,114
帮我们把一些细节问题

1208
00:49:50,114 --> 00:49:52,194
其实都考虑的非常清楚了

1209
00:49:52,194 --> 00:49:54,894
所以大家看到这个报告的时候啊

1210
00:49:54,894 --> 00:49:57,134
已经是他里面做了非常多的总结归纳了

1211
00:49:57,134 --> 00:50:01,054
然后这个PDF会稍微慢一点

1212
00:50:01,054 --> 00:50:07,174
所以我们回过头再来看一下

1213
00:50:07,174 --> 00:50:08,574
在这个文档里面

1214
00:50:08,574 --> 00:50:09,714
这里就可以提到

1215
00:50:09,714 --> 00:50:11,574
就这些个点啊

1216
00:50:11,574 --> 00:50:13,654
一些C4V的这些个数据的话

1217
00:50:13,654 --> 00:50:16,554
大家可以用在各种各样的场景里面啊

1218
00:50:16,554 --> 00:50:19,014
不要局限于这个C4V这个场景啊

1219
00:50:19,014 --> 00:50:21,314
你可以把它用到各种啊

1220
00:50:21,314 --> 00:50:24,014
包括我们前面给他讲的那个代码分析

1221
00:50:24,014 --> 00:50:25,754
也是一个比较好的场景是吧

1222
00:50:25,754 --> 00:50:28,054
就是这种可以并行的

1223
00:50:28,054 --> 00:50:29,714
分批量的去跑的任务

1224
00:50:29,714 --> 00:50:31,574
你都可以交给这个

1225
00:50:31,574 --> 00:50:34,334
Codex的一个subagents

1226
00:50:34,334 --> 00:50:36,374
让他专门去写一个字笼体

1227
00:50:36,374 --> 00:50:38,374
去跑这个任务

1228
00:50:38,374 --> 00:50:39,254
这样的话

1229
00:50:39,254 --> 00:50:40,974
它可以并行的去处理

1230
00:50:40,974 --> 00:50:42,234
它的效率会很高

1231
00:50:42,234 --> 00:50:44,014
所以的话

1232
00:50:44,014 --> 00:50:45,754
最终啊

1233
00:50:45,754 --> 00:50:47,074
就生成这个报告的话

1234
00:50:47,074 --> 00:50:48,234
哎

1235
00:50:48,234 --> 00:50:49,334
这个效果

1236
00:50:49,334 --> 00:50:51,614
效率就比较高啊

1237
00:50:51,614 --> 00:50:54,194
然后这个前单调受的话

1238
00:50:54,194 --> 00:50:56,414
也是一个比较好的场景啊

1239
00:50:56,414 --> 00:50:57,534
就是大家可以把这个

1240
00:50:57,534 --> 00:50:59,474
整合到不同的这个

1241
00:50:59,474 --> 00:51:03,334
一些自动化测试啊

1242
00:51:03,334 --> 00:51:03,674
是吧

1243
00:51:03,674 --> 00:51:05,314
包括一些后端接口啊

1244
00:51:05,314 --> 00:51:06,294
比如说我后端的接口

1245
00:51:06,294 --> 00:51:06,974
代码写完了

1246
00:51:06,974 --> 00:51:09,214
我现在想通过CURL

1247
00:51:09,214 --> 00:51:11,334
单独我开一个

1248
00:51:11,334 --> 00:51:12,514
这个直升体

1249
00:51:12,514 --> 00:51:13,614
想用CURL

1250
00:51:13,614 --> 00:51:14,954
把整个的一个测试

1251
00:51:14,954 --> 00:51:15,734
都给它跑通

1252
00:51:15,734 --> 00:51:16,974
跑通

1253
00:51:16,974 --> 00:51:18,274
各种的案例测试

1254
00:51:18,274 --> 00:51:19,354
没问题之后的话

1255
00:51:19,354 --> 00:51:21,314
咱们再来去验证

1256
00:51:21,314 --> 00:51:22,514
这个里面的逻辑

1257
00:51:22,514 --> 00:51:24,154
有没有问题

1258
00:51:24,154 --> 00:51:24,854
是吧

1259
00:51:24,854 --> 00:51:28,714
就是代码一写完

1260
00:51:28,714 --> 00:51:30,094
自动化测试

1261
00:51:30,094 --> 00:51:32,694
就可以开始做了

1262
00:51:32,694 --> 00:51:34,614
这个就是可以并行的

1263
00:51:34,614 --> 00:51:35,274
包括一些

1264
00:51:35,274 --> 00:51:37,034
文档是吧

1265
00:51:37,034 --> 00:51:38,074
文档生成啊

1266
00:51:38,074 --> 00:51:39,234
一些逻辑啊

1267
00:51:39,234 --> 00:51:40,454
你就可以去生成

1268
00:51:40,454 --> 00:51:42,174
甚至你有些现成

1269
00:51:42,174 --> 00:51:43,854
他可以去协作啊

1270
00:51:43,854 --> 00:51:45,374
就你可以一直让他等在那里

1271
00:51:45,374 --> 00:51:46,634
比如说当大码开发完了

1272
00:51:46,634 --> 00:51:48,014
马上就启动一个

1273
00:51:48,014 --> 00:51:49,854
自动化测试的一个现成

1274
00:51:49,854 --> 00:51:51,194
自动化测试完之后

1275
00:51:51,194 --> 00:51:52,434
马上就生成一个

1276
00:51:52,434 --> 00:51:53,874
测试报告的一个现成

1277
00:51:53,874 --> 00:51:55,394
就让他给启动了

1278
00:51:55,394 --> 00:51:58,214
所以大家可以在这个里面

1279
00:51:58,214 --> 00:52:00,234
加各种各样的一个场景啊

1280
00:52:00,234 --> 00:52:02,734
其实啊

1281
00:52:02,734 --> 00:52:04,374
都可以做很多事情

1282
00:52:05,274 --> 00:52:07,514
然后pdf看有没有生成啊

1283
00:52:08,734 --> 00:52:10,214
还没有生成这个比较慢啊

1284
00:52:10,214 --> 00:52:13,434
因为它要涉及到非常多的代码逻辑啊

1285
00:52:15,034 --> 00:52:16,674
可能还会有一些编码报错

1286
00:52:16,674 --> 00:52:18,634
因为他要保证不会出现乱码

1287
00:52:19,274 --> 00:52:21,114
好大家看这个pdf已经生成了

1288
00:52:21,714 --> 00:52:22,914
我看一下有没有问题

1289
00:52:26,434 --> 00:52:29,714
已经生成成功指标也跑出来了啊

1290
00:52:29,714 --> 00:52:30,414
看一下

1291
00:52:35,274 --> 00:52:38,074
大家看

1292
00:52:38,074 --> 00:52:39,374
这是他跑出来的这个数据

1293
00:52:39,374 --> 00:52:42,774
这个效果还是不错的

1294
00:52:42,774 --> 00:52:45,974
但是这个字体有点没设计好

1295
00:52:45,974 --> 00:52:48,534
包括一些规范阅读

1296
00:52:48,534 --> 00:52:50,774
你看这个图表都是给咱们画出来的

1297
00:52:50,774 --> 00:52:52,314
还是比较完善的

1298
00:52:52,314 --> 00:52:54,094
产品维度等等的

1299
00:52:54,094 --> 00:52:55,034
还不错

1300
00:52:55,034 --> 00:52:58,494
默认没有加任何节日时优化

1301
00:52:58,494 --> 00:53:00,654
能够做到这种程度还是比较完善了

1302
00:53:00,654 --> 00:53:02,574
所以它的效果也算OK

1303
00:53:02,574 --> 00:53:07,734
所以这个里面就是大家可以做很多的这种优化

1304
00:53:07,734 --> 00:53:10,594
一些智能体等等的

1305
00:53:10,594 --> 00:53:11,114
是吧

1306
00:53:11,114 --> 00:53:13,214
我们就可以做各种各样的调优

1307
00:53:13,214 --> 00:53:16,254
包括一些bug的一些修复

1308
00:53:16,254 --> 00:53:16,874
是吧

1309
00:53:16,874 --> 00:53:18,894
然后我们都可以去做一些处理

1310
00:53:18,894 --> 00:53:20,594
那这个的话

1311
00:53:20,594 --> 00:53:22,954
回头大家可以去验证一下

1312
00:53:22,954 --> 00:53:24,794
你可以把它用到不同的场景里面去

1313
00:53:24,794 --> 00:53:27,454
一个是做CSV的这个数据分析是吧

1314
00:53:27,454 --> 00:53:29,274
一个是做代码的一个审查

1315
00:53:29,274 --> 00:53:32,154
包括前端的一个机身调试测试

1316
00:53:32,154 --> 00:53:34,054
或者后端的一个自动化测试

1317
00:53:34,054 --> 00:53:38,114
大家都可以基于这个子智能体去做一个实战

1318
00:53:38,114 --> 00:53:40,214
回头我们可以去看一下