WEBVTT

00:00:00.000 --> 00:00:03.940
接下来我们来讲一下

00:00:03.940 --> 00:00:05.460
Codex Sub-Agents

00:00:05.460 --> 00:00:08.060
多智能体协同与复杂论物分发

00:00:08.060 --> 00:00:10.540
那么这个一般是用在什么场景呢

00:00:10.540 --> 00:00:13.580
比如说大家要做一个非常复杂的一个任务

00:00:13.580 --> 00:00:15.320
比如说我们要做一个大项目

00:00:15.320 --> 00:00:17.560
这个项目里面涉及到一些需求分析

00:00:17.560 --> 00:00:20.840
然后开发测试

00:00:20.840 --> 00:00:22.380
包括部署等等的

00:00:22.380 --> 00:00:24.760
非常多的一些细节问题的时候

00:00:24.760 --> 00:00:27.420
那这时候我们要对一个大项目

00:00:27.420 --> 00:00:28.740
做一个任务的一个拆分

00:00:28.740 --> 00:00:32.200
按需求按开发按测试按部署等等

00:00:32.200 --> 00:00:34.420
我们要把任务拆出来

00:00:34.420 --> 00:00:35.860
拆出来之后的话

00:00:35.860 --> 00:00:40.100
我们这个任务应该怎么来执行呢

00:00:40.100 --> 00:00:40.640
是吧

00:00:40.640 --> 00:00:42.080
那么在Codex里面的话

00:00:42.080 --> 00:00:45.000
就有一个叫做Subagents的这么一个组件

00:00:45.000 --> 00:00:47.760
那这个翻译过来叫做子智能体

00:00:47.760 --> 00:00:50.200
也就是说大家可以把Codex

00:00:50.200 --> 00:00:53.040
整个看作一个大的一个智能体的话

00:00:53.040 --> 00:00:58.000
那它去单独可以去开一些子的一个智能体

00:00:58.000 --> 00:00:59.540
去帮我们去完成一个任务

00:00:59.540 --> 00:01:02.520
就相当于我们现在是一个公司是吧

00:01:02.520 --> 00:01:04.180
那Codex相当于这个公司

00:01:04.180 --> 00:01:05.740
那现在有员工啊

00:01:05.740 --> 00:01:07.840
每个部门有负责人是吧

00:01:07.840 --> 00:01:10.340
然后他要带头去做不同的项目

00:01:10.340 --> 00:01:13.860
有这个具体的这个同事负责不同的这个工作

00:01:13.860 --> 00:01:16.820
你就可以把这些个同事看作这个子agent

00:01:16.820 --> 00:01:19.800
那么你可以把它看作成一个小团队

00:01:19.800 --> 00:01:21.760
他可以做不同的这个任务

00:01:21.760 --> 00:01:23.740
这个就是决策定义

00:01:23.740 --> 00:01:24.860
然后并且的话

00:01:24.860 --> 00:01:26.440
这里面有个非常关键的点

00:01:26.440 --> 00:01:27.900
就是他可以并行

00:01:28.000 --> 00:01:28.660
什么意思呢

00:01:28.660 --> 00:01:29.760
就是我这个任务啊

00:01:29.760 --> 00:01:32.380
我不是说要等是吧

00:01:32.380 --> 00:01:34.420
那我这个开发跟测试

00:01:34.420 --> 00:01:36.220
我这个测试的文档

00:01:36.220 --> 00:01:37.360
是不是可以先生成了

00:01:37.360 --> 00:01:37.760
是吧

00:01:37.760 --> 00:01:38.960
那你需求出来之后

00:01:38.960 --> 00:01:40.320
我这个这个代码

00:01:40.320 --> 00:01:41.440
是不是就可以开始写了

00:01:41.440 --> 00:01:43.280
然后测试的一些规范

00:01:43.280 --> 00:01:44.500
是不是就可以开始做了

00:01:44.500 --> 00:01:45.420
就有些工作

00:01:45.420 --> 00:01:46.720
它是可以并行的啊

00:01:46.720 --> 00:01:48.900
它不是说依赖于上面那个工作

00:01:48.900 --> 00:01:50.700
完成了才能做下一刻

00:01:50.700 --> 00:01:53.160
我们是可以做一些编排的啊

00:01:53.160 --> 00:01:54.460
就多个整体之间

00:01:54.460 --> 00:01:55.600
它是可以协作的

00:01:55.600 --> 00:01:56.860
那么Codex的话

00:01:56.860 --> 00:01:58.680
就可以通过这种并行的方式

00:01:58.680 --> 00:02:00.820
启动多个专用的这种智能体

00:02:00.820 --> 00:02:05.060
帮我们一起同时的去做各自的一些工作

00:02:05.060 --> 00:02:06.280
然后做完之后的话

00:02:06.280 --> 00:02:08.340
给它做一些合并

00:02:08.340 --> 00:02:08.760
是吧

00:02:08.760 --> 00:02:10.800
然后把这个结果做一下这个归纳

00:02:10.800 --> 00:02:13.400
比如说我整个一个项目是有需求

00:02:13.400 --> 00:02:14.840
有开发有测试

00:02:14.840 --> 00:02:15.200
是吧

00:02:15.200 --> 00:02:16.280
有部署等等的

00:02:16.280 --> 00:02:18.920
我希望它并行可以去完成一些事情

00:02:18.920 --> 00:02:21.320
就是我有一些工作完成之后

00:02:21.320 --> 00:02:24.460
我可以交由智能体自动的去切换

00:02:24.460 --> 00:02:25.400
然后去协作

00:02:25.400 --> 00:02:28.440
最终我的目标是这个项目要上线

00:02:28.440 --> 00:02:30.780
我只关注这个目标就可以了

00:02:30.780 --> 00:02:32.780
那么其他的步骤怎么来分的话

00:02:32.780 --> 00:02:35.020
我们可以让Codex里面

00:02:35.020 --> 00:02:37.120
这个叫Subagents的一个组件

00:02:37.120 --> 00:02:38.180
去做这个事情

00:02:38.180 --> 00:02:40.860
那么目前Codex的话

00:02:40.860 --> 00:02:41.780
最新版本

00:02:41.780 --> 00:02:45.080
它是默认启用了一个Subagents的话

00:02:45.080 --> 00:02:47.080
大家可以正常的去使用

00:02:47.080 --> 00:02:50.360
那么一般我们可以把它用在一个

00:02:50.360 --> 00:02:51.540
什么样的一个场景呢

00:02:51.540 --> 00:02:53.160
比如说啊

00:02:53.160 --> 00:02:56.180
我们可以去做一个非常大型的项目

00:02:56.180 --> 00:02:58.660
比如说我现在要针对这个PR是吧

00:02:58.660 --> 00:02:59.320
做审查

00:02:59.320 --> 00:03:01.160
我要审查的安全问题

00:03:01.160 --> 00:03:02.440
代码质量bug

00:03:02.440 --> 00:03:04.380
这种场景的话

00:03:04.380 --> 00:03:06.960
就特别适合用这个subagents

00:03:06.960 --> 00:03:09.260
因为它前后的这个任务

00:03:09.260 --> 00:03:10.300
没有关联项

00:03:10.300 --> 00:03:11.900
它都可以并行的去执行

00:03:11.900 --> 00:03:14.240
它不是说先要把安全问题查出来

00:03:14.240 --> 00:03:15.680
再把代码质量分析一下

00:03:15.680 --> 00:03:16.240
再去查bug

00:03:16.240 --> 00:03:18.380
这同时可以去

00:03:18.380 --> 00:03:19.940
同步的去跑

00:03:19.940 --> 00:03:22.780
跑出来之后给一个汇总的结果就可以了

00:03:22.780 --> 00:03:23.720
所以这种任务

00:03:23.720 --> 00:03:24.600
它特别适合

00:03:24.600 --> 00:03:25.780
于用这个Codex

00:03:25.780 --> 00:03:27.580
像我们刚刚讲的

00:03:27.580 --> 00:03:28.380
那个软件的

00:03:28.380 --> 00:03:29.500
这个开发工作流的话

00:03:29.500 --> 00:03:31.080
它还是会有一些依赖的

00:03:31.080 --> 00:03:33.360
文档可以同时去生成

00:03:33.360 --> 00:03:35.700
但是你得先把代码写出来

00:03:35.700 --> 00:03:36.640
才得去测试

00:03:36.640 --> 00:03:37.180
是吧

00:03:37.180 --> 00:03:39.060
所以它还是有一定的依赖的

00:03:39.060 --> 00:03:40.460
但是做代码审查

00:03:40.460 --> 00:03:42.220
就特别适合于这种场景

00:03:42.220 --> 00:03:43.840
那么这个Codex

00:03:43.840 --> 00:03:45.640
它就会做各种各样的编码

00:03:45.640 --> 00:03:46.940
比如说它会去生成

00:03:46.940 --> 00:03:48.600
新的一个子智能体

00:03:48.600 --> 00:03:50.880
然后给不同的智能体

00:03:50.880 --> 00:03:52.720
去录有我们后续的一个指令

00:03:52.720 --> 00:03:54.540
然后就等待一些结果

00:03:54.540 --> 00:03:56.940
最后每个智能体

00:03:56.940 --> 00:03:59.360
子智能体它的一个任务完成之后

00:03:59.360 --> 00:04:01.460
我们再把这个子线上给关闭掉

00:04:01.460 --> 00:04:04.420
所以说这个就是一步的方式

00:04:04.420 --> 00:04:06.000
那么Codex它也会等待

00:04:06.000 --> 00:04:07.580
所有的这个结果完成之后

00:04:07.580 --> 00:04:09.080
再做一个汇总答复

00:04:09.080 --> 00:04:11.300
所以说我们可以

00:04:11.300 --> 00:04:12.780
以这个提示式的方式

00:04:12.780 --> 00:04:14.360
让Codex来跑一下

00:04:14.360 --> 00:04:16.740
这个当前的一些个情况

00:04:16.740 --> 00:04:17.200
是吧

00:04:17.200 --> 00:04:18.400
然后再看一下

00:04:18.400 --> 00:04:20.620
这里面我们首先给大家来演示一下

00:04:20.620 --> 00:04:24.980
那我现在我这个低盘下面有一个Codex目录啊

00:04:24.980 --> 00:04:27.840
那这里我是把Codex的一个开源项目拉下来

00:04:27.840 --> 00:04:29.940
我们就以这个项目为例啊

00:04:29.940 --> 00:04:33.180
然后让他去分析一下这个PR是吧

00:04:33.180 --> 00:04:34.620
随便找一个PR吧

00:04:34.620 --> 00:04:37.460
嗯

00:04:37.460 --> 00:04:40.260
然后的话就是当前PR

00:04:40.260 --> 00:04:41.920
就随便

00:04:41.920 --> 00:04:44.080
下Codex

00:04:44.080 --> 00:04:45.280
我就找一个啊

00:04:45.280 --> 00:04:46.260
看一下他的一个PR

00:04:46.260 --> 00:04:54.660
我们最开始给大家提供了一个项目

00:04:54.660 --> 00:04:56.400
就是Codex的一个开源项目

00:04:56.400 --> 00:05:00.220
然后去找到这个整个的一个PR

00:05:00.220 --> 00:05:02.660
看一下

00:05:02.660 --> 00:05:06.700
就我就随便找一个PR了

00:05:06.700 --> 00:05:07.660
那我就用这个

00:05:07.660 --> 00:05:09.920
我把这个PR复制一下

00:05:09.920 --> 00:05:12.880
然后的话这里面

00:05:12.880 --> 00:05:15.860
我们进入Codex

00:05:15.860 --> 00:05:18.460
比如这个是一个PR是吧

00:05:18.460 --> 00:05:20.880
那我们就给它分析一下

00:05:20.880 --> 00:05:22.380
复制一下

00:05:22.380 --> 00:05:25.340
我们现在想分析一下

00:05:25.340 --> 00:05:26.900
别人现在开源是吧

00:05:26.900 --> 00:05:28.220
它提交了一个PR上来

00:05:28.220 --> 00:05:29.700
我现在想审查一下这个PR

00:05:29.700 --> 00:05:32.060
然后我再加进来

00:05:32.060 --> 00:05:33.380
我们就看一下

00:05:33.380 --> 00:05:34.460
让它去分析了

00:05:34.460 --> 00:05:37.600
那我们在这里就可以看到

00:05:37.600 --> 00:05:41.060
整个它会有一个

00:05:41.060 --> 00:05:43.080
这个subagents的一个概念

00:05:43.080 --> 00:05:44.360
看它这里有没有启动

00:05:44.360 --> 00:05:45.180
这个subagents

00:05:45.180 --> 00:05:55.120
你看他现在就开始在工作了

00:05:55.120 --> 00:05:55.280
是吧

00:05:55.280 --> 00:05:58.580
他会执行这个命令去查询这个PR

00:05:58.580 --> 00:05:59.020
是吧

00:05:59.020 --> 00:06:00.500
执行这个GH命令

00:06:00.500 --> 00:06:01.920
这个GH命令的话

00:06:01.920 --> 00:06:04.620
是Github提供的一个CLI工具啊

00:06:04.620 --> 00:06:06.420
这个首先大家要做一个登录啊

00:06:06.420 --> 00:06:09.460
如果说公关公关仓库的话

00:06:09.460 --> 00:06:11.520
默认应该是不需要授权的

00:06:11.520 --> 00:06:13.160
如果说弹出来要一个token的话

00:06:13.160 --> 00:06:14.980
这个最好大家去配一下啊

00:06:14.980 --> 00:06:16.540
因为你如果不配置token的话

00:06:16.540 --> 00:06:18.540
有些情况下可能会被限制

00:06:18.540 --> 00:06:21.920
所以执行一个JH login这个命令

00:06:21.920 --> 00:06:25.000
然后就把它去登录一下

00:06:25.000 --> 00:06:26.460
这个JH怎么安装

00:06:26.460 --> 00:06:28.020
大家可以去找一下这个教程

00:06:28.020 --> 00:06:28.540
很简单

00:06:28.540 --> 00:06:31.200
把这个JH CLI工具给它装一下

00:06:31.200 --> 00:06:35.080
然后我们就可以看一下

00:06:35.080 --> 00:06:38.520
看一下它的这个subagents

00:06:38.520 --> 00:06:39.540
看一下

00:06:39.540 --> 00:06:43.240
你看它这个斜钢命令里面有一个agents

00:06:43.240 --> 00:06:44.800
我们这里面可以看一下

00:06:44.800 --> 00:06:49.020
你看当前是有一个主线程

00:06:49.020 --> 00:06:49.460
是吧

00:06:49.460 --> 00:06:50.360
主线程

00:06:50.360 --> 00:06:53.240
然后这个里面我们可以去看一下啊

00:06:54.240 --> 00:06:56.740
看一下它的一个逻辑

00:06:56.740 --> 00:06:58.860
现在是只有一个主线程

00:06:58.860 --> 00:07:05.240
那现在这个里面还是在去拉代码啊

00:07:05.240 --> 00:07:12.160
这个里面我们可以切换啊

00:07:12.160 --> 00:07:16.760
就是当前如果他启动了一个子智能体的话

00:07:16.760 --> 00:07:21.080
我们可以看到一些这个细节啊

00:07:21.080 --> 00:07:23.100
比如说切换到当前活动的

00:07:23.100 --> 00:07:26.160
到目前为止他还只有一个啊

00:07:27.160 --> 00:07:31.440
目前为止还有一个

00:07:31.440 --> 00:07:35.940
那我们等一下看他有没有执行多个

00:07:35.940 --> 00:07:41.040
你看你是PR的审查子代理

00:07:41.040 --> 00:07:42.740
主要负责什么什么是吧

00:07:42.740 --> 00:07:46.000
然后他这里就是开始去分配这个subagents了

00:07:46.000 --> 00:07:46.480
是吧

00:07:46.480 --> 00:07:50.300
这里面我们先让他跑着

00:07:50.300 --> 00:07:52.900
我开另外一个窗口同步的来看啊

00:07:52.900 --> 00:07:54.680
因为这个消息太多了

00:07:54.680 --> 00:07:56.940
有时候看得有点晕啊

00:07:56.940 --> 00:07:58.540
就是有点混乱了

00:07:58.540 --> 00:08:00.000
我这里再切一个窗口啊

00:08:01.431 --> 00:08:16.651
然后codex

00:08:16.651 --> 00:08:21.511
sub-agents

00:08:21.511 --> 00:08:28.691
它在这个里面

00:08:28.691 --> 00:08:30.051
把它当前会晃

00:08:30.051 --> 00:08:31.131
subo agents

00:08:32.131 --> 00:08:33.131
agents

00:08:38.731 --> 00:08:42.091
你看现在这里大家是不是就可以看到多个agents了

00:08:42.091 --> 00:08:43.051
是吧

00:08:43.051 --> 00:08:45.971
有做这种各种什么提问的呀

00:08:45.971 --> 00:08:46.291
是吧

00:08:46.291 --> 00:08:47.931
然后各种细节处理的呀

00:08:47.931 --> 00:08:48.731
是吧

00:08:48.731 --> 00:08:53.011
它会相当于给你单独去加几个这个出来啊

00:08:53.011 --> 00:08:56.291
那你可以把这个拿来分析一下

00:08:56.291 --> 00:08:59.051
让我推出去

00:08:59.051 --> 00:09:11.211
帮我分析下agents中

00:09:11.211 --> 00:09:14.131
因为开了多个

00:09:14.131 --> 00:09:15.371
我这里都有点卡了

00:09:15.371 --> 00:09:24.631
有具体的分工

00:09:24.631 --> 00:09:28.591
其实上面日志已经打出来

00:09:28.591 --> 00:09:30.091
但是比较多啊

00:09:30.091 --> 00:09:32.431
所以这个我们有点看不出来啊

00:09:32.431 --> 00:09:34.931
我们现在让这个分析一下

00:09:34.931 --> 00:09:40.451
因为这个正在执行啊

00:09:40.451 --> 00:09:42.151
所以他这个消息阻塞了

00:09:42.151 --> 00:09:43.771
不过没关系啊

00:09:43.771 --> 00:09:44.791
我们的这个效果已经

00:09:44.791 --> 00:09:48.391
我们可以切换到具体的agents里面去啊

00:09:48.391 --> 00:09:51.011
我们可以比如说切换到这个里面去

00:09:51.011 --> 00:09:53.391
然后你可以看这个子agent里面

00:09:53.391 --> 00:09:55.271
他在做不同的逻辑是吧

00:09:55.271 --> 00:09:58.691
他有的是在做安全问题

00:09:58.691 --> 00:10:00.531
有些是在做代码质量的

00:10:00.531 --> 00:10:03.111
大家可以自由的去切换啊

00:10:03.111 --> 00:10:04.251
比如说在这个里面

00:10:04.251 --> 00:10:05.611
我可以看出来

00:10:05.611 --> 00:10:07.291
主线程

00:10:07.291 --> 00:10:10.831
你可以自由的去切啊

00:10:10.831 --> 00:10:12.791
那我这个得关一下

00:10:12.791 --> 00:10:13.951
不然这个有点卡

00:10:13.951 --> 00:10:18.191
把它关一下

00:10:18.191 --> 00:10:20.771
这有点卡住了

00:10:20.771 --> 00:10:25.051
所以这个你开的越多的话

00:10:25.051 --> 00:10:28.191
整个可能就是对性能消耗也比较大

00:10:28.191 --> 00:10:31.171
所以我们这里面还是要给他先关掉

00:10:31.171 --> 00:10:33.311
不然这个太卡了

00:10:33.311 --> 00:10:36.071
就在这个里面啊

00:10:36.071 --> 00:10:38.031
在这个里面我们也是可以看得到的

00:10:38.031 --> 00:10:41.091
但这个他没有加载出来啊

00:10:42.211 --> 00:10:44.211
没关系

00:10:44.211 --> 00:10:45.911
刚刚那个我已经中断了

00:10:45.911 --> 00:10:47.751
这个会有点卡

00:10:47.751 --> 00:10:55.631
所以我们其实可以通过不同的这个子agent

00:10:55.631 --> 00:10:59.011
然后的话就是去执行各种各样的任务

00:10:59.011 --> 00:10:59.711
然后最终的话

00:10:59.711 --> 00:11:02.351
我们其实只关注这个结果有没有

00:11:02.351 --> 00:11:02.771
是吧

00:11:02.771 --> 00:11:05.571
所以大家可以通过这种方式的话

00:11:05.571 --> 00:11:07.511
你就可以去做各种各样的一些

00:11:07.511 --> 00:11:09.831
这个分析类的一些工作

00:11:09.831 --> 00:11:11.051
因为这种的话

00:11:11.051 --> 00:11:12.851
它是没有前后依赖的

00:11:12.851 --> 00:11:14.771
大家想怎么用就怎么用

00:11:14.771 --> 00:11:15.751
是吧

00:11:15.751 --> 00:11:18.051
他你不用考虑前后的依赖关系的话

00:11:18.051 --> 00:11:18.551
最终

00:11:18.551 --> 00:11:20.071
并行的去跑

00:11:20.071 --> 00:11:21.531
跟串行的去跑

00:11:21.531 --> 00:11:22.911
其实是

00:11:22.911 --> 00:11:25.151
效率不一样的

00:11:25.151 --> 00:11:27.091
你并行的去跑的话

00:11:27.091 --> 00:11:28.751
这个里面啊

00:11:28.751 --> 00:11:30.711
他的一个效率就会更高

00:11:30.711 --> 00:11:32.631
因为他可以同时去干活

00:11:32.631 --> 00:11:33.951
最终给你一个结果

00:11:33.951 --> 00:11:35.931
相当于同样是十秒钟

00:11:35.931 --> 00:11:37.471
一个任务

00:11:37.471 --> 00:11:39.331
如果是串行的去跑的话

00:11:39.331 --> 00:11:40.851
六个任务就是一分钟

00:11:40.851 --> 00:11:41.631
他才能跑完

00:11:41.631 --> 00:11:43.451
如果说是并行的话

00:11:43.451 --> 00:11:44.631
就是十秒钟

00:11:44.631 --> 00:11:45.851
把所有任务都跑完了

00:11:45.851 --> 00:11:47.651
这个效率是完全不一样的

00:11:47.651 --> 00:11:50.711
然后大家也可以通过这个

00:11:50.711 --> 00:11:52.911
斜杠agents命令

00:11:52.911 --> 00:11:54.571
然后去看一下

00:11:54.571 --> 00:11:56.211
当前正在运行的现成

00:11:56.211 --> 00:11:58.371
就是你也这个不能开太多了

00:11:58.371 --> 00:11:59.191
开太多的话

00:11:59.191 --> 00:11:59.891
这个会会

00:11:59.891 --> 00:12:01.171
电脑会很卡

00:12:01.171 --> 00:12:03.511
所以这个大家需要酌情去考虑

00:12:03.511 --> 00:12:04.931
基本上开个

00:12:04.931 --> 00:12:06.751
两三个就差不多了

00:12:06.751 --> 00:12:07.731
开太多的话

00:12:07.731 --> 00:12:11.151
反而就是这个执行会

00:12:11.151 --> 00:12:12.611
电脑会有一些影响

00:12:12.611 --> 00:12:14.831
但具体得看大家的实际情况

00:12:14.831 --> 00:12:16.271
有的你电脑配置高的话

00:12:16.271 --> 00:12:16.911
这也不所谓

00:12:16.911 --> 00:12:20.151
然后这个子制中体的话

00:12:20.151 --> 00:12:22.251
它的权限是怎么样的呢

00:12:22.251 --> 00:12:25.451
它会继承我们当前绘画的一个杀相策略啊

00:12:25.451 --> 00:12:26.991
也就是说你的主线程

00:12:26.991 --> 00:12:30.231
当前比如说用的是bypass模式啊

00:12:30.231 --> 00:12:32.191
给了所有的权限的话

00:12:32.191 --> 00:12:35.291
那它就是所有权限全开的

00:12:35.291 --> 00:12:38.311
如果说你给的是一个需要授权啊

00:12:38.311 --> 00:12:39.251
就需要用户确认的话

00:12:39.251 --> 00:12:41.111
它会也会继承你这个对话权限

00:12:41.111 --> 00:12:43.751
所以关键是看大家就是你想

00:12:43.751 --> 00:12:46.351
给一个什么样的权限

00:12:46.351 --> 00:12:48.531
比如说你想不要他在用户确认了

00:12:48.531 --> 00:12:50.351
你就把权限全放开就可以了

00:12:50.351 --> 00:12:53.031
这个就看大家的一个事情情况

00:12:53.031 --> 00:12:56.351
然后这个里面啊

00:12:56.351 --> 00:12:58.111
他主要就是子真正体的话

00:12:58.111 --> 00:12:59.551
他其实很多选项的话

00:12:59.551 --> 00:13:01.851
都是通过这个继承了

00:13:01.851 --> 00:13:06.271
这个主线程的这么一个真正体去处理的

00:13:06.271 --> 00:13:08.611
所以大家去设置这个权限的时候

00:13:08.611 --> 00:13:09.991
你也可以去关注一下

00:13:09.991 --> 00:13:12.551
就是你的主线程

00:13:12.551 --> 00:13:14.171
怎么来设定这个权限

00:13:14.171 --> 00:13:18.151
然后的话就是Codex里面

00:13:18.151 --> 00:13:21.111
它自带了三种类件的这个智能体

00:13:21.111 --> 00:13:22.771
就是我们可以去配置

00:13:22.771 --> 00:13:26.691
默认的话就是一个通用回退型的

00:13:26.691 --> 00:13:27.451
这么一个智能体

00:13:27.451 --> 00:13:29.651
然后Worker它是偏执行的

00:13:29.651 --> 00:13:32.711
适合去做一些实现和修复类的工作

00:13:32.711 --> 00:13:34.791
Explorer的话就是止读

00:13:34.791 --> 00:13:38.411
我们刚刚看到打印的这个日志的话

00:13:38.411 --> 00:13:39.751
有些就是Explorer的

00:13:39.751 --> 00:13:41.731
因为我们上面提到一个需求

00:13:41.731 --> 00:13:43.011
它都是查询嘛

00:13:43.011 --> 00:13:43.271
是吧

00:13:43.271 --> 00:13:44.391
只是做分析的

00:13:44.391 --> 00:13:46.131
它不需要执行一些

00:13:46.131 --> 00:13:47.511
这么修改类的一些任务

00:13:47.511 --> 00:13:49.611
所以这个就是Explorer

00:13:49.611 --> 00:13:51.571
这是Codex

00:13:51.571 --> 00:13:54.351
它会根据你当前的一些任务的一些情况

00:13:54.351 --> 00:13:55.731
分析出来

00:13:55.731 --> 00:13:58.951
它的一个结果应该是怎么样的

00:13:58.951 --> 00:13:59.251
是吧

00:13:59.251 --> 00:14:00.191
这个东西

00:14:00.191 --> 00:14:04.231
它是会根据实际情况去调整的

00:14:04.231 --> 00:14:05.651
如果说你拿去改代码的话

00:14:05.651 --> 00:14:08.071
它可能会选择这个Worker

00:14:08.071 --> 00:14:11.791
所以这个就是它具体的一个执行逻辑

00:14:11.791 --> 00:14:13.531
这个我们回头来验一下

00:14:13.531 --> 00:14:17.571
然后的话就是我们自定义这个整体的话

00:14:17.571 --> 00:14:23.271
它在这个.codex目入下面有一个.agents

00:14:23.271 --> 00:14:24.471
文件夹

00:14:24.471 --> 00:14:25.951
这个我们可以看一下

00:14:25.951 --> 00:14:29.631
就是你可以在当前这个项目下面

00:14:29.631 --> 00:14:33.391
你去建一个这个agents

00:14:33.391 --> 00:14:36.971
它的一个文件夹

00:14:36.971 --> 00:14:39.031
然后的话你可以去配这个agents

00:14:39.031 --> 00:14:41.731
然后的话就是你也可以什么呢

00:14:41.731 --> 00:14:43.191
在项目级别啊

00:14:43.191 --> 00:14:44.331
一个是在全局的

00:14:44.331 --> 00:14:45.451
一个是在项目的

00:14:45.451 --> 00:14:47.831
那我们等一下来先配一个项目级

00:14:47.831 --> 00:14:48.931
比如说

00:14:48.931 --> 00:14:53.691
我一个是这个分析

00:14:53.691 --> 00:14:55.331
我们就参考前面那几个嘛

00:14:55.331 --> 00:14:55.631
是吧

00:14:55.631 --> 00:14:58.611
我就让他分析代码问题跟质量

00:14:58.611 --> 00:15:00.471
我配两个这个agents

00:15:00.471 --> 00:15:01.631
让他去跑一下

00:15:01.631 --> 00:15:03.851
看一下能不能跑出效果出来

00:15:03.851 --> 00:15:04.231
是吧

00:15:04.231 --> 00:15:06.351
那其实就很简单

00:15:06.351 --> 00:15:09.371
那比如说我们现在就把这两个给复制一下

00:15:09.371 --> 00:15:11.411
怎么来弄呢

00:15:11.411 --> 00:15:13.651
首先我们打开这个里面

00:15:13.651 --> 00:15:18.031
然后我就直接在这个里面操作了

00:15:18.031 --> 00:15:22.091
你就直接在当前这个项目下面

00:15:22.091 --> 00:15:24.071
比如说这个project2下面

00:15:24.071 --> 00:15:26.111
然后找一个有代码的

00:15:26.111 --> 00:15:27.671
比如说这个里面

00:15:27.671 --> 00:15:28.871
myproject

00:15:28.871 --> 00:15:32.311
我现在找一个项目

00:15:32.311 --> 00:15:39.111
这个下面有我之前写的一些小游戏的项目

00:15:39.111 --> 00:15:41.391
那我就在这个下面吧

00:15:41.391 --> 00:15:44.651
比如说我们现在打开这个目录是吧

00:15:44.651 --> 00:15:46.191
然后在这个目录里面

00:15:46.191 --> 00:15:48.431
我们切换到这个Codex

00:15:48.431 --> 00:15:51.771
来我们这个是

00:15:51.771 --> 00:15:56.271
我要用终端展开啊

00:16:00.535 --> 00:16:02.135
之前是不是开了一个

00:16:02.135 --> 00:16:03.235
好在这个里面

00:16:03.235 --> 00:16:05.355
我切换到这个map project里面去

00:16:09.735 --> 00:16:10.735
map project

00:16:10.735 --> 00:16:11.595
那这个下面

00:16:11.595 --> 00:16:13.335
由我之前写的一些这个

00:16:13.335 --> 00:16:15.935
生成的一些小游戏的示例吗

00:16:15.935 --> 00:16:21.055
那现在我现在相当于我要做一个子智能体啊

00:16:21.055 --> 00:16:22.195
我要开两个智能体

00:16:22.195 --> 00:16:26.035
一个是去教验这个安全问题

00:16:26.035 --> 00:16:27.995
还有一个是教验这个代码质量问题

00:16:27.995 --> 00:16:29.075
我要写两个嘛

00:16:29.075 --> 00:16:30.495
所以应该怎么来弄呢

00:16:30.495 --> 00:16:32.135
我们进入codex

00:16:32.135 --> 00:16:40.155
比如说帮我配置两个子智能体

00:16:41.595 --> 00:16:44.355
或者你叫subagency也可以啊

00:16:44.355 --> 00:16:46.095
能体或者叫子代理

00:16:46.095 --> 00:16:47.235
他应该也能识别出来

00:16:47.235 --> 00:16:50.055
然后这个是

00:16:50.055 --> 00:16:54.415
这是我两个的一个需求是吧

00:16:54.415 --> 00:16:56.655
你就这么来写就可以了

00:16:56.655 --> 00:16:58.555
然后他默认就会在这个下面去

00:16:58.555 --> 00:17:01.375
新建这个agency.文件夹

00:17:01.375 --> 00:17:04.575
然后帮你把这个子智能体给他配进去

00:17:04.575 --> 00:17:05.515
你看啊

00:17:05.515 --> 00:17:07.995
他首先会看你这个里面有没有一个叫

00:17:07.995 --> 00:17:10.155
subagency的这么一个配置是吧

00:17:10.155 --> 00:17:10.895
没有的话

00:17:10.895 --> 00:17:12.015
他就会帮你去创建

00:17:12.015 --> 00:17:13.955
这是差的一个规范

00:17:13.955 --> 00:17:15.375
所以大家

00:17:15.375 --> 00:17:16.875
你其实直接让Codex

00:17:16.875 --> 00:17:19.335
帮你去配置就完了

00:17:19.335 --> 00:17:22.655
你不需要去看这个文档

00:17:22.655 --> 00:17:23.015
是吧

00:17:23.015 --> 00:17:25.135
但如果说你要调一些细节参数的话

00:17:25.135 --> 00:17:26.275
你还是要知道

00:17:26.275 --> 00:17:27.315
这里面那些规范的

00:17:27.315 --> 00:17:27.815
比如说

00:17:27.815 --> 00:17:29.715
这个子制整体的名称是什么

00:17:29.715 --> 00:17:30.515
描述是什么

00:17:30.515 --> 00:17:31.755
然后包括一些

00:17:31.755 --> 00:17:34.455
一些参数是吧

00:17:34.455 --> 00:17:36.535
它的一个含义是什么

00:17:36.535 --> 00:17:37.315
大家需要知道

00:17:37.315 --> 00:17:40.375
就你只是简单的配一个

00:17:40.375 --> 00:17:41.855
子制容体的话

00:17:41.855 --> 00:17:44.055
你就直接让它去执行就完了

00:17:44.055 --> 00:17:47.675
所以整个过程会比较简单

00:17:47.675 --> 00:17:49.475
诶

00:17:49.475 --> 00:17:51.015
那个是到哪里了

00:17:51.015 --> 00:17:52.675
这里有一个

00:17:52.675 --> 00:17:54.555
确认啊

00:17:54.555 --> 00:17:57.315
他说允许

00:17:57.315 --> 00:17:58.035
fine manage

00:17:58.035 --> 00:18:00.755
这是一个

00:18:00.755 --> 00:18:02.395
这是一个mcp服务

00:18:02.395 --> 00:18:05.215
这是允许

00:18:07.315 --> 00:18:10.075
你看接下来他会用补丁的方式

00:18:10.075 --> 00:18:12.195
添加两个agency.md文件

00:18:12.195 --> 00:18:15.575
并且在agency.md里面去补充一段子

00:18:15.575 --> 00:18:16.455
智能体的配置

00:18:16.455 --> 00:18:21.955
所以这些个参数大家需要知道啊

00:18:21.955 --> 00:18:25.635
比如说允许打开的智能体的一个现成的上限啊

00:18:25.635 --> 00:18:29.495
然后就是这个参数啊

00:18:29.495 --> 00:18:31.095
这个什么嵌套的深度啊

00:18:31.095 --> 00:18:31.655
是吧

00:18:31.655 --> 00:18:33.595
但这个大家需要的时候再去看啊

00:18:33.595 --> 00:18:34.675
你可能会不太理解

00:18:34.675 --> 00:18:37.075
什么叫深层的嵌套深度啊

00:18:37.075 --> 00:18:37.715
就是一个对话

00:18:37.715 --> 00:18:39.835
那当你遇到这个问题的时候

00:18:39.835 --> 00:18:40.535
你再去查

00:18:40.535 --> 00:18:43.815
就其实你也不用太关心这几个参数

00:18:43.815 --> 00:18:47.235
只是说你要知道有这么些内容就可以

00:18:47.235 --> 00:18:49.315
包括它的一个文件结构描述

00:18:49.315 --> 00:18:49.715
是吧

00:18:49.715 --> 00:18:52.575
你看现在已经好了

00:18:52.575 --> 00:18:53.515
你看配置了

00:18:53.515 --> 00:18:56.955
这样Codex目录下面有一个这个agency

00:18:56.955 --> 00:18:59.835
然后下面有两个子制容体

00:18:59.835 --> 00:19:00.235
是吧

00:19:00.235 --> 00:19:02.655
一个是做安全问题审查的

00:19:02.655 --> 00:19:04.975
还有一个是做代码质量审查的

00:19:04.975 --> 00:19:06.455
我们看一下

00:19:06.455 --> 00:19:10.115
在myproject下面

00:19:10.115 --> 00:19:12.055
有个点codex目录

00:19:12.055 --> 00:19:14.035
codex目录下面有个agents目录

00:19:14.035 --> 00:19:15.615
agents目录下面有个

00:19:15.615 --> 00:19:18.255
你看这个是做代码审查的子生体

00:19:18.255 --> 00:19:20.315
它的名称是什么

00:19:20.315 --> 00:19:21.775
你看对应到我们这个文档是吧

00:19:21.775 --> 00:19:22.655
名称描述

00:19:22.655 --> 00:19:24.875
实际我们用的最多的

00:19:24.875 --> 00:19:25.615
就是这两个参数

00:19:25.615 --> 00:19:26.575
其他的话

00:19:26.575 --> 00:19:27.875
没有特殊需求

00:19:27.875 --> 00:19:28.715
一般不用挑

00:19:28.715 --> 00:19:30.315
有需要的时候

00:19:30.315 --> 00:19:32.295
你让codex帮你生成就完了

00:19:32.295 --> 00:19:33.835
就你给它提需求就行了

00:19:33.835 --> 00:19:35.935
你不用单独去记这些个参数

00:19:35.935 --> 00:19:38.995
但是你需要知道有这么个概念在里面

00:19:38.995 --> 00:19:41.995
就是他支持这些个参数就可以了

00:19:41.995 --> 00:19:43.675
这个是做代码审查的

00:19:43.675 --> 00:19:45.555
你看审查子质整体

00:19:45.555 --> 00:19:46.575
论物是什么什么

00:19:46.575 --> 00:19:47.455
关注范围是什么

00:19:47.455 --> 00:19:48.435
审查原则是什么

00:19:48.435 --> 00:19:49.475
输出格式是什么

00:19:49.475 --> 00:19:51.815
另外一个是安全问题审查

00:19:51.815 --> 00:19:55.495
然后因为我们这个项目里面

00:19:55.495 --> 00:19:57.475
又有python又有html的项目

00:19:57.475 --> 00:19:59.055
所以他这里面输出了两种

00:19:59.055 --> 00:20:01.055
html单文件

00:20:01.055 --> 00:20:02.415
他的细节是什么

00:20:02.415 --> 00:20:05.715
python他的这个细节有什么

00:20:05.715 --> 00:20:06.775
审查原则是什么

00:20:06.775 --> 00:20:07.675
输出格是什么

00:20:07.675 --> 00:20:09.375
好

00:20:09.375 --> 00:20:10.415
然后完了之后

00:20:10.415 --> 00:20:11.875
我们可以通过这个

00:20:11.875 --> 00:20:12.955
看一下

00:20:12.955 --> 00:20:14.075
subagents

00:20:14.075 --> 00:20:16.515
这个是查看的

00:20:16.515 --> 00:20:17.515
agents

00:20:17.515 --> 00:20:24.055
这个是我们现在还没跑

00:20:24.055 --> 00:20:24.795
还没跑

00:20:24.795 --> 00:20:27.315
接下来你就可以让它去运行一下

00:20:27.315 --> 00:20:29.415
比如说

00:20:29.415 --> 00:20:32.835
针对当前

00:20:32.835 --> 00:20:35.535
项目

00:20:35.535 --> 00:20:40.135
代码使用智智能体

00:20:40.135 --> 00:20:49.355
同时进行

00:20:49.355 --> 00:20:52.655
两个场景啊

00:20:52.655 --> 00:20:54.995
同时进行代码质量审查

00:20:54.995 --> 00:20:57.035
还有安全问题审查

00:20:57.035 --> 00:21:04.935
你会看一下我们写的这个subagents

00:21:04.935 --> 00:21:06.275
到底能不能生效是吧

00:21:06.275 --> 00:21:09.195
然后我们现在你看agents

00:21:09.195 --> 00:21:10.815
现在这个是没有的是吧

00:21:10.815 --> 00:21:11.635
现在就一个吧

00:21:11.635 --> 00:21:14.135
然后我们现在等到跑的时候

00:21:14.135 --> 00:21:15.155
我们再来看一下

00:21:15.155 --> 00:21:16.855
它会不会起多个啊

00:21:16.855 --> 00:21:18.595
现在就只有一个

00:21:18.595 --> 00:21:20.995
因为它没有启动那个子智能体呢

00:21:20.995 --> 00:21:23.995
这里大家是看不出来的啊

00:21:23.995 --> 00:21:26.935
然后你看啊

00:21:26.935 --> 00:21:28.795
你是本项目的安全审查

00:21:28.795 --> 00:21:31.295
子制成体然后工作目录是啥啥啥

00:21:31.295 --> 00:21:33.155
现在已经起了一个了

00:21:33.155 --> 00:21:34.575
再退出去看一下

00:21:34.575 --> 00:21:35.995
agents

00:21:35.995 --> 00:21:38.895
然后大家看这个是不是

00:21:38.895 --> 00:21:39.395
一个

00:21:39.395 --> 00:21:42.395
主线程是什么是吧

00:21:42.395 --> 00:21:43.735
然后目标是吧

00:21:43.735 --> 00:21:46.735
然后相当于它都是做一个tolo

00:21:46.735 --> 00:21:49.075
就是探索这个主要是做一些分析

00:21:49.075 --> 00:21:51.255
类的然后两个两个角色

00:21:51.255 --> 00:21:53.775
这个应该是它生成的一个角色名

00:21:53.775 --> 00:21:54.995
每次都不一样

00:21:54.995 --> 00:21:57.015
然后这个是相当于

00:21:57.015 --> 00:21:59.335
他给你生成两个虚拟的数字员工

00:21:59.335 --> 00:22:01.975
所以这个里面

00:22:01.975 --> 00:22:03.555
他干活的就这两个

00:22:03.555 --> 00:22:04.175
是吧

00:22:04.175 --> 00:22:06.635
干活的就这两个

00:22:06.635 --> 00:22:07.895
他都是Expolo

00:22:07.895 --> 00:22:10.895
如果大家你想让他去改单法的话

00:22:10.895 --> 00:22:12.875
他应该会生成这个

00:22:12.875 --> 00:22:15.975
Worker的这么一个执行的一个Subagents

00:22:15.975 --> 00:22:18.695
我们其实可以再给他加一下

00:22:18.695 --> 00:22:21.175
就bug修正是吧

00:22:21.175 --> 00:22:23.235
我先给他退出去

00:22:23.235 --> 00:22:26.995
我现在才想再加一下

00:22:26.995 --> 00:22:30.595
恢复到之前那个对话吧

00:22:30.595 --> 00:22:40.295
Codex resume

00:22:40.295 --> 00:22:45.995
然后恢复到之前那个对话

00:22:53.235 --> 00:22:55.975
agents

00:22:55.975 --> 00:22:58.375
现在那个已经中断了

00:22:58.375 --> 00:22:59.795
然后

00:22:59.795 --> 00:23:02.615
再帮我

00:23:02.615 --> 00:23:04.195
开发一个

00:23:04.195 --> 00:23:07.235
代码

00:23:07.235 --> 00:23:12.535
代码修正

00:23:12.535 --> 00:23:16.335
的

00:23:16.335 --> 00:23:19.095
智能体

00:23:19.095 --> 00:23:24.415
配置一个

00:23:24.415 --> 00:23:30.415
我们主要是要看到这个代码开发的话

00:23:30.415 --> 00:23:32.315
就是Walker啊

00:23:32.315 --> 00:23:33.895
比较看一下这个区别就可以了

00:23:33.895 --> 00:23:36.855
这个是做执行任务的啊

00:23:36.855 --> 00:23:40.455
主要是要区分一下两种agents

00:23:40.455 --> 00:23:43.495
就以后大家你加了各种各样的这个子agent

00:23:43.495 --> 00:23:43.975
是吧

00:23:43.975 --> 00:23:45.955
那你需要知道

00:23:45.955 --> 00:23:48.575
这个它的类型是用来干嘛的

00:23:48.575 --> 00:23:50.935
应该这个是fix

00:23:50.935 --> 00:23:53.795
你就随便跑一个

00:23:53.795 --> 00:23:55.835
比如说我现在

00:23:58.802 --> 00:24:01.942
想让他去做代码修复

00:24:05.902 --> 00:24:07.062
使用

00:24:07.062 --> 00:24:12.302
自

00:24:12.302 --> 00:24:22.702
针对当前项目代码进行修复

00:24:22.702 --> 00:24:26.122
你就直接这么跟他说啊

00:24:26.122 --> 00:24:28.802
他会去起这个整体去修复代码

00:24:28.802 --> 00:24:34.602
但虽然我这个需求没有写明确啊

00:24:34.602 --> 00:24:35.562
他还是会扫一遍

00:24:35.562 --> 00:24:36.622
先把问题扫出来

00:24:36.622 --> 00:24:38.162
然后再去做这个事情

00:24:38.162 --> 00:24:42.582
然后我们看一下这个

00:24:42.582 --> 00:24:44.082
到底用的Worker是什么

00:24:44.082 --> 00:24:45.122
就是

00:24:45.122 --> 00:24:48.942
现在还是Exploro的

00:24:48.942 --> 00:24:53.162
等一下到具体修代码的时候

00:24:53.162 --> 00:24:53.782
才会那个

00:24:53.782 --> 00:24:54.922
所以这里得等

00:24:54.922 --> 00:24:57.822
等他先把问题给他分析出来

00:24:57.822 --> 00:24:59.822
然后再去跑

00:24:59.822 --> 00:25:03.222
所以他没到改代码之前的话

00:25:03.222 --> 00:25:05.462
他不会变成那个

00:25:05.462 --> 00:25:07.502
这个Worker的

00:25:07.502 --> 00:25:12.202
你看现在是不是变了

00:25:12.202 --> 00:25:14.562
现在是不是单独起了一个Worker在干活了

00:25:14.562 --> 00:25:16.022
这个就是改代码的

00:25:16.022 --> 00:25:17.842
做Fix的修正代码

00:25:17.842 --> 00:25:20.502
前面那几个都还是分析的

00:25:20.502 --> 00:25:22.442
这个大家需要注意一下

00:25:22.442 --> 00:25:23.942
并且前两个都是关闭的

00:25:23.942 --> 00:25:27.142
你看这个绿色的就表示在运行的

00:25:27.142 --> 00:25:30.542
这个灰掉的白色的就是没有运行的

00:25:30.542 --> 00:25:32.442
这个需要注意一下

00:25:32.442 --> 00:25:35.022
所以这几个类型

00:25:35.022 --> 00:25:35.882
大家要搞清楚

00:25:35.882 --> 00:25:37.902
一个是偏执行的

00:25:37.902 --> 00:25:39.002
修复代码的

00:25:39.002 --> 00:25:40.702
还有一个是只读的

00:25:40.702 --> 00:25:43.462
如果说你都没有加的话

00:25:43.462 --> 00:25:45.162
它可能会变成一个default

00:25:45.162 --> 00:25:47.762
那个man的

00:25:47.762 --> 00:25:48.302
我看一下

00:25:48.302 --> 00:25:50.562
默认的agents的

00:25:50.562 --> 00:25:52.702
这个你看man就是default

00:25:52.702 --> 00:25:54.542
主线程

00:25:54.542 --> 00:25:55.842
他啥都干

00:25:55.842 --> 00:25:57.622
就是用来回退的

00:25:57.622 --> 00:25:59.662
主线程的默认就是default

00:25:59.662 --> 00:26:02.402
一般我们开子制容体要么

00:26:02.402 --> 00:26:03.542
就是去帮你干活

00:26:03.542 --> 00:26:06.222
做一些实现跟修复嘛

00:26:06.222 --> 00:26:07.502
要么就是做分析

00:26:07.502 --> 00:26:08.502
只读的啊

00:26:08.502 --> 00:26:10.362
就是这个是可读可写

00:26:10.362 --> 00:26:12.562
这个是只读的啊

00:26:12.562 --> 00:26:13.542
或者说这个就是

00:26:13.542 --> 00:26:15.762
就是用来专门就是用来盖活子啊

00:26:15.762 --> 00:26:17.502
好

00:26:17.502 --> 00:26:18.482
这个是项目级的

00:26:18.482 --> 00:26:20.802
那么大家其实你也可以在这个

00:26:20.802 --> 00:26:24.182
我们整个的一个全局的啊

00:26:24.182 --> 00:26:27.562
Codex的全局的这个配置里面

00:26:27.562 --> 00:26:29.542
去加这个子智能体啊

00:26:33.542 --> 00:26:37.102
配置里面

00:26:37.102 --> 00:26:39.422
打开这个配置

00:26:39.422 --> 00:26:41.502
然后打开这个路径

00:26:41.502 --> 00:26:43.842
这个路径下面

00:26:43.842 --> 00:26:47.542
打开这个路径

00:26:47.542 --> 00:26:51.102
这个路径下面有一个agents

00:26:51.102 --> 00:26:53.582
咱现在没有那个文件奖啊

00:26:53.582 --> 00:26:56.322
大家可以在全局的这个当前用户目的下面

00:26:56.322 --> 00:26:59.442
去创建一个这个agents

00:26:59.442 --> 00:27:01.142
agents文件奖

00:27:01.142 --> 00:27:04.142
就跟咱们这个项目这里是一样的

00:27:04.142 --> 00:27:05.262
项目这里

00:27:05.262 --> 00:27:08.322
创建了这么一个agents

00:27:08.322 --> 00:27:09.502
是吧

00:27:09.502 --> 00:27:11.642
在这个里面

00:27:11.642 --> 00:27:13.942
就是他有一个agents

00:27:13.942 --> 00:27:15.302
然后在这个下面

00:27:15.302 --> 00:27:18.162
我们建三个子agents

00:27:18.162 --> 00:27:19.122
对吧

00:27:19.122 --> 00:27:21.102
就帮你可以去同时干活

00:27:21.102 --> 00:27:22.222
就这么意思

00:27:22.222 --> 00:27:26.282
然后这些个文件结构

00:27:26.282 --> 00:27:27.342
大家知道就行了

00:27:27.342 --> 00:27:28.542
主要就是这两个

00:27:28.542 --> 00:27:30.782
其他的话暂时都是用不上

00:27:30.782 --> 00:27:32.542
有需要的话你让AI

00:27:32.542 --> 00:27:34.842
帮你去加

00:27:34.842 --> 00:27:36.442
就你有特殊需求提出来

00:27:36.442 --> 00:27:38.702
他会自动的去帮你加这些参数

00:27:38.702 --> 00:27:41.262
只要他能匹配到这些个需求

00:27:41.262 --> 00:27:44.682
然后包括一些描述啊

00:27:44.682 --> 00:27:44.982
是吧

00:27:44.982 --> 00:27:46.262
然后大家你也可以

00:27:46.262 --> 00:27:48.042
他就是用markdown的方式去写的

00:27:48.042 --> 00:27:50.942
你看我们就正常跟写提示词一样

00:27:50.942 --> 00:27:52.702
其实这个所谓的子整体的话

00:27:52.702 --> 00:27:54.702
都是以提示词去驱动的

00:27:54.702 --> 00:27:56.522
整个的一个整体干活

00:27:56.522 --> 00:27:57.942
他就是参考了这个提示词

00:27:57.942 --> 00:27:59.482
就是他的一个工作流程啊

00:27:59.482 --> 00:28:01.302
所以这个里面的话

00:28:01.302 --> 00:28:03.602
其实也很好理解啊

00:28:03.602 --> 00:28:05.462
就是用TS调整大模型

00:28:05.462 --> 00:28:06.522
然后做一个理解

00:28:06.522 --> 00:28:08.922
然后在agents去做一个执行的

00:28:08.922 --> 00:28:13.722
所以说这个里面啊

00:28:13.722 --> 00:28:15.082
这就是它的一个规范

00:28:15.082 --> 00:28:19.702
那么大家你也可以通过去改一些这个

00:28:19.702 --> 00:28:25.482
用户级别的一些agents的一些规范

00:28:25.482 --> 00:28:29.462
比如说我们可以做一个拆分是吧

00:28:29.462 --> 00:28:32.202
有TiExplorer的

00:28:32.202 --> 00:28:33.402
有Review的

00:28:33.402 --> 00:28:37.082
然后就是可以做各种各样的一些处理的

00:28:37.082 --> 00:28:38.462
就大家你可以自定义

00:28:38.462 --> 00:28:40.802
就你想要什么一个真体的话

00:28:40.802 --> 00:28:42.122
你自己去定义就可以了

00:28:42.122 --> 00:28:43.162
再把规范写好

00:28:43.162 --> 00:28:45.562
他就可以去干这个事情

00:28:45.562 --> 00:28:47.162
兴起的话我们还可以在

00:28:47.162 --> 00:28:50.162
这个用户

00:28:50.162 --> 00:28:52.162
就是项目级别或者用户级别

00:28:52.162 --> 00:28:53.402
去加一些什么呢

00:28:53.402 --> 00:28:55.182
比如说他的最大线程

00:28:55.182 --> 00:28:57.222
有可能他卡太卡

00:28:57.222 --> 00:28:58.962
你比如说开十个线程

00:28:58.962 --> 00:28:59.762
电脑太卡了

00:28:59.762 --> 00:29:01.542
那你就改造三个

00:29:01.542 --> 00:29:02.662
或者一个线程

00:29:02.662 --> 00:29:06.122
就这个就是这个线程

00:29:06.122 --> 00:29:07.202
线程越多的话

00:29:07.202 --> 00:29:08.722
指线效率越高

00:29:08.722 --> 00:29:11.022
但是的话性能也会下降

00:29:11.022 --> 00:29:13.302
因为你的CPU运行资源

00:29:13.302 --> 00:29:14.182
可能不够的时候

00:29:14.182 --> 00:29:15.762
反正电脑会很卡

00:29:15.762 --> 00:29:18.222
所以这个大家需要去考虑

00:29:18.222 --> 00:29:19.322
应该设置多少

00:29:19.322 --> 00:29:22.322
然后包括一些什么深度啊

00:29:22.322 --> 00:29:22.662
是吧

00:29:22.662 --> 00:29:24.542
各种各样的一些参数啊

00:29:24.542 --> 00:29:25.362
比如说

00:29:25.362 --> 00:29:27.242
你还可以针对不同的

00:29:27.242 --> 00:29:28.762
这个子制整体

00:29:28.762 --> 00:29:29.722
去配置模型啊

00:29:29.722 --> 00:29:31.742
比如说有一些是写代码的

00:29:31.742 --> 00:29:34.682
那你建议用5.3的这个Codex版本

00:29:34.682 --> 00:29:37.362
有些是做那个分析的是吧

00:29:37.362 --> 00:29:40.202
一些个项目嘛是吧

00:29:40.202 --> 00:29:41.242
阅读代码的

00:29:41.242 --> 00:29:44.762
那我建议你可以用这个5.5是吧

00:29:44.762 --> 00:29:47.282
它比较适合你做一些推理分析的一些工作

00:29:47.282 --> 00:29:50.602
写代码的话就用Codex版本会比较好一些啊

00:29:50.602 --> 00:29:54.622
所以说这个子制中体里面

00:29:54.622 --> 00:29:57.422
你其实可以加各种各样的一些配置啊

00:29:57.422 --> 00:29:58.402
他的一些这个

00:29:58.402 --> 00:30:01.462
描述啊

00:30:01.462 --> 00:30:01.682
是吧

00:30:01.682 --> 00:30:02.602
模型啊

00:30:02.602 --> 00:30:04.462
然后包括他的一个

00:30:04.462 --> 00:30:05.182
沙相模式

00:30:05.182 --> 00:30:05.802
大家就可以改

00:30:05.802 --> 00:30:07.382
我们刚刚给他说的是

00:30:07.382 --> 00:30:08.002
沙相模式

00:30:08.002 --> 00:30:09.242
你如果不写的话

00:30:09.242 --> 00:30:11.842
他会默认用我们

00:30:11.842 --> 00:30:12.862
子线程

00:30:12.862 --> 00:30:13.802
就主线程

00:30:13.802 --> 00:30:16.102
带过来的这个权限

00:30:16.102 --> 00:30:17.282
如果大家配的话

00:30:17.282 --> 00:30:19.202
就以你配的这个为准

00:30:19.202 --> 00:30:20.762
包括模型的这个

00:30:20.762 --> 00:30:22.282
推理的这个等级

00:30:22.282 --> 00:30:22.602
是吧

00:30:22.602 --> 00:30:24.302
大家也可以做一个search

00:30:24.302 --> 00:30:26.122
就是子这种体

00:30:26.122 --> 00:30:28.042
它是可以单独进行配置的

00:30:28.042 --> 00:30:29.782
但是你如果没有配置的话

00:30:29.782 --> 00:30:34.322
它会默认的用主线程的那个配置计程过来

00:30:34.322 --> 00:30:35.382
这个是需要注意的

00:30:35.382 --> 00:30:37.442
所以大家可以根据实际情况

00:30:37.442 --> 00:30:38.322
你做一个调整

00:30:38.322 --> 00:30:40.682
把这些个子制容体的一些参数调一调

00:30:40.682 --> 00:30:43.282
然后让它就是没有什么问题

00:30:43.282 --> 00:30:47.262
然后的话就是这套配置的话

00:30:47.262 --> 00:30:49.022
我们还可以去加一些这个

00:30:49.022 --> 00:30:51.422
不同的这个提示词是吧

00:30:51.422 --> 00:30:53.682
就是你比如说你也不知道应该配什么的时候

00:30:53.682 --> 00:30:54.342
你就提要求

00:30:54.342 --> 00:30:57.302
比如说你说要子智能体具备一些

00:30:57.302 --> 00:30:58.742
超级管理员

00:30:58.742 --> 00:31:00.982
这个所有的权限都要给他

00:31:00.982 --> 00:31:03.062
并且这个模型要清晃到5.3

00:31:03.062 --> 00:31:04.922
然后退理等级用高

00:31:04.922 --> 00:31:07.822
你就把这些个参数告诉他

00:31:07.822 --> 00:31:09.542
让他自己去生成就可以了

00:31:09.542 --> 00:31:10.862
你自己不需要改这东西

00:31:10.862 --> 00:31:12.022
你让他去生成就完了

00:31:12.022 --> 00:31:13.662
但是你要把需求描述清楚

00:31:13.662 --> 00:31:17.142
然后我们还可以用子智能体

00:31:17.142 --> 00:31:18.442
去处理一些这个

00:31:18.442 --> 00:31:20.722
CSV的一些批样任务

00:31:20.722 --> 00:31:22.162
那么这个

00:31:22.162 --> 00:31:23.762
目前啊

00:31:23.762 --> 00:31:25.722
还是一个实验性的一个能力

00:31:25.722 --> 00:31:26.762
但后面啊

00:31:26.762 --> 00:31:28.302
最新更新的版本

00:31:28.302 --> 00:31:29.562
可能会把它变成一个

00:31:29.562 --> 00:31:30.962
这个正式版本

00:31:30.962 --> 00:31:34.642
那比如说我们现在要做数据分析工作

00:31:34.642 --> 00:31:34.962
是吧

00:31:34.962 --> 00:31:37.482
那现在你可以加一些这个子智能体

00:31:37.482 --> 00:31:39.702
专门去用来去完成一些

00:31:39.702 --> 00:31:41.382
CSV的一些数据啊

00:31:41.382 --> 00:31:43.882
读取一些那个结果

00:31:43.882 --> 00:31:44.242
是吧

00:31:44.242 --> 00:31:47.002
然后我们可以去生成Worker

00:31:47.002 --> 00:31:48.622
比如说

00:31:48.622 --> 00:31:51.302
这个就比较适合一座审计类的一些工作

00:31:51.302 --> 00:31:55.462
人家有一些他要去按行去审查文件啊

00:31:55.462 --> 00:31:56.322
一些表格嘛

00:31:56.322 --> 00:31:56.962
对吧

00:31:56.962 --> 00:31:58.682
一些数据啊

00:31:58.682 --> 00:32:00.042
一些PDF解析啊

00:32:00.317 --> 00:32:03.117
或者是一些一组数据啊

00:32:03.117 --> 00:32:03.337
是吧

00:32:03.337 --> 00:32:04.997
或者PR啊等等的啊

00:32:04.997 --> 00:32:05.837
或者等等的

00:32:05.837 --> 00:32:07.997
一些个啊

00:32:07.997 --> 00:32:10.137
需要分批去处理的

00:32:10.137 --> 00:32:12.897
这个就比较适合于用这个子制整体啊

00:32:12.897 --> 00:32:15.557
因为它可以一直工作嘛

00:32:15.557 --> 00:32:17.417
可以开多个任务

00:32:17.417 --> 00:32:18.377
然后的话就是

00:32:18.377 --> 00:32:21.217
我们可以去指定CSV的一个路径

00:32:21.217 --> 00:32:22.017
对吧

00:32:22.017 --> 00:32:24.377
包括它的一个Worker啊

00:32:24.377 --> 00:32:25.517
就干活的一个逻辑

00:32:25.517 --> 00:32:27.177
它的一个细节是什么

00:32:27.177 --> 00:32:29.397
并且的话就是它的一个

00:32:29.397 --> 00:32:31.937
整个的一些逻辑啊

00:32:31.937 --> 00:32:34.777
就你都可以去自定义啊

00:32:34.777 --> 00:32:37.797
所以这个里面啊

00:32:37.797 --> 00:32:40.477
它可以去调用各种各样的一些

00:32:40.477 --> 00:32:42.017
这个Agent啊

00:32:42.017 --> 00:32:42.637
去读取

00:32:42.637 --> 00:32:44.217
你看像这里的话

00:32:44.217 --> 00:32:45.257
我们就告诉他们

00:32:45.257 --> 00:32:47.797
这个里面有一些CSV数据是吧

00:32:47.797 --> 00:32:50.437
那你可以去做一些这个读取

00:32:50.437 --> 00:32:53.297
但你也可以通过Codex的一个

00:32:53.297 --> 00:32:56.577
非交互式的这个命令的方式去运行

00:32:56.577 --> 00:32:58.797
这样的话就特别适合于

00:32:58.797 --> 00:33:00.097
把它整合到一些

00:33:00.097 --> 00:33:01.877
塞藥脚本里面去

00:33:01.877 --> 00:33:03.157
因为我们以前

00:33:03.157 --> 00:33:05.877
这个比如说在服务器上跑

00:33:05.877 --> 00:33:07.457
都是跑塞藥脚本的是吧

00:33:07.457 --> 00:33:09.377
塞藥脚本里面就不太好用

00:33:09.377 --> 00:33:10.657
这种交互式的页面了

00:33:10.657 --> 00:33:11.957
就是说你要进入到一个

00:33:11.957 --> 00:33:13.577
TY的终端跟他对话

00:33:13.577 --> 00:33:15.857
他更多的是希望用

00:33:15.857 --> 00:33:18.077
这个非交互式的命令去运行

00:33:18.077 --> 00:33:21.877
所以你直接给他输入输出结果就可以了

00:33:21.877 --> 00:33:22.617
所以说

00:33:22.617 --> 00:33:25.177
看大家的一个应用场景

00:33:25.177 --> 00:33:27.197
如果说你想要把Codex

00:33:27.197 --> 00:33:29.117
变成一个这个

00:33:29.117 --> 00:33:31.557
后端的一个任务

00:33:31.557 --> 00:33:31.777
是吧

00:33:31.777 --> 00:33:33.777
就服务器端一个摄像脚本去运行的话

00:33:33.777 --> 00:33:35.957
那你就用非交互式的方式去运行

00:33:35.957 --> 00:33:37.497
如果说你只是自己

00:33:37.497 --> 00:33:40.017
用TY的对话方式去使用的话

00:33:40.017 --> 00:33:41.277
你就不需要加这个指令

00:33:41.277 --> 00:33:44.097
所以看大家大家的一个使用情况

00:33:44.097 --> 00:33:48.357
然后包括一些那个agents的一个最大线程数啊

00:33:48.357 --> 00:33:49.477
然后他的一个时间啊

00:33:49.477 --> 00:33:49.677
是不是

00:33:49.677 --> 00:33:56.557
然后比如说我们还要做一些什么前端集成调试是吧

00:33:56.557 --> 00:33:59.597
比如说一些前端兼容性的问题啊

00:33:59.597 --> 00:34:00.237
是吧

00:34:00.237 --> 00:34:02.437
然后回归测试啊

00:34:03.437 --> 00:34:06.237
那么大家就单独可以去开发一些子生体

00:34:06.237 --> 00:34:07.637
去什么呢

00:34:07.637 --> 00:34:08.657
比如说操作流暖器

00:34:08.657 --> 00:34:09.737
去做自动化测试

00:34:09.737 --> 00:34:10.577
去做验证

00:34:10.577 --> 00:34:11.897
然后生成一些色彩报告

00:34:11.897 --> 00:34:14.237
并且的话可以去什么呢

00:34:14.237 --> 00:34:16.457
去加一些这个配置

00:34:16.457 --> 00:34:16.957
是吧

00:34:16.957 --> 00:34:19.377
就是你可以做很多自动化的一些事情

00:34:19.377 --> 00:34:20.997
就是在前端

00:34:20.997 --> 00:34:23.357
你可以比如说针对浏览器做一些debug

00:34:23.357 --> 00:34:24.077
是吧

00:34:24.077 --> 00:34:26.897
然后去生成一些这个

00:34:26.897 --> 00:34:29.097
性能的一些报告

00:34:29.097 --> 00:34:29.997
截屏

00:34:29.997 --> 00:34:31.257
然后分析

00:34:31.257 --> 00:34:34.177
当前的这个UI上面有哪些问题

00:34:34.177 --> 00:34:35.817
包括它的一个设计

00:34:35.817 --> 00:34:37.577
设计我们可以通过截图来分析

00:34:37.577 --> 00:34:37.957
是吧

00:34:37.957 --> 00:34:40.577
那包括他整个的一些细节啊

00:34:40.577 --> 00:34:42.657
应该是怎么样的

00:34:42.657 --> 00:34:43.997
你都可以通过这个

00:34:43.997 --> 00:34:46.317
子整体去实现了

00:34:46.317 --> 00:34:50.297
所以说这个子整体能干的事情非常多啊

00:34:50.297 --> 00:34:51.217
就是做一些

00:34:51.217 --> 00:34:54.017
流水线工作的时候

00:34:54.017 --> 00:34:57.517
需要大量的这个分批次啊

00:34:57.517 --> 00:35:00.057
按照这个可以并行的去执行啊

00:35:00.057 --> 00:35:02.177
比如这个是做UI修复的

00:35:02.177 --> 00:35:06.017
上面是做浏览器bug的一个调试的是吧

00:35:06.017 --> 00:35:08.957
那你就可以去做各种各样的一个场景

00:35:08.957 --> 00:35:12.597
那这里面我给大家演示一下

00:35:12.597 --> 00:35:16.597
就首先是CSV批量数据是吧

00:35:16.597 --> 00:35:19.697
那这里面比如说我先建个文件夹

00:35:19.697 --> 00:35:24.197
我在这里面建一个文件夹

00:35:24.197 --> 00:35:25.857
叫做CSV

00:35:25.857 --> 00:35:29.037
那我让Codex帮我生成一些数据

00:35:29.037 --> 00:35:34.857
CSV

00:35:34.857 --> 00:35:39.857
然后我现在切换到这个目录里面去啊

00:35:39.857 --> 00:35:49.737
cssv

00:35:49.737 --> 00:35:56.597
然后帮我生成

00:35:56.597 --> 00:36:00.757
我们让他想做一个什么事情呢

00:36:00.757 --> 00:36:05.997
比如说我现在想去做一个

00:36:05.997 --> 00:36:09.757
先生成12个月的一个

00:36:09.757 --> 00:36:13.137
这个比如说产品的一个销售的一个情况

00:36:13.137 --> 00:36:13.517
是吧

00:36:13.517 --> 00:36:16.457
然后再把它会会总成一个年度的一个报告

00:36:16.457 --> 00:36:17.297
啊

00:36:17.297 --> 00:36:18.537
我们做这样一个情况

00:36:18.537 --> 00:36:20.137
这个实现啊

00:36:20.137 --> 00:36:23.577
帮我生成1到12月份

00:36:23.577 --> 00:36:28.237
你就生成1到12月份

00:36:28.237 --> 00:36:29.917
嗯

00:36:29.917 --> 00:36:34.617
销售数据的CSV

00:36:34.617 --> 00:36:36.937
视力

00:36:36.937 --> 00:36:43.557
电子产品吧

00:36:43.557 --> 00:36:46.537
电子产品销售数据的CSV

00:36:46.537 --> 00:36:47.957
文件

00:36:47.957 --> 00:36:52.257
总计12个文件

00:36:52.257 --> 00:36:55.417
要求

00:36:55.417 --> 00:36:58.297
数据

00:36:58.297 --> 00:37:00.897
尽量真实

00:37:00.897 --> 00:37:02.837
尽量真实一点

00:37:02.837 --> 00:37:06.877
这个就是我们的需求

00:37:06.877 --> 00:37:07.957
这是我们的需求

00:37:07.957 --> 00:37:10.297
然后我现在进入到Codex

00:37:10.297 --> 00:37:18.557
我先让他把CSV数据给他生产出来

00:37:18.557 --> 00:37:19.477
生产出来之后

00:37:19.477 --> 00:37:23.337
然后我让他并行的去处理12个月的数据

00:37:23.337 --> 00:37:28.257
最终我关注的是年度的这个销售数据的一个报告

00:37:28.257 --> 00:37:30.017
这个报告的话

00:37:30.017 --> 00:37:32.777
我想让它生成这个

00:37:32.777 --> 00:37:34.717
然后看一下

00:37:34.717 --> 00:37:36.297
生成一个PDF吧

00:37:36.297 --> 00:37:37.197
区分一下

00:37:37.197 --> 00:37:38.557
就生成PDF数据吧

00:37:38.557 --> 00:37:40.797
这样大家会看到更加清晰一些

00:37:40.797 --> 00:37:45.377
首先先生成

00:37:45.377 --> 00:37:46.837
先生成完之后的话

00:37:46.837 --> 00:37:48.217
然后再去处理

00:37:48.217 --> 00:37:52.817
这个就是我们想

00:37:52.817 --> 00:37:54.917
并行的去处理一个cell数据

00:37:54.917 --> 00:37:57.517
这只是一个案例

00:37:57.517 --> 00:37:58.997
就是大家你可以以后

00:37:58.997 --> 00:38:00.917
不管是CSV数据也好

00:38:00.917 --> 00:38:02.477
还是其他的各种各样的文件

00:38:02.477 --> 00:38:04.917
只要他需要分批处理的

00:38:04.917 --> 00:38:06.877
并且可以支持并且处理的

00:38:06.877 --> 00:38:09.597
然后需要做一个汇总的这种场景

00:38:09.597 --> 00:38:13.897
就特别适合用子智能体去做一个优化

00:38:13.897 --> 00:38:15.577
就提高它的一个效率

00:38:15.577 --> 00:38:18.917
所以这一块是大家可以去关注的一个点

00:38:27.517 --> 00:38:30.437
所以他生成完之后的话

00:38:30.437 --> 00:38:32.177
我们再来做一个汇总啊

00:38:32.177 --> 00:38:35.037
等下会让他开发一个SysV的一个

00:38:35.037 --> 00:38:37.257
这个Worker是吧

00:38:37.257 --> 00:38:41.217
然后再去分析数据啊

00:38:41.217 --> 00:38:44.537
其实我现在可以同步开发

00:38:44.537 --> 00:38:47.637
我再切换到一个这个里面去啊

00:38:47.637 --> 00:38:50.017
我现在一边生成数据

00:38:50.017 --> 00:38:52.457
一边去切换到这个

00:38:52.457 --> 00:38:54.077
让他去开发这个agency

00:38:54.077 --> 00:38:58.317
比如说agents

00:38:58.317 --> 00:39:02.837
csv

00:39:02.837 --> 00:39:05.377
比如说

00:39:05.377 --> 00:39:08.137
我们进入到codex

00:39:08.137 --> 00:39:12.777
帮我

00:39:12.777 --> 00:39:14.917
你看12个月的数据基本上快生成完了

00:39:14.917 --> 00:39:15.177
是吧

00:39:15.177 --> 00:39:19.837
我首先让他开发一个这个subagents

00:39:19.837 --> 00:39:24.757
帮我配置一个

00:39:24.757 --> 00:39:33.477
CSV数据分析的子智能体

00:39:33.477 --> 00:39:36.837
然后啊

00:39:36.837 --> 00:39:41.317
能体和

00:39:41.317 --> 00:39:44.757
CSV

00:39:44.757 --> 00:39:49.997
想一下

00:39:49.997 --> 00:39:52.597
一个是做数据分析的

00:39:52.597 --> 00:39:57.097
就这个只是指分析给出这个结论是吧

00:39:57.097 --> 00:39:59.177
指正体和

00:40:00.413 --> 00:40:02.313
或者说怎么叫

00:40:02.313 --> 00:40:04.573
CSV

00:40:04.573 --> 00:40:07.593
数据

00:40:07.593 --> 00:40:12.873
数据汇总

00:40:15.413 --> 00:40:44.093
CSIVE年度销售数据贵总生成PDF报告的

00:40:45.413 --> 00:40:48.893
子智能体

00:40:48.893 --> 00:40:56.953
我们就分两类吧

00:40:56.953 --> 00:40:59.153
一类叫数据分析

00:40:59.153 --> 00:41:03.313
总结啊

00:41:03.313 --> 00:41:04.033
一个叫总结

00:41:04.033 --> 00:41:05.933
一个叫这个汇总啊

00:41:05.933 --> 00:41:06.613
总结这里

00:41:06.613 --> 00:41:09.893
总结我们就是输出txt啊

00:41:09.893 --> 00:41:12.253
报告

00:41:12.253 --> 00:41:16.293
和去生成PDF汇总报告

00:41:16.293 --> 00:41:18.113
就是两种场景

00:41:18.113 --> 00:41:20.613
我们都给它去加一下

00:41:20.613 --> 00:41:27.413
就最后要看到两个文件

00:41:27.413 --> 00:41:29.393
一个是用来去生成TXT的

00:41:29.393 --> 00:41:31.233
一个是用来去生成PDF的

00:41:31.233 --> 00:41:33.933
这个就是我们的需求

00:41:33.933 --> 00:41:35.273
然后数据来源

00:41:35.273 --> 00:41:36.513
就这些CSV数据

00:41:36.513 --> 00:41:39.933
所以我们等一下来看一下

00:41:39.933 --> 00:41:43.453
这两个Worker的一个工作逻辑

00:42:09.933 --> 00:42:18.013
好

00:42:18.013 --> 00:42:18.813
我们等它生成

00:42:18.813 --> 00:42:21.893
然后我们首先来看一下这个数据啊

00:42:21.893 --> 00:42:23.213
1月份

00:42:23.213 --> 00:42:24.693
2月份

00:42:24.693 --> 00:42:25.273
3月份

00:42:25.273 --> 00:42:26.133
4月份

00:42:26.133 --> 00:42:28.273
这个数据看上去没什么问题啊

00:42:28.273 --> 00:42:30.253
都是一些电子产品的销售数据是吧

00:42:30.253 --> 00:42:32.473
然后我们等一下看一下

00:42:32.473 --> 00:42:34.813
这个生成出来的报告是什么样的

00:42:34.813 --> 00:42:37.753
然后现在它在开发这个

00:42:37.753 --> 00:42:39.233
Subagency

00:42:39.233 --> 00:42:43.113
这里需要一点时间

00:42:43.113 --> 00:42:55.993
他帮我去写了一个agents.md文件

00:42:55.993 --> 00:42:59.313
因为我之前这个有一套规范

00:42:59.313 --> 00:43:01.673
我定义了一套全局的ddt规范

00:43:01.673 --> 00:43:05.193
所以他把这个领域的这个规范

00:43:05.193 --> 00:43:07.433
也应用到了C4V的这个分析里面去了

00:43:07.433 --> 00:43:10.333
其实是不需要这个规范的

00:43:10.333 --> 00:43:12.433
但是我因为我当时写了全局规范了

00:43:12.433 --> 00:43:13.793
所以他也把它考虑进去了

00:43:13.793 --> 00:43:15.833
这个也没关系

00:43:15.833 --> 00:43:19.873
我们只要看那个subagents能不能生成就完了

00:43:19.873 --> 00:43:25.153
你看TOM语法教验通过

00:43:25.153 --> 00:43:26.693
目录也预计生成

00:43:26.693 --> 00:43:27.213
然后

00:43:27.213 --> 00:43:29.653
他

00:43:29.653 --> 00:43:31.133
看一下

00:43:31.133 --> 00:43:33.573
这个子这张体

00:43:37.433 --> 00:43:40.273
在Codex目录下面

00:43:40.273 --> 00:43:41.593
有一个agents

00:43:41.593 --> 00:43:43.313
agents下面生成了这个

00:43:43.313 --> 00:43:45.153
首先是一个tom文件

00:43:45.153 --> 00:43:47.653
你看这次的是一个tom文件的方式

00:43:47.653 --> 00:43:49.953
它不是一个markdown了

00:43:49.953 --> 00:43:51.433
就这个

00:43:51.433 --> 00:43:54.353
我看一下应该也是可以的

00:43:54.353 --> 00:43:55.273
tom文件

00:43:55.273 --> 00:43:58.453
描述

00:43:58.453 --> 00:44:01.713
然后包括一些这个细节啊

00:44:01.713 --> 00:44:02.013
是吧

00:44:02.013 --> 00:44:03.773
都是可以的

00:44:03.773 --> 00:44:06.613
就他用markdown跟那个都是可以执行的

00:44:06.613 --> 00:44:09.533
这个tome文件也是ok的

00:44:09.533 --> 00:44:10.613
咱们都是配置文件

00:44:10.613 --> 00:44:12.293
工作方式

00:44:12.293 --> 00:44:13.453
然后年度汇总

00:44:13.453 --> 00:44:15.093
这个是pdf的是吧

00:44:15.093 --> 00:44:16.913
这是tst的

00:44:16.913 --> 00:44:19.053
你看它的报告就不太一样了

00:44:19.053 --> 00:44:19.313
是吧

00:44:19.313 --> 00:44:21.253
现在我们就让它干活了

00:44:21.253 --> 00:44:28.373
帮我生成

00:44:28.373 --> 00:44:38.853
pdf报告

00:44:38.853 --> 00:44:40.833
你就这么说

00:44:40.833 --> 00:44:44.293
帮我分析当前所有

00:44:44.293 --> 00:44:48.953
csv文件

00:44:48.953 --> 00:44:51.133
然后输出

00:44:51.133 --> 00:44:54.593
这里我们提一下

00:44:54.593 --> 00:44:57.973
然后调用子智能体

00:44:57.973 --> 00:45:06.933
生成TXT报告和PDF报告

00:45:06.933 --> 00:45:09.273
好就完事了

00:45:09.273 --> 00:45:12.193
然后这两个自动体

00:45:12.193 --> 00:45:14.113
我们等一下看一下它的一个工作逻辑

00:45:14.113 --> 00:45:15.973
现在还正在执行

00:45:15.973 --> 00:45:18.773
就看一下它两个可以并行处理

00:45:18.773 --> 00:45:21.973
同时生成这个TXT跟PDF

00:45:27.973 --> 00:45:57.173
它会首先去分析这个SysV

00:45:57.173 --> 00:45:58.633
里面的一些数据

00:45:58.633 --> 00:46:01.333
然后包括一些任务

00:46:01.333 --> 00:46:04.533
看一下这个agents有没有在工作了

00:46:04.533 --> 00:46:06.293
agents

00:46:06.293 --> 00:46:09.273
你看现在有一个在工作了

00:46:09.273 --> 00:46:11.993
但是还没定性是不是worker

00:46:11.993 --> 00:46:13.533
因为他没写文件了

00:46:13.533 --> 00:46:14.353
他在做分析

00:46:14.353 --> 00:46:17.173
所以这个是一个默认的

00:46:17.173 --> 00:46:18.893
你看这个agents县层里面

00:46:18.893 --> 00:46:19.733
他还在工作

00:46:19.733 --> 00:46:23.493
我现在已经切换到这个直升体里面了

00:46:23.493 --> 00:46:25.373
他现在还在执行

00:46:25.373 --> 00:46:28.033
所以还看不出来它的一个类型

00:46:28.033 --> 00:46:29.953
你看现在是不是就有了

00:46:29.953 --> 00:46:31.213
当前的

00:46:31.213 --> 00:46:34.053
你看下面两个再生成PDF跟Word了

00:46:34.053 --> 00:46:35.533
跟这个DXT了

00:46:35.533 --> 00:46:37.373
所以它是Walk了

00:46:37.373 --> 00:46:39.613
就是切换到这个里面去

00:46:39.613 --> 00:46:41.633
切换到这个子智能体里面

00:46:41.633 --> 00:46:44.373
它现在再读取一些工具了

00:46:44.373 --> 00:46:47.193
你看这个是读

00:46:47.193 --> 00:46:49.393
这个是生成PDF的

00:46:49.393 --> 00:46:51.533
我们再切换到另外一个

00:46:51.533 --> 00:46:54.233
这个是看一下

00:46:54.233 --> 00:46:57.433
这个就是txt了啊

00:46:57.433 --> 00:47:03.233
就一个txt一个是这个pdf啊

00:47:03.233 --> 00:47:05.473
然后还有一个这个是干嘛的

00:47:09.433 --> 00:47:11.133
这个是之前的

00:47:11.133 --> 00:47:14.393
这是之前去生成这个文件的

00:47:18.593 --> 00:47:19.573
直读完成

00:47:19.573 --> 00:47:19.893
没有

00:47:19.893 --> 00:47:23.973
这是之前去生成agents的那些个

00:47:23.973 --> 00:47:24.973
这个县城啊

00:47:28.373 --> 00:47:30.913
目前你看这里有一个绿色的啊

00:47:30.913 --> 00:47:34.013
绿色的就是正在工作的啊

00:47:34.013 --> 00:47:35.313
活动的

00:47:35.313 --> 00:47:38.633
然后这个白色的就是聪明已经关掉了啊

00:47:38.633 --> 00:47:41.673
所以我们主要关注这两个worker就行了

00:47:41.673 --> 00:47:46.773
一个生成pdf的一个生成这个txt的啊

00:47:46.773 --> 00:47:49.613
所以他主要关注这两个就行了

00:47:49.613 --> 00:47:52.633
啊在这个下面我们会看到他整个的一个报告

00:47:52.633 --> 00:47:53.633
是吧

00:47:53.973 --> 00:47:54.614
好

00:47:56.314 --> 00:47:57.154
那等他跑完

00:47:57.154 --> 00:47:57.614
跑完之后

00:47:57.614 --> 00:47:58.814
我们就能看到那个报告了

00:48:09.614 --> 00:48:17.754
编码入口修好了

00:48:17.754 --> 00:48:20.394
然后再验证这个PowerShell到Python

00:48:20.394 --> 00:48:21.854
可以保持UTF刚报

00:48:21.854 --> 00:48:25.034
就是它这个中间会帮你去考虑一些编码问题

00:48:25.034 --> 00:48:27.574
如果说你有一些编码问题的话

00:48:27.574 --> 00:48:30.074
这个时候它可能会有一些问题

00:48:30.074 --> 00:48:32.994
所以这个细节大家需要考虑一下

00:48:32.994 --> 00:48:38.194
这里面有些进程它可能报错了

00:48:38.194 --> 00:48:39.434
那你要去看一下

00:48:39.434 --> 00:48:41.674
如果他跑了很久的话

00:48:41.674 --> 00:48:42.634
你可以关注一下

00:48:42.634 --> 00:48:44.474
当然他都会帮你去处理

00:48:44.474 --> 00:48:47.474
只是这个时间可能会耗费比较久

00:48:47.474 --> 00:48:56.234
你看报告已经写出来了

00:48:56.234 --> 00:48:57.614
然后他会复合一下

00:48:57.614 --> 00:49:01.134
但是他没写文件啊

00:49:01.134 --> 00:49:02.754
他已经输出了

00:49:02.754 --> 00:49:03.894
看一下

00:49:03.894 --> 00:49:05.574
TXT的已经写完了啊

00:49:05.574 --> 00:49:07.314
你看这个TXT的给了一个报告

00:49:07.314 --> 00:49:10.374
总的一个情况

00:49:10.374 --> 00:49:10.694
是吧

00:49:10.694 --> 00:49:11.774
销售数据啊

00:49:11.774 --> 00:49:12.794
品类啊

00:49:12.794 --> 00:49:13.014
是吧

00:49:13.014 --> 00:49:13.894
品牌啊

00:49:13.894 --> 00:49:16.114
应该是不是都帮你分析的清清楚楚的

00:49:16.114 --> 00:49:16.714
渠道啊

00:49:16.714 --> 00:49:17.114
是吧

00:49:17.114 --> 00:49:19.314
整个的都帮你分析了

00:49:19.314 --> 00:49:21.094
然后还差一个PDF的

00:49:21.094 --> 00:49:23.174
PDF的慢一点啊

00:49:23.174 --> 00:49:24.834
因为他要去

00:49:24.834 --> 00:49:26.074
叫PDF的一些库

00:49:26.074 --> 00:49:28.854
然后我们看一下这个agency

00:49:28.854 --> 00:49:31.054
有一个是已经终结了

00:49:31.054 --> 00:49:32.934
但这里还在work

00:49:32.934 --> 00:49:35.454
看一下这个

00:49:35.454 --> 00:49:37.054
这个还在写啊

00:49:37.314 --> 00:49:40.774
这个生日PDF的会稍微慢一点

00:49:40.774 --> 00:49:42.674
因为他可能还要画一些图表啊

00:49:42.674 --> 00:49:44.534
所以就慢一点

00:49:44.534 --> 00:49:48.834
那这个数据还是挺完善的是吧

00:49:48.834 --> 00:49:50.114
帮我们把一些细节问题

00:49:50.114 --> 00:49:52.194
其实都考虑的非常清楚了

00:49:52.194 --> 00:49:54.894
所以大家看到这个报告的时候啊

00:49:54.894 --> 00:49:57.134
已经是他里面做了非常多的总结归纳了

00:49:57.134 --> 00:50:01.054
然后这个PDF会稍微慢一点

00:50:01.054 --> 00:50:07.174
所以我们回过头再来看一下

00:50:07.174 --> 00:50:08.574
在这个文档里面

00:50:08.574 --> 00:50:09.714
这里就可以提到

00:50:09.714 --> 00:50:11.574
就这些个点啊

00:50:11.574 --> 00:50:13.654
一些C4V的这些个数据的话

00:50:13.654 --> 00:50:16.554
大家可以用在各种各样的场景里面啊

00:50:16.554 --> 00:50:19.014
不要局限于这个C4V这个场景啊

00:50:19.014 --> 00:50:21.314
你可以把它用到各种啊

00:50:21.314 --> 00:50:24.014
包括我们前面给他讲的那个代码分析

00:50:24.014 --> 00:50:25.754
也是一个比较好的场景是吧

00:50:25.754 --> 00:50:28.054
就是这种可以并行的

00:50:28.054 --> 00:50:29.714
分批量的去跑的任务

00:50:29.714 --> 00:50:31.574
你都可以交给这个

00:50:31.574 --> 00:50:34.334
Codex的一个subagents

00:50:34.334 --> 00:50:36.374
让他专门去写一个字笼体

00:50:36.374 --> 00:50:38.374
去跑这个任务

00:50:38.374 --> 00:50:39.254
这样的话

00:50:39.254 --> 00:50:40.974
它可以并行的去处理

00:50:40.974 --> 00:50:42.234
它的效率会很高

00:50:42.234 --> 00:50:44.014
所以的话

00:50:44.014 --> 00:50:45.754
最终啊

00:50:45.754 --> 00:50:47.074
就生成这个报告的话

00:50:47.074 --> 00:50:48.234
哎

00:50:48.234 --> 00:50:49.334
这个效果

00:50:49.334 --> 00:50:51.614
效率就比较高啊

00:50:51.614 --> 00:50:54.194
然后这个前单调受的话

00:50:54.194 --> 00:50:56.414
也是一个比较好的场景啊

00:50:56.414 --> 00:50:57.534
就是大家可以把这个

00:50:57.534 --> 00:50:59.474
整合到不同的这个

00:50:59.474 --> 00:51:03.334
一些自动化测试啊

00:51:03.334 --> 00:51:03.674
是吧

00:51:03.674 --> 00:51:05.314
包括一些后端接口啊

00:51:05.314 --> 00:51:06.294
比如说我后端的接口

00:51:06.294 --> 00:51:06.974
代码写完了

00:51:06.974 --> 00:51:09.214
我现在想通过CURL

00:51:09.214 --> 00:51:11.334
单独我开一个

00:51:11.334 --> 00:51:12.514
这个直升体

00:51:12.514 --> 00:51:13.614
想用CURL

00:51:13.614 --> 00:51:14.954
把整个的一个测试

00:51:14.954 --> 00:51:15.734
都给它跑通

00:51:15.734 --> 00:51:16.974
跑通

00:51:16.974 --> 00:51:18.274
各种的案例测试

00:51:18.274 --> 00:51:19.354
没问题之后的话

00:51:19.354 --> 00:51:21.314
咱们再来去验证

00:51:21.314 --> 00:51:22.514
这个里面的逻辑

00:51:22.514 --> 00:51:24.154
有没有问题

00:51:24.154 --> 00:51:24.854
是吧

00:51:24.854 --> 00:51:28.714
就是代码一写完

00:51:28.714 --> 00:51:30.094
自动化测试

00:51:30.094 --> 00:51:32.694
就可以开始做了

00:51:32.694 --> 00:51:34.614
这个就是可以并行的

00:51:34.614 --> 00:51:35.274
包括一些

00:51:35.274 --> 00:51:37.034
文档是吧

00:51:37.034 --> 00:51:38.074
文档生成啊

00:51:38.074 --> 00:51:39.234
一些逻辑啊

00:51:39.234 --> 00:51:40.454
你就可以去生成

00:51:40.454 --> 00:51:42.174
甚至你有些现成

00:51:42.174 --> 00:51:43.854
他可以去协作啊

00:51:43.854 --> 00:51:45.374
就你可以一直让他等在那里

00:51:45.374 --> 00:51:46.634
比如说当大码开发完了

00:51:46.634 --> 00:51:48.014
马上就启动一个

00:51:48.014 --> 00:51:49.854
自动化测试的一个现成

00:51:49.854 --> 00:51:51.194
自动化测试完之后

00:51:51.194 --> 00:51:52.434
马上就生成一个

00:51:52.434 --> 00:51:53.874
测试报告的一个现成

00:51:53.874 --> 00:51:55.394
就让他给启动了

00:51:55.394 --> 00:51:58.214
所以大家可以在这个里面

00:51:58.214 --> 00:52:00.234
加各种各样的一个场景啊

00:52:00.234 --> 00:52:02.734
其实啊

00:52:02.734 --> 00:52:04.374
都可以做很多事情

00:52:05.274 --> 00:52:07.514
然后pdf看有没有生成啊

00:52:08.734 --> 00:52:10.214
还没有生成这个比较慢啊

00:52:10.214 --> 00:52:13.434
因为它要涉及到非常多的代码逻辑啊

00:52:15.034 --> 00:52:16.674
可能还会有一些编码报错

00:52:16.674 --> 00:52:18.634
因为他要保证不会出现乱码

00:52:19.274 --> 00:52:21.114
好大家看这个pdf已经生成了

00:52:21.714 --> 00:52:22.914
我看一下有没有问题

00:52:26.434 --> 00:52:29.714
已经生成成功指标也跑出来了啊

00:52:29.714 --> 00:52:30.414
看一下

00:52:35.274 --> 00:52:38.074
大家看

00:52:38.074 --> 00:52:39.374
这是他跑出来的这个数据

00:52:39.374 --> 00:52:42.774
这个效果还是不错的

00:52:42.774 --> 00:52:45.974
但是这个字体有点没设计好

00:52:45.974 --> 00:52:48.534
包括一些规范阅读

00:52:48.534 --> 00:52:50.774
你看这个图表都是给咱们画出来的

00:52:50.774 --> 00:52:52.314
还是比较完善的

00:52:52.314 --> 00:52:54.094
产品维度等等的

00:52:54.094 --> 00:52:55.034
还不错

00:52:55.034 --> 00:52:58.494
默认没有加任何节日时优化

00:52:58.494 --> 00:53:00.654
能够做到这种程度还是比较完善了

00:53:00.654 --> 00:53:02.574
所以它的效果也算OK

00:53:02.574 --> 00:53:07.734
所以这个里面就是大家可以做很多的这种优化

00:53:07.734 --> 00:53:10.594
一些智能体等等的

00:53:10.594 --> 00:53:11.114
是吧

00:53:11.114 --> 00:53:13.214
我们就可以做各种各样的调优

00:53:13.214 --> 00:53:16.254
包括一些bug的一些修复

00:53:16.254 --> 00:53:16.874
是吧

00:53:16.874 --> 00:53:18.894
然后我们都可以去做一些处理

00:53:18.894 --> 00:53:20.594
那这个的话

00:53:20.594 --> 00:53:22.954
回头大家可以去验证一下

00:53:22.954 --> 00:53:24.794
你可以把它用到不同的场景里面去

00:53:24.794 --> 00:53:27.454
一个是做CSV的这个数据分析是吧

00:53:27.454 --> 00:53:29.274
一个是做代码的一个审查

00:53:29.274 --> 00:53:32.154
包括前端的一个机身调试测试

00:53:32.154 --> 00:53:34.054
或者后端的一个自动化测试

00:53:34.054 --> 00:53:38.114
大家都可以基于这个子智能体去做一个实战

00:53:38.114 --> 00:53:40.214
回头我们可以去看一下