start	end	text
0	3940	接下来我们来讲一下
3940	5460	Codex Sub-Agents
5460	8060	多智能体协同与复杂论物分发
8060	10540	那么这个一般是用在什么场景呢
10540	13580	比如说大家要做一个非常复杂的一个任务
13580	15320	比如说我们要做一个大项目
15320	17560	这个项目里面涉及到一些需求分析
17560	20840	然后开发测试
20840	22380	包括部署等等的
22380	24760	非常多的一些细节问题的时候
24760	27420	那这时候我们要对一个大项目
27420	28740	做一个任务的一个拆分
28740	32200	按需求按开发按测试按部署等等
32200	34420	我们要把任务拆出来
34420	35860	拆出来之后的话
35860	40100	我们这个任务应该怎么来执行呢
40100	40640	是吧
40640	42080	那么在Codex里面的话
42080	45000	就有一个叫做Subagents的这么一个组件
45000	47760	那这个翻译过来叫做子智能体
47760	50200	也就是说大家可以把Codex
50200	53040	整个看作一个大的一个智能体的话
53040	58000	那它去单独可以去开一些子的一个智能体
58000	59540	去帮我们去完成一个任务
59540	62520	就相当于我们现在是一个公司是吧
62520	64180	那Codex相当于这个公司
64180	65740	那现在有员工啊
65740	67840	每个部门有负责人是吧
67840	70340	然后他要带头去做不同的项目
70340	73860	有这个具体的这个同事负责不同的这个工作
73860	76820	你就可以把这些个同事看作这个子agent
76820	79800	那么你可以把它看作成一个小团队
79800	81760	他可以做不同的这个任务
81760	83740	这个就是决策定义
83740	84860	然后并且的话
84860	86440	这里面有个非常关键的点
86440	87900	就是他可以并行
88000	88660	什么意思呢
88660	89760	就是我这个任务啊
89760	92380	我不是说要等是吧
92380	94420	那我这个开发跟测试
94420	96220	我这个测试的文档
96220	97360	是不是可以先生成了
97360	97760	是吧
97760	98960	那你需求出来之后
98960	100320	我这个这个代码
100320	101440	是不是就可以开始写了
101440	103280	然后测试的一些规范
103280	104500	是不是就可以开始做了
104500	105420	就有些工作
105420	106720	它是可以并行的啊
106720	108900	它不是说依赖于上面那个工作
108900	110700	完成了才能做下一刻
110700	113160	我们是可以做一些编排的啊
113160	114460	就多个整体之间
114460	115600	它是可以协作的
115600	116860	那么Codex的话
116860	118680	就可以通过这种并行的方式
118680	120820	启动多个专用的这种智能体
120820	125060	帮我们一起同时的去做各自的一些工作
125060	126280	然后做完之后的话
126280	128340	给它做一些合并
128340	128760	是吧
128760	130800	然后把这个结果做一下这个归纳
130800	133400	比如说我整个一个项目是有需求
133400	134840	有开发有测试
134840	135200	是吧
135200	136280	有部署等等的
136280	138920	我希望它并行可以去完成一些事情
138920	141320	就是我有一些工作完成之后
141320	144460	我可以交由智能体自动的去切换
144460	145400	然后去协作
145400	148440	最终我的目标是这个项目要上线
148440	150780	我只关注这个目标就可以了
150780	152780	那么其他的步骤怎么来分的话
152780	155020	我们可以让Codex里面
155020	157120	这个叫Subagents的一个组件
157120	158180	去做这个事情
158180	160860	那么目前Codex的话
160860	161780	最新版本
161780	165080	它是默认启用了一个Subagents的话
165080	167080	大家可以正常的去使用
167080	170360	那么一般我们可以把它用在一个
170360	171540	什么样的一个场景呢
171540	173160	比如说啊
173160	176180	我们可以去做一个非常大型的项目
176180	178660	比如说我现在要针对这个PR是吧
178660	179320	做审查
179320	181160	我要审查的安全问题
181160	182440	代码质量bug
182440	184380	这种场景的话
184380	186960	就特别适合用这个subagents
186960	189260	因为它前后的这个任务
189260	190300	没有关联项
190300	191900	它都可以并行的去执行
191900	194240	它不是说先要把安全问题查出来
194240	195680	再把代码质量分析一下
195680	196240	再去查bug
196240	198380	这同时可以去
198380	199940	同步的去跑
199940	202780	跑出来之后给一个汇总的结果就可以了
202780	203720	所以这种任务
203720	204600	它特别适合
204600	205780	于用这个Codex
205780	207580	像我们刚刚讲的
207580	208380	那个软件的
208380	209500	这个开发工作流的话
209500	211080	它还是会有一些依赖的
211080	213360	文档可以同时去生成
213360	215700	但是你得先把代码写出来
215700	216640	才得去测试
216640	217180	是吧
217180	219060	所以它还是有一定的依赖的
219060	220460	但是做代码审查
220460	222220	就特别适合于这种场景
222220	223840	那么这个Codex
223840	225640	它就会做各种各样的编码
225640	226940	比如说它会去生成
226940	228600	新的一个子智能体
228600	230880	然后给不同的智能体
230880	232720	去录有我们后续的一个指令
232720	234540	然后就等待一些结果
234540	236940	最后每个智能体
236940	239360	子智能体它的一个任务完成之后
239360	241460	我们再把这个子线上给关闭掉
241460	244420	所以说这个就是一步的方式
244420	246000	那么Codex它也会等待
246000	247580	所有的这个结果完成之后
247580	249080	再做一个汇总答复
249080	251300	所以说我们可以
251300	252780	以这个提示式的方式
252780	254360	让Codex来跑一下
254360	256740	这个当前的一些个情况
256740	257200	是吧
257200	258400	然后再看一下
258400	260620	这里面我们首先给大家来演示一下
260620	264980	那我现在我这个低盘下面有一个Codex目录啊
264980	267840	那这里我是把Codex的一个开源项目拉下来
267840	269940	我们就以这个项目为例啊
269940	273180	然后让他去分析一下这个PR是吧
273180	274620	随便找一个PR吧
274620	277460	嗯
277460	280260	然后的话就是当前PR
280260	281920	就随便
281920	284080	下Codex
284080	285280	我就找一个啊
285280	286260	看一下他的一个PR
286260	294660	我们最开始给大家提供了一个项目
294660	296400	就是Codex的一个开源项目
296400	300220	然后去找到这个整个的一个PR
300220	302660	看一下
302660	306700	就我就随便找一个PR了
306700	307660	那我就用这个
307660	309920	我把这个PR复制一下
309920	312880	然后的话这里面
312880	315860	我们进入Codex
315860	318460	比如这个是一个PR是吧
318460	320880	那我们就给它分析一下
320880	322380	复制一下
322380	325340	我们现在想分析一下
325340	326900	别人现在开源是吧
326900	328220	它提交了一个PR上来
328220	329700	我现在想审查一下这个PR
329700	332060	然后我再加进来
332060	333380	我们就看一下
333380	334460	让它去分析了
334460	337600	那我们在这里就可以看到
337600	341060	整个它会有一个
341060	343080	这个subagents的一个概念
343080	344360	看它这里有没有启动
344360	345180	这个subagents
345180	355120	你看他现在就开始在工作了
355120	355280	是吧
355280	358580	他会执行这个命令去查询这个PR
358580	359020	是吧
359020	360500	执行这个GH命令
360500	361920	这个GH命令的话
361920	364620	是Github提供的一个CLI工具啊
364620	366420	这个首先大家要做一个登录啊
366420	369460	如果说公关公关仓库的话
369460	371520	默认应该是不需要授权的
371520	373160	如果说弹出来要一个token的话
373160	374980	这个最好大家去配一下啊
374980	376540	因为你如果不配置token的话
376540	378540	有些情况下可能会被限制
378540	381920	所以执行一个JH login这个命令
381920	385000	然后就把它去登录一下
385000	386460	这个JH怎么安装
386460	388020	大家可以去找一下这个教程
388020	388540	很简单
388540	391200	把这个JH CLI工具给它装一下
391200	395080	然后我们就可以看一下
395080	398520	看一下它的这个subagents
398520	399540	看一下
399540	403240	你看它这个斜钢命令里面有一个agents
403240	404800	我们这里面可以看一下
404800	409020	你看当前是有一个主线程
409020	409460	是吧
409460	410360	主线程
410360	413240	然后这个里面我们可以去看一下啊
414240	416740	看一下它的一个逻辑
416740	418860	现在是只有一个主线程
418860	425240	那现在这个里面还是在去拉代码啊
425240	432160	这个里面我们可以切换啊
432160	436760	就是当前如果他启动了一个子智能体的话
436760	441080	我们可以看到一些这个细节啊
441080	443100	比如说切换到当前活动的
443100	446160	到目前为止他还只有一个啊
447160	451440	目前为止还有一个
451440	455940	那我们等一下看他有没有执行多个
455940	461040	你看你是PR的审查子代理
461040	462740	主要负责什么什么是吧
462740	466000	然后他这里就是开始去分配这个subagents了
466000	466480	是吧
466480	470300	这里面我们先让他跑着
470300	472900	我开另外一个窗口同步的来看啊
472900	474680	因为这个消息太多了
474680	476940	有时候看得有点晕啊
476940	478540	就是有点混乱了
478540	480000	我这里再切一个窗口啊
481431	496651	然后codex
496651	501511	sub-agents
501511	508691	它在这个里面
508691	510051	把它当前会晃
510051	511131	subo agents
512131	513131	agents
518731	522091	你看现在这里大家是不是就可以看到多个agents了
522091	523051	是吧
523051	525971	有做这种各种什么提问的呀
525971	526291	是吧
526291	527931	然后各种细节处理的呀
527931	528731	是吧
528731	533011	它会相当于给你单独去加几个这个出来啊
533011	536291	那你可以把这个拿来分析一下
536291	539051	让我推出去
539051	551211	帮我分析下agents中
551211	554131	因为开了多个
554131	555371	我这里都有点卡了
555371	564631	有具体的分工
564631	568591	其实上面日志已经打出来
568591	570091	但是比较多啊
570091	572431	所以这个我们有点看不出来啊
572431	574931	我们现在让这个分析一下
574931	580451	因为这个正在执行啊
580451	582151	所以他这个消息阻塞了
582151	583771	不过没关系啊
583771	584791	我们的这个效果已经
584791	588391	我们可以切换到具体的agents里面去啊
588391	591011	我们可以比如说切换到这个里面去
591011	593391	然后你可以看这个子agent里面
593391	595271	他在做不同的逻辑是吧
595271	598691	他有的是在做安全问题
598691	600531	有些是在做代码质量的
600531	603111	大家可以自由的去切换啊
603111	604251	比如说在这个里面
604251	605611	我可以看出来
605611	607291	主线程
607291	610831	你可以自由的去切啊
610831	612791	那我这个得关一下
612791	613951	不然这个有点卡
613951	618191	把它关一下
618191	620771	这有点卡住了
620771	625051	所以这个你开的越多的话
625051	628191	整个可能就是对性能消耗也比较大
628191	631171	所以我们这里面还是要给他先关掉
631171	633311	不然这个太卡了
633311	636071	就在这个里面啊
636071	638031	在这个里面我们也是可以看得到的
638031	641091	但这个他没有加载出来啊
642211	644211	没关系
644211	645911	刚刚那个我已经中断了
645911	647751	这个会有点卡
647751	655631	所以我们其实可以通过不同的这个子agent
655631	659011	然后的话就是去执行各种各样的任务
659011	659711	然后最终的话
659711	662351	我们其实只关注这个结果有没有
662351	662771	是吧
662771	665571	所以大家可以通过这种方式的话
665571	667511	你就可以去做各种各样的一些
667511	669831	这个分析类的一些工作
669831	671051	因为这种的话
671051	672851	它是没有前后依赖的
672851	674771	大家想怎么用就怎么用
674771	675751	是吧
675751	678051	他你不用考虑前后的依赖关系的话
678051	678551	最终
678551	680071	并行的去跑
680071	681531	跟串行的去跑
681531	682911	其实是
682911	685151	效率不一样的
685151	687091	你并行的去跑的话
687091	688751	这个里面啊
688751	690711	他的一个效率就会更高
690711	692631	因为他可以同时去干活
692631	693951	最终给你一个结果
693951	695931	相当于同样是十秒钟
695931	697471	一个任务
697471	699331	如果是串行的去跑的话
699331	700851	六个任务就是一分钟
700851	701631	他才能跑完
701631	703451	如果说是并行的话
703451	704631	就是十秒钟
704631	705851	把所有任务都跑完了
705851	707651	这个效率是完全不一样的
707651	710711	然后大家也可以通过这个
710711	712911	斜杠agents命令
712911	714571	然后去看一下
714571	716211	当前正在运行的现成
716211	718371	就是你也这个不能开太多了
718371	719191	开太多的话
719191	719891	这个会会
719891	721171	电脑会很卡
721171	723511	所以这个大家需要酌情去考虑
723511	724931	基本上开个
724931	726751	两三个就差不多了
726751	727731	开太多的话
727731	731151	反而就是这个执行会
731151	732611	电脑会有一些影响
732611	734831	但具体得看大家的实际情况
734831	736271	有的你电脑配置高的话
736271	736911	这也不所谓
736911	740151	然后这个子制中体的话
740151	742251	它的权限是怎么样的呢
742251	745451	它会继承我们当前绘画的一个杀相策略啊
745451	746991	也就是说你的主线程
746991	750231	当前比如说用的是bypass模式啊
750231	752191	给了所有的权限的话
752191	755291	那它就是所有权限全开的
755291	758311	如果说你给的是一个需要授权啊
758311	759251	就需要用户确认的话
759251	761111	它会也会继承你这个对话权限
761111	763751	所以关键是看大家就是你想
763751	766351	给一个什么样的权限
766351	768531	比如说你想不要他在用户确认了
768531	770351	你就把权限全放开就可以了
770351	773031	这个就看大家的一个事情情况
773031	776351	然后这个里面啊
776351	778111	他主要就是子真正体的话
778111	779551	他其实很多选项的话
779551	781851	都是通过这个继承了
781851	786271	这个主线程的这么一个真正体去处理的
786271	788611	所以大家去设置这个权限的时候
788611	789991	你也可以去关注一下
789991	792551	就是你的主线程
792551	794171	怎么来设定这个权限
794171	798151	然后的话就是Codex里面
798151	801111	它自带了三种类件的这个智能体
801111	802771	就是我们可以去配置
802771	806691	默认的话就是一个通用回退型的
806691	807451	这么一个智能体
807451	809651	然后Worker它是偏执行的
809651	812711	适合去做一些实现和修复类的工作
812711	814791	Explorer的话就是止读
814791	818411	我们刚刚看到打印的这个日志的话
818411	819751	有些就是Explorer的
819751	821731	因为我们上面提到一个需求
821731	823011	它都是查询嘛
823011	823271	是吧
823271	824391	只是做分析的
824391	826131	它不需要执行一些
826131	827511	这么修改类的一些任务
827511	829611	所以这个就是Explorer
829611	831571	这是Codex
831571	834351	它会根据你当前的一些任务的一些情况
834351	835731	分析出来
835731	838951	它的一个结果应该是怎么样的
838951	839251	是吧
839251	840191	这个东西
840191	844231	它是会根据实际情况去调整的
844231	845651	如果说你拿去改代码的话
845651	848071	它可能会选择这个Worker
848071	851791	所以这个就是它具体的一个执行逻辑
851791	853531	这个我们回头来验一下
853531	857571	然后的话就是我们自定义这个整体的话
857571	863271	它在这个.codex目入下面有一个.agents
863271	864471	文件夹
864471	865951	这个我们可以看一下
865951	869631	就是你可以在当前这个项目下面
869631	873391	你去建一个这个agents
873391	876971	它的一个文件夹
876971	879031	然后的话你可以去配这个agents
879031	881731	然后的话就是你也可以什么呢
881731	883191	在项目级别啊
883191	884331	一个是在全局的
884331	885451	一个是在项目的
885451	887831	那我们等一下来先配一个项目级
887831	888931	比如说
888931	893691	我一个是这个分析
893691	895331	我们就参考前面那几个嘛
895331	895631	是吧
895631	898611	我就让他分析代码问题跟质量
898611	900471	我配两个这个agents
900471	901631	让他去跑一下
901631	903851	看一下能不能跑出效果出来
903851	904231	是吧
904231	906351	那其实就很简单
906351	909371	那比如说我们现在就把这两个给复制一下
909371	911411	怎么来弄呢
911411	913651	首先我们打开这个里面
913651	918031	然后我就直接在这个里面操作了
918031	922091	你就直接在当前这个项目下面
922091	924071	比如说这个project2下面
924071	926111	然后找一个有代码的
926111	927671	比如说这个里面
927671	928871	myproject
928871	932311	我现在找一个项目
932311	939111	这个下面有我之前写的一些小游戏的项目
939111	941391	那我就在这个下面吧
941391	944651	比如说我们现在打开这个目录是吧
944651	946191	然后在这个目录里面
946191	948431	我们切换到这个Codex
948431	951771	来我们这个是
951771	956271	我要用终端展开啊
960535	962135	之前是不是开了一个
962135	963235	好在这个里面
963235	965355	我切换到这个map project里面去
969735	970735	map project
970735	971595	那这个下面
971595	973335	由我之前写的一些这个
973335	975935	生成的一些小游戏的示例吗
975935	981055	那现在我现在相当于我要做一个子智能体啊
981055	982195	我要开两个智能体
982195	986035	一个是去教验这个安全问题
986035	987995	还有一个是教验这个代码质量问题
987995	989075	我要写两个嘛
989075	990495	所以应该怎么来弄呢
990495	992135	我们进入codex
992135	1000155	比如说帮我配置两个子智能体
1001595	1004355	或者你叫subagency也可以啊
1004355	1006095	能体或者叫子代理
1006095	1007235	他应该也能识别出来
1007235	1010055	然后这个是
1010055	1014415	这是我两个的一个需求是吧
1014415	1016655	你就这么来写就可以了
1016655	1018555	然后他默认就会在这个下面去
1018555	1021375	新建这个agency.文件夹
1021375	1024575	然后帮你把这个子智能体给他配进去
1024575	1025515	你看啊
1025515	1027995	他首先会看你这个里面有没有一个叫
1027995	1030155	subagency的这么一个配置是吧
1030155	1030895	没有的话
1030895	1032015	他就会帮你去创建
1032015	1033955	这是差的一个规范
1033955	1035375	所以大家
1035375	1036875	你其实直接让Codex
1036875	1039335	帮你去配置就完了
1039335	1042655	你不需要去看这个文档
1042655	1043015	是吧
1043015	1045135	但如果说你要调一些细节参数的话
1045135	1046275	你还是要知道
1046275	1047315	这里面那些规范的
1047315	1047815	比如说
1047815	1049715	这个子制整体的名称是什么
1049715	1050515	描述是什么
1050515	1051755	然后包括一些
1051755	1054455	一些参数是吧
1054455	1056535	它的一个含义是什么
1056535	1057315	大家需要知道
1057315	1060375	就你只是简单的配一个
1060375	1061855	子制容体的话
1061855	1064055	你就直接让它去执行就完了
1064055	1067675	所以整个过程会比较简单
1067675	1069475	诶
1069475	1071015	那个是到哪里了
1071015	1072675	这里有一个
1072675	1074555	确认啊
1074555	1077315	他说允许
1077315	1078035	fine manage
1078035	1080755	这是一个
1080755	1082395	这是一个mcp服务
1082395	1085215	这是允许
1087315	1090075	你看接下来他会用补丁的方式
1090075	1092195	添加两个agency.md文件
1092195	1095575	并且在agency.md里面去补充一段子
1095575	1096455	智能体的配置
1096455	1101955	所以这些个参数大家需要知道啊
1101955	1105635	比如说允许打开的智能体的一个现成的上限啊
1105635	1109495	然后就是这个参数啊
1109495	1111095	这个什么嵌套的深度啊
1111095	1111655	是吧
1111655	1113595	但这个大家需要的时候再去看啊
1113595	1114675	你可能会不太理解
1114675	1117075	什么叫深层的嵌套深度啊
1117075	1117715	就是一个对话
1117715	1119835	那当你遇到这个问题的时候
1119835	1120535	你再去查
1120535	1123815	就其实你也不用太关心这几个参数
1123815	1127235	只是说你要知道有这么些内容就可以
1127235	1129315	包括它的一个文件结构描述
1129315	1129715	是吧
1129715	1132575	你看现在已经好了
1132575	1133515	你看配置了
1133515	1136955	这样Codex目录下面有一个这个agency
1136955	1139835	然后下面有两个子制容体
1139835	1140235	是吧
1140235	1142655	一个是做安全问题审查的
1142655	1144975	还有一个是做代码质量审查的
1144975	1146455	我们看一下
1146455	1150115	在myproject下面
1150115	1152055	有个点codex目录
1152055	1154035	codex目录下面有个agents目录
1154035	1155615	agents目录下面有个
1155615	1158255	你看这个是做代码审查的子生体
1158255	1160315	它的名称是什么
1160315	1161775	你看对应到我们这个文档是吧
1161775	1162655	名称描述
1162655	1164875	实际我们用的最多的
1164875	1165615	就是这两个参数
1165615	1166575	其他的话
1166575	1167875	没有特殊需求
1167875	1168715	一般不用挑
1168715	1170315	有需要的时候
1170315	1172295	你让codex帮你生成就完了
1172295	1173835	就你给它提需求就行了
1173835	1175935	你不用单独去记这些个参数
1175935	1178995	但是你需要知道有这么个概念在里面
1178995	1181995	就是他支持这些个参数就可以了
1181995	1183675	这个是做代码审查的
1183675	1185555	你看审查子质整体
1185555	1186575	论物是什么什么
1186575	1187455	关注范围是什么
1187455	1188435	审查原则是什么
1188435	1189475	输出格式是什么
1189475	1191815	另外一个是安全问题审查
1191815	1195495	然后因为我们这个项目里面
1195495	1197475	又有python又有html的项目
1197475	1199055	所以他这里面输出了两种
1199055	1201055	html单文件
1201055	1202415	他的细节是什么
1202415	1205715	python他的这个细节有什么
1205715	1206775	审查原则是什么
1206775	1207675	输出格是什么
1207675	1209375	好
1209375	1210415	然后完了之后
1210415	1211875	我们可以通过这个
1211875	1212955	看一下
1212955	1214075	subagents
1214075	1216515	这个是查看的
1216515	1217515	agents
1217515	1224055	这个是我们现在还没跑
1224055	1224795	还没跑
1224795	1227315	接下来你就可以让它去运行一下
1227315	1229415	比如说
1229415	1232835	针对当前
1232835	1235535	项目
1235535	1240135	代码使用智智能体
1240135	1249355	同时进行
1249355	1252655	两个场景啊
1252655	1254995	同时进行代码质量审查
1254995	1257035	还有安全问题审查
1257035	1264935	你会看一下我们写的这个subagents
1264935	1266275	到底能不能生效是吧
1266275	1269195	然后我们现在你看agents
1269195	1270815	现在这个是没有的是吧
1270815	1271635	现在就一个吧
1271635	1274135	然后我们现在等到跑的时候
1274135	1275155	我们再来看一下
1275155	1276855	它会不会起多个啊
1276855	1278595	现在就只有一个
1278595	1280995	因为它没有启动那个子智能体呢
1280995	1283995	这里大家是看不出来的啊
1283995	1286935	然后你看啊
1286935	1288795	你是本项目的安全审查
1288795	1291295	子制成体然后工作目录是啥啥啥
1291295	1293155	现在已经起了一个了
1293155	1294575	再退出去看一下
1294575	1295995	agents
1295995	1298895	然后大家看这个是不是
1298895	1299395	一个
1299395	1302395	主线程是什么是吧
1302395	1303735	然后目标是吧
1303735	1306735	然后相当于它都是做一个tolo
1306735	1309075	就是探索这个主要是做一些分析
1309075	1311255	类的然后两个两个角色
1311255	1313775	这个应该是它生成的一个角色名
1313775	1314995	每次都不一样
1314995	1317015	然后这个是相当于
1317015	1319335	他给你生成两个虚拟的数字员工
1319335	1321975	所以这个里面
1321975	1323555	他干活的就这两个
1323555	1324175	是吧
1324175	1326635	干活的就这两个
1326635	1327895	他都是Expolo
1327895	1330895	如果大家你想让他去改单法的话
1330895	1332875	他应该会生成这个
1332875	1335975	Worker的这么一个执行的一个Subagents
1335975	1338695	我们其实可以再给他加一下
1338695	1341175	就bug修正是吧
1341175	1343235	我先给他退出去
1343235	1346995	我现在才想再加一下
1346995	1350595	恢复到之前那个对话吧
1350595	1360295	Codex resume
1360295	1365995	然后恢复到之前那个对话
1373235	1375975	agents
1375975	1378375	现在那个已经中断了
1378375	1379795	然后
1379795	1382615	再帮我
1382615	1384195	开发一个
1384195	1387235	代码
1387235	1392535	代码修正
1392535	1396335	的
1396335	1399095	智能体
1399095	1404415	配置一个
1404415	1410415	我们主要是要看到这个代码开发的话
1410415	1412315	就是Walker啊
1412315	1413895	比较看一下这个区别就可以了
1413895	1416855	这个是做执行任务的啊
1416855	1420455	主要是要区分一下两种agents
1420455	1423495	就以后大家你加了各种各样的这个子agent
1423495	1423975	是吧
1423975	1425955	那你需要知道
1425955	1428575	这个它的类型是用来干嘛的
1428575	1430935	应该这个是fix
1430935	1433795	你就随便跑一个
1433795	1435835	比如说我现在
1438802	1441942	想让他去做代码修复
1445902	1447062	使用
1447062	1452302	自
1452302	1462702	针对当前项目代码进行修复
1462702	1466122	你就直接这么跟他说啊
1466122	1468802	他会去起这个整体去修复代码
1468802	1474602	但虽然我这个需求没有写明确啊
1474602	1475562	他还是会扫一遍
1475562	1476622	先把问题扫出来
1476622	1478162	然后再去做这个事情
1478162	1482582	然后我们看一下这个
1482582	1484082	到底用的Worker是什么
1484082	1485122	就是
1485122	1488942	现在还是Exploro的
1488942	1493162	等一下到具体修代码的时候
1493162	1493782	才会那个
1493782	1494922	所以这里得等
1494922	1497822	等他先把问题给他分析出来
1497822	1499822	然后再去跑
1499822	1503222	所以他没到改代码之前的话
1503222	1505462	他不会变成那个
1505462	1507502	这个Worker的
1507502	1512202	你看现在是不是变了
1512202	1514562	现在是不是单独起了一个Worker在干活了
1514562	1516022	这个就是改代码的
1516022	1517842	做Fix的修正代码
1517842	1520502	前面那几个都还是分析的
1520502	1522442	这个大家需要注意一下
1522442	1523942	并且前两个都是关闭的
1523942	1527142	你看这个绿色的就表示在运行的
1527142	1530542	这个灰掉的白色的就是没有运行的
1530542	1532442	这个需要注意一下
1532442	1535022	所以这几个类型
1535022	1535882	大家要搞清楚
1535882	1537902	一个是偏执行的
1537902	1539002	修复代码的
1539002	1540702	还有一个是只读的
1540702	1543462	如果说你都没有加的话
1543462	1545162	它可能会变成一个default
1545162	1547762	那个man的
1547762	1548302	我看一下
1548302	1550562	默认的agents的
1550562	1552702	这个你看man就是default
1552702	1554542	主线程
1554542	1555842	他啥都干
1555842	1557622	就是用来回退的
1557622	1559662	主线程的默认就是default
1559662	1562402	一般我们开子制容体要么
1562402	1563542	就是去帮你干活
1563542	1566222	做一些实现跟修复嘛
1566222	1567502	要么就是做分析
1567502	1568502	只读的啊
1568502	1570362	就是这个是可读可写
1570362	1572562	这个是只读的啊
1572562	1573542	或者说这个就是
1573542	1575762	就是用来专门就是用来盖活子啊
1575762	1577502	好
1577502	1578482	这个是项目级的
1578482	1580802	那么大家其实你也可以在这个
1580802	1584182	我们整个的一个全局的啊
1584182	1587562	Codex的全局的这个配置里面
1587562	1589542	去加这个子智能体啊
1593542	1597102	配置里面
1597102	1599422	打开这个配置
1599422	1601502	然后打开这个路径
1601502	1603842	这个路径下面
1603842	1607542	打开这个路径
1607542	1611102	这个路径下面有一个agents
1611102	1613582	咱现在没有那个文件奖啊
1613582	1616322	大家可以在全局的这个当前用户目的下面
1616322	1619442	去创建一个这个agents
1619442	1621142	agents文件奖
1621142	1624142	就跟咱们这个项目这里是一样的
1624142	1625262	项目这里
1625262	1628322	创建了这么一个agents
1628322	1629502	是吧
1629502	1631642	在这个里面
1631642	1633942	就是他有一个agents
1633942	1635302	然后在这个下面
1635302	1638162	我们建三个子agents
1638162	1639122	对吧
1639122	1641102	就帮你可以去同时干活
1641102	1642222	就这么意思
1642222	1646282	然后这些个文件结构
1646282	1647342	大家知道就行了
1647342	1648542	主要就是这两个
1648542	1650782	其他的话暂时都是用不上
1650782	1652542	有需要的话你让AI
1652542	1654842	帮你去加
1654842	1656442	就你有特殊需求提出来
1656442	1658702	他会自动的去帮你加这些参数
1658702	1661262	只要他能匹配到这些个需求
1661262	1664682	然后包括一些描述啊
1664682	1664982	是吧
1664982	1666262	然后大家你也可以
1666262	1668042	他就是用markdown的方式去写的
1668042	1670942	你看我们就正常跟写提示词一样
1670942	1672702	其实这个所谓的子整体的话
1672702	1674702	都是以提示词去驱动的
1674702	1676522	整个的一个整体干活
1676522	1677942	他就是参考了这个提示词
1677942	1679482	就是他的一个工作流程啊
1679482	1681302	所以这个里面的话
1681302	1683602	其实也很好理解啊
1683602	1685462	就是用TS调整大模型
1685462	1686522	然后做一个理解
1686522	1688922	然后在agents去做一个执行的
1688922	1693722	所以说这个里面啊
1693722	1695082	这就是它的一个规范
1695082	1699702	那么大家你也可以通过去改一些这个
1699702	1705482	用户级别的一些agents的一些规范
1705482	1709462	比如说我们可以做一个拆分是吧
1709462	1712202	有TiExplorer的
1712202	1713402	有Review的
1713402	1717082	然后就是可以做各种各样的一些处理的
1717082	1718462	就大家你可以自定义
1718462	1720802	就你想要什么一个真体的话
1720802	1722122	你自己去定义就可以了
1722122	1723162	再把规范写好
1723162	1725562	他就可以去干这个事情
1725562	1727162	兴起的话我们还可以在
1727162	1730162	这个用户
1730162	1732162	就是项目级别或者用户级别
1732162	1733402	去加一些什么呢
1733402	1735182	比如说他的最大线程
1735182	1737222	有可能他卡太卡
1737222	1738962	你比如说开十个线程
1738962	1739762	电脑太卡了
1739762	1741542	那你就改造三个
1741542	1742662	或者一个线程
1742662	1746122	就这个就是这个线程
1746122	1747202	线程越多的话
1747202	1748722	指线效率越高
1748722	1751022	但是的话性能也会下降
1751022	1753302	因为你的CPU运行资源
1753302	1754182	可能不够的时候
1754182	1755762	反正电脑会很卡
1755762	1758222	所以这个大家需要去考虑
1758222	1759322	应该设置多少
1759322	1762322	然后包括一些什么深度啊
1762322	1762662	是吧
1762662	1764542	各种各样的一些参数啊
1764542	1765362	比如说
1765362	1767242	你还可以针对不同的
1767242	1768762	这个子制整体
1768762	1769722	去配置模型啊
1769722	1771742	比如说有一些是写代码的
1771742	1774682	那你建议用5.3的这个Codex版本
1774682	1777362	有些是做那个分析的是吧
1777362	1780202	一些个项目嘛是吧
1780202	1781242	阅读代码的
1781242	1784762	那我建议你可以用这个5.5是吧
1784762	1787282	它比较适合你做一些推理分析的一些工作
1787282	1790602	写代码的话就用Codex版本会比较好一些啊
1790602	1794622	所以说这个子制中体里面
1794622	1797422	你其实可以加各种各样的一些配置啊
1797422	1798402	他的一些这个
1798402	1801462	描述啊
1801462	1801682	是吧
1801682	1802602	模型啊
1802602	1804462	然后包括他的一个
1804462	1805182	沙相模式
1805182	1805802	大家就可以改
1805802	1807382	我们刚刚给他说的是
1807382	1808002	沙相模式
1808002	1809242	你如果不写的话
1809242	1811842	他会默认用我们
1811842	1812862	子线程
1812862	1813802	就主线程
1813802	1816102	带过来的这个权限
1816102	1817282	如果大家配的话
1817282	1819202	就以你配的这个为准
1819202	1820762	包括模型的这个
1820762	1822282	推理的这个等级
1822282	1822602	是吧
1822602	1824302	大家也可以做一个search
1824302	1826122	就是子这种体
1826122	1828042	它是可以单独进行配置的
1828042	1829782	但是你如果没有配置的话
1829782	1834322	它会默认的用主线程的那个配置计程过来
1834322	1835382	这个是需要注意的
1835382	1837442	所以大家可以根据实际情况
1837442	1838322	你做一个调整
1838322	1840682	把这些个子制容体的一些参数调一调
1840682	1843282	然后让它就是没有什么问题
1843282	1847262	然后的话就是这套配置的话
1847262	1849022	我们还可以去加一些这个
1849022	1851422	不同的这个提示词是吧
1851422	1853682	就是你比如说你也不知道应该配什么的时候
1853682	1854342	你就提要求
1854342	1857302	比如说你说要子智能体具备一些
1857302	1858742	超级管理员
1858742	1860982	这个所有的权限都要给他
1860982	1863062	并且这个模型要清晃到5.3
1863062	1864922	然后退理等级用高
1864922	1867822	你就把这些个参数告诉他
1867822	1869542	让他自己去生成就可以了
1869542	1870862	你自己不需要改这东西
1870862	1872022	你让他去生成就完了
1872022	1873662	但是你要把需求描述清楚
1873662	1877142	然后我们还可以用子智能体
1877142	1878442	去处理一些这个
1878442	1880722	CSV的一些批样任务
1880722	1882162	那么这个
1882162	1883762	目前啊
1883762	1885722	还是一个实验性的一个能力
1885722	1886762	但后面啊
1886762	1888302	最新更新的版本
1888302	1889562	可能会把它变成一个
1889562	1890962	这个正式版本
1890962	1894642	那比如说我们现在要做数据分析工作
1894642	1894962	是吧
1894962	1897482	那现在你可以加一些这个子智能体
1897482	1899702	专门去用来去完成一些
1899702	1901382	CSV的一些数据啊
1901382	1903882	读取一些那个结果
1903882	1904242	是吧
1904242	1907002	然后我们可以去生成Worker
1907002	1908622	比如说
1908622	1911302	这个就比较适合一座审计类的一些工作
1911302	1915462	人家有一些他要去按行去审查文件啊
1915462	1916322	一些表格嘛
1916322	1916962	对吧
1916962	1918682	一些数据啊
1918682	1920042	一些PDF解析啊
1920317	1923117	或者是一些一组数据啊
1923117	1923337	是吧
1923337	1924997	或者PR啊等等的啊
1924997	1925837	或者等等的
1925837	1927997	一些个啊
1927997	1930137	需要分批去处理的
1930137	1932897	这个就比较适合于用这个子制整体啊
1932897	1935557	因为它可以一直工作嘛
1935557	1937417	可以开多个任务
1937417	1938377	然后的话就是
1938377	1941217	我们可以去指定CSV的一个路径
1941217	1942017	对吧
1942017	1944377	包括它的一个Worker啊
1944377	1945517	就干活的一个逻辑
1945517	1947177	它的一个细节是什么
1947177	1949397	并且的话就是它的一个
1949397	1951937	整个的一些逻辑啊
1951937	1954777	就你都可以去自定义啊
1954777	1957797	所以这个里面啊
1957797	1960477	它可以去调用各种各样的一些
1960477	1962017	这个Agent啊
1962017	1962637	去读取
1962637	1964217	你看像这里的话
1964217	1965257	我们就告诉他们
1965257	1967797	这个里面有一些CSV数据是吧
1967797	1970437	那你可以去做一些这个读取
1970437	1973297	但你也可以通过Codex的一个
1973297	1976577	非交互式的这个命令的方式去运行
1976577	1978797	这样的话就特别适合于
1978797	1980097	把它整合到一些
1980097	1981877	塞藥脚本里面去
1981877	1983157	因为我们以前
1983157	1985877	这个比如说在服务器上跑
1985877	1987457	都是跑塞藥脚本的是吧
1987457	1989377	塞藥脚本里面就不太好用
1989377	1990657	这种交互式的页面了
1990657	1991957	就是说你要进入到一个
1991957	1993577	TY的终端跟他对话
1993577	1995857	他更多的是希望用
1995857	1998077	这个非交互式的命令去运行
1998077	2001877	所以你直接给他输入输出结果就可以了
2001877	2002617	所以说
2002617	2005177	看大家的一个应用场景
2005177	2007197	如果说你想要把Codex
2007197	2009117	变成一个这个
2009117	2011557	后端的一个任务
2011557	2011777	是吧
2011777	2013777	就服务器端一个摄像脚本去运行的话
2013777	2015957	那你就用非交互式的方式去运行
2015957	2017497	如果说你只是自己
2017497	2020017	用TY的对话方式去使用的话
2020017	2021277	你就不需要加这个指令
2021277	2024097	所以看大家大家的一个使用情况
2024097	2028357	然后包括一些那个agents的一个最大线程数啊
2028357	2029477	然后他的一个时间啊
2029477	2029677	是不是
2029677	2036557	然后比如说我们还要做一些什么前端集成调试是吧
2036557	2039597	比如说一些前端兼容性的问题啊
2039597	2040237	是吧
2040237	2042437	然后回归测试啊
2043437	2046237	那么大家就单独可以去开发一些子生体
2046237	2047637	去什么呢
2047637	2048657	比如说操作流暖器
2048657	2049737	去做自动化测试
2049737	2050577	去做验证
2050577	2051897	然后生成一些色彩报告
2051897	2054237	并且的话可以去什么呢
2054237	2056457	去加一些这个配置
2056457	2056957	是吧
2056957	2059377	就是你可以做很多自动化的一些事情
2059377	2060997	就是在前端
2060997	2063357	你可以比如说针对浏览器做一些debug
2063357	2064077	是吧
2064077	2066897	然后去生成一些这个
2066897	2069097	性能的一些报告
2069097	2069997	截屏
2069997	2071257	然后分析
2071257	2074177	当前的这个UI上面有哪些问题
2074177	2075817	包括它的一个设计
2075817	2077577	设计我们可以通过截图来分析
2077577	2077957	是吧
2077957	2080577	那包括他整个的一些细节啊
2080577	2082657	应该是怎么样的
2082657	2083997	你都可以通过这个
2083997	2086317	子整体去实现了
2086317	2090297	所以说这个子整体能干的事情非常多啊
2090297	2091217	就是做一些
2091217	2094017	流水线工作的时候
2094017	2097517	需要大量的这个分批次啊
2097517	2100057	按照这个可以并行的去执行啊
2100057	2102177	比如这个是做UI修复的
2102177	2106017	上面是做浏览器bug的一个调试的是吧
2106017	2108957	那你就可以去做各种各样的一个场景
2108957	2112597	那这里面我给大家演示一下
2112597	2116597	就首先是CSV批量数据是吧
2116597	2119697	那这里面比如说我先建个文件夹
2119697	2124197	我在这里面建一个文件夹
2124197	2125857	叫做CSV
2125857	2129037	那我让Codex帮我生成一些数据
2129037	2134857	CSV
2134857	2139857	然后我现在切换到这个目录里面去啊
2139857	2149737	cssv
2149737	2156597	然后帮我生成
2156597	2160757	我们让他想做一个什么事情呢
2160757	2165997	比如说我现在想去做一个
2165997	2169757	先生成12个月的一个
2169757	2173137	这个比如说产品的一个销售的一个情况
2173137	2173517	是吧
2173517	2176457	然后再把它会会总成一个年度的一个报告
2176457	2177297	啊
2177297	2178537	我们做这样一个情况
2178537	2180137	这个实现啊
2180137	2183577	帮我生成1到12月份
2183577	2188237	你就生成1到12月份
2188237	2189917	嗯
2189917	2194617	销售数据的CSV
2194617	2196937	视力
2196937	2203557	电子产品吧
2203557	2206537	电子产品销售数据的CSV
2206537	2207957	文件
2207957	2212257	总计12个文件
2212257	2215417	要求
2215417	2218297	数据
2218297	2220897	尽量真实
2220897	2222837	尽量真实一点
2222837	2226877	这个就是我们的需求
2226877	2227957	这是我们的需求
2227957	2230297	然后我现在进入到Codex
2230297	2238557	我先让他把CSV数据给他生产出来
2238557	2239477	生产出来之后
2239477	2243337	然后我让他并行的去处理12个月的数据
2243337	2248257	最终我关注的是年度的这个销售数据的一个报告
2248257	2250017	这个报告的话
2250017	2252777	我想让它生成这个
2252777	2254717	然后看一下
2254717	2256297	生成一个PDF吧
2256297	2257197	区分一下
2257197	2258557	就生成PDF数据吧
2258557	2260797	这样大家会看到更加清晰一些
2260797	2265377	首先先生成
2265377	2266837	先生成完之后的话
2266837	2268217	然后再去处理
2268217	2272817	这个就是我们想
2272817	2274917	并行的去处理一个cell数据
2274917	2277517	这只是一个案例
2277517	2278997	就是大家你可以以后
2278997	2280917	不管是CSV数据也好
2280917	2282477	还是其他的各种各样的文件
2282477	2284917	只要他需要分批处理的
2284917	2286877	并且可以支持并且处理的
2286877	2289597	然后需要做一个汇总的这种场景
2289597	2293897	就特别适合用子智能体去做一个优化
2293897	2295577	就提高它的一个效率
2295577	2298917	所以这一块是大家可以去关注的一个点
2307517	2310437	所以他生成完之后的话
2310437	2312177	我们再来做一个汇总啊
2312177	2315037	等下会让他开发一个SysV的一个
2315037	2317257	这个Worker是吧
2317257	2321217	然后再去分析数据啊
2321217	2324537	其实我现在可以同步开发
2324537	2327637	我再切换到一个这个里面去啊
2327637	2330017	我现在一边生成数据
2330017	2332457	一边去切换到这个
2332457	2334077	让他去开发这个agency
2334077	2338317	比如说agents
2338317	2342837	csv
2342837	2345377	比如说
2345377	2348137	我们进入到codex
2348137	2352777	帮我
2352777	2354917	你看12个月的数据基本上快生成完了
2354917	2355177	是吧
2355177	2359837	我首先让他开发一个这个subagents
2359837	2364757	帮我配置一个
2364757	2373477	CSV数据分析的子智能体
2373477	2376837	然后啊
2376837	2381317	能体和
2381317	2384757	CSV
2384757	2389997	想一下
2389997	2392597	一个是做数据分析的
2392597	2397097	就这个只是指分析给出这个结论是吧
2397097	2399177	指正体和
2400413	2402313	或者说怎么叫
2402313	2404573	CSV
2404573	2407593	数据
2407593	2412873	数据汇总
2415413	2444093	CSIVE年度销售数据贵总生成PDF报告的
2445413	2448893	子智能体
2448893	2456953	我们就分两类吧
2456953	2459153	一类叫数据分析
2459153	2463313	总结啊
2463313	2464033	一个叫总结
2464033	2465933	一个叫这个汇总啊
2465933	2466613	总结这里
2466613	2469893	总结我们就是输出txt啊
2469893	2472253	报告
2472253	2476293	和去生成PDF汇总报告
2476293	2478113	就是两种场景
2478113	2480613	我们都给它去加一下
2480613	2487413	就最后要看到两个文件
2487413	2489393	一个是用来去生成TXT的
2489393	2491233	一个是用来去生成PDF的
2491233	2493933	这个就是我们的需求
2493933	2495273	然后数据来源
2495273	2496513	就这些CSV数据
2496513	2499933	所以我们等一下来看一下
2499933	2503453	这两个Worker的一个工作逻辑
2529933	2538013	好
2538013	2538813	我们等它生成
2538813	2541893	然后我们首先来看一下这个数据啊
2541893	2543213	1月份
2543213	2544693	2月份
2544693	2545273	3月份
2545273	2546133	4月份
2546133	2548273	这个数据看上去没什么问题啊
2548273	2550253	都是一些电子产品的销售数据是吧
2550253	2552473	然后我们等一下看一下
2552473	2554813	这个生成出来的报告是什么样的
2554813	2557753	然后现在它在开发这个
2557753	2559233	Subagency
2559233	2563113	这里需要一点时间
2563113	2575993	他帮我去写了一个agents.md文件
2575993	2579313	因为我之前这个有一套规范
2579313	2581673	我定义了一套全局的ddt规范
2581673	2585193	所以他把这个领域的这个规范
2585193	2587433	也应用到了C4V的这个分析里面去了
2587433	2590333	其实是不需要这个规范的
2590333	2592433	但是我因为我当时写了全局规范了
2592433	2593793	所以他也把它考虑进去了
2593793	2595833	这个也没关系
2595833	2599873	我们只要看那个subagents能不能生成就完了
2599873	2605153	你看TOM语法教验通过
2605153	2606693	目录也预计生成
2606693	2607213	然后
2607213	2609653	他
2609653	2611133	看一下
2611133	2613573	这个子这张体
2617433	2620273	在Codex目录下面
2620273	2621593	有一个agents
2621593	2623313	agents下面生成了这个
2623313	2625153	首先是一个tom文件
2625153	2627653	你看这次的是一个tom文件的方式
2627653	2629953	它不是一个markdown了
2629953	2631433	就这个
2631433	2634353	我看一下应该也是可以的
2634353	2635273	tom文件
2635273	2638453	描述
2638453	2641713	然后包括一些这个细节啊
2641713	2642013	是吧
2642013	2643773	都是可以的
2643773	2646613	就他用markdown跟那个都是可以执行的
2646613	2649533	这个tome文件也是ok的
2649533	2650613	咱们都是配置文件
2650613	2652293	工作方式
2652293	2653453	然后年度汇总
2653453	2655093	这个是pdf的是吧
2655093	2656913	这是tst的
2656913	2659053	你看它的报告就不太一样了
2659053	2659313	是吧
2659313	2661253	现在我们就让它干活了
2661253	2668373	帮我生成
2668373	2678853	pdf报告
2678853	2680833	你就这么说
2680833	2684293	帮我分析当前所有
2684293	2688953	csv文件
2688953	2691133	然后输出
2691133	2694593	这里我们提一下
2694593	2697973	然后调用子智能体
2697973	2706933	生成TXT报告和PDF报告
2706933	2709273	好就完事了
2709273	2712193	然后这两个自动体
2712193	2714113	我们等一下看一下它的一个工作逻辑
2714113	2715973	现在还正在执行
2715973	2718773	就看一下它两个可以并行处理
2718773	2721973	同时生成这个TXT跟PDF
2727973	2757173	它会首先去分析这个SysV
2757173	2758633	里面的一些数据
2758633	2761333	然后包括一些任务
2761333	2764533	看一下这个agents有没有在工作了
2764533	2766293	agents
2766293	2769273	你看现在有一个在工作了
2769273	2771993	但是还没定性是不是worker
2771993	2773533	因为他没写文件了
2773533	2774353	他在做分析
2774353	2777173	所以这个是一个默认的
2777173	2778893	你看这个agents县层里面
2778893	2779733	他还在工作
2779733	2783493	我现在已经切换到这个直升体里面了
2783493	2785373	他现在还在执行
2785373	2788033	所以还看不出来它的一个类型
2788033	2789953	你看现在是不是就有了
2789953	2791213	当前的
2791213	2794053	你看下面两个再生成PDF跟Word了
2794053	2795533	跟这个DXT了
2795533	2797373	所以它是Walk了
2797373	2799613	就是切换到这个里面去
2799613	2801633	切换到这个子智能体里面
2801633	2804373	它现在再读取一些工具了
2804373	2807193	你看这个是读
2807193	2809393	这个是生成PDF的
2809393	2811533	我们再切换到另外一个
2811533	2814233	这个是看一下
2814233	2817433	这个就是txt了啊
2817433	2823233	就一个txt一个是这个pdf啊
2823233	2825473	然后还有一个这个是干嘛的
2829433	2831133	这个是之前的
2831133	2834393	这是之前去生成这个文件的
2838593	2839573	直读完成
2839573	2839893	没有
2839893	2843973	这是之前去生成agents的那些个
2843973	2844973	这个县城啊
2848373	2850913	目前你看这里有一个绿色的啊
2850913	2854013	绿色的就是正在工作的啊
2854013	2855313	活动的
2855313	2858633	然后这个白色的就是聪明已经关掉了啊
2858633	2861673	所以我们主要关注这两个worker就行了
2861673	2866773	一个生成pdf的一个生成这个txt的啊
2866773	2869613	所以他主要关注这两个就行了
2869613	2872633	啊在这个下面我们会看到他整个的一个报告
2872633	2873633	是吧
2873973	2874614	好
2876314	2877154	那等他跑完
2877154	2877614	跑完之后
2877614	2878814	我们就能看到那个报告了
2889614	2897754	编码入口修好了
2897754	2900394	然后再验证这个PowerShell到Python
2900394	2901854	可以保持UTF刚报
2901854	2905034	就是它这个中间会帮你去考虑一些编码问题
2905034	2907574	如果说你有一些编码问题的话
2907574	2910074	这个时候它可能会有一些问题
2910074	2912994	所以这个细节大家需要考虑一下
2912994	2918194	这里面有些进程它可能报错了
2918194	2919434	那你要去看一下
2919434	2921674	如果他跑了很久的话
2921674	2922634	你可以关注一下
2922634	2924474	当然他都会帮你去处理
2924474	2927474	只是这个时间可能会耗费比较久
2927474	2936234	你看报告已经写出来了
2936234	2937614	然后他会复合一下
2937614	2941134	但是他没写文件啊
2941134	2942754	他已经输出了
2942754	2943894	看一下
2943894	2945574	TXT的已经写完了啊
2945574	2947314	你看这个TXT的给了一个报告
2947314	2950374	总的一个情况
2950374	2950694	是吧
2950694	2951774	销售数据啊
2951774	2952794	品类啊
2952794	2953014	是吧
2953014	2953894	品牌啊
2953894	2956114	应该是不是都帮你分析的清清楚楚的
2956114	2956714	渠道啊
2956714	2957114	是吧
2957114	2959314	整个的都帮你分析了
2959314	2961094	然后还差一个PDF的
2961094	2963174	PDF的慢一点啊
2963174	2964834	因为他要去
2964834	2966074	叫PDF的一些库
2966074	2968854	然后我们看一下这个agency
2968854	2971054	有一个是已经终结了
2971054	2972934	但这里还在work
2972934	2975454	看一下这个
2975454	2977054	这个还在写啊
2977314	2980774	这个生日PDF的会稍微慢一点
2980774	2982674	因为他可能还要画一些图表啊
2982674	2984534	所以就慢一点
2984534	2988834	那这个数据还是挺完善的是吧
2988834	2990114	帮我们把一些细节问题
2990114	2992194	其实都考虑的非常清楚了
2992194	2994894	所以大家看到这个报告的时候啊
2994894	2997134	已经是他里面做了非常多的总结归纳了
2997134	3001054	然后这个PDF会稍微慢一点
3001054	3007174	所以我们回过头再来看一下
3007174	3008574	在这个文档里面
3008574	3009714	这里就可以提到
3009714	3011574	就这些个点啊
3011574	3013654	一些C4V的这些个数据的话
3013654	3016554	大家可以用在各种各样的场景里面啊
3016554	3019014	不要局限于这个C4V这个场景啊
3019014	3021314	你可以把它用到各种啊
3021314	3024014	包括我们前面给他讲的那个代码分析
3024014	3025754	也是一个比较好的场景是吧
3025754	3028054	就是这种可以并行的
3028054	3029714	分批量的去跑的任务
3029714	3031574	你都可以交给这个
3031574	3034334	Codex的一个subagents
3034334	3036374	让他专门去写一个字笼体
3036374	3038374	去跑这个任务
3038374	3039254	这样的话
3039254	3040974	它可以并行的去处理
3040974	3042234	它的效率会很高
3042234	3044014	所以的话
3044014	3045754	最终啊
3045754	3047074	就生成这个报告的话
3047074	3048234	哎
3048234	3049334	这个效果
3049334	3051614	效率就比较高啊
3051614	3054194	然后这个前单调受的话
3054194	3056414	也是一个比较好的场景啊
3056414	3057534	就是大家可以把这个
3057534	3059474	整合到不同的这个
3059474	3063334	一些自动化测试啊
3063334	3063674	是吧
3063674	3065314	包括一些后端接口啊
3065314	3066294	比如说我后端的接口
3066294	3066974	代码写完了
3066974	3069214	我现在想通过CURL
3069214	3071334	单独我开一个
3071334	3072514	这个直升体
3072514	3073614	想用CURL
3073614	3074954	把整个的一个测试
3074954	3075734	都给它跑通
3075734	3076974	跑通
3076974	3078274	各种的案例测试
3078274	3079354	没问题之后的话
3079354	3081314	咱们再来去验证
3081314	3082514	这个里面的逻辑
3082514	3084154	有没有问题
3084154	3084854	是吧
3084854	3088714	就是代码一写完
3088714	3090094	自动化测试
3090094	3092694	就可以开始做了
3092694	3094614	这个就是可以并行的
3094614	3095274	包括一些
3095274	3097034	文档是吧
3097034	3098074	文档生成啊
3098074	3099234	一些逻辑啊
3099234	3100454	你就可以去生成
3100454	3102174	甚至你有些现成
3102174	3103854	他可以去协作啊
3103854	3105374	就你可以一直让他等在那里
3105374	3106634	比如说当大码开发完了
3106634	3108014	马上就启动一个
3108014	3109854	自动化测试的一个现成
3109854	3111194	自动化测试完之后
3111194	3112434	马上就生成一个
3112434	3113874	测试报告的一个现成
3113874	3115394	就让他给启动了
3115394	3118214	所以大家可以在这个里面
3118214	3120234	加各种各样的一个场景啊
3120234	3122734	其实啊
3122734	3124374	都可以做很多事情
3125274	3127514	然后pdf看有没有生成啊
3128734	3130214	还没有生成这个比较慢啊
3130214	3133434	因为它要涉及到非常多的代码逻辑啊
3135034	3136674	可能还会有一些编码报错
3136674	3138634	因为他要保证不会出现乱码
3139274	3141114	好大家看这个pdf已经生成了
3141714	3142914	我看一下有没有问题
3146434	3149714	已经生成成功指标也跑出来了啊
3149714	3150414	看一下
3155274	3158074	大家看
3158074	3159374	这是他跑出来的这个数据
3159374	3162774	这个效果还是不错的
3162774	3165974	但是这个字体有点没设计好
3165974	3168534	包括一些规范阅读
3168534	3170774	你看这个图表都是给咱们画出来的
3170774	3172314	还是比较完善的
3172314	3174094	产品维度等等的
3174094	3175034	还不错
3175034	3178494	默认没有加任何节日时优化
3178494	3180654	能够做到这种程度还是比较完善了
3180654	3182574	所以它的效果也算OK
3182574	3187734	所以这个里面就是大家可以做很多的这种优化
3187734	3190594	一些智能体等等的
3190594	3191114	是吧
3191114	3193214	我们就可以做各种各样的调优
3193214	3196254	包括一些bug的一些修复
3196254	3196874	是吧
3196874	3198894	然后我们都可以去做一些处理
3198894	3200594	那这个的话
3200594	3202954	回头大家可以去验证一下
3202954	3204794	你可以把它用到不同的场景里面去
3204794	3207454	一个是做CSV的这个数据分析是吧
3207454	3209274	一个是做代码的一个审查
3209274	3212154	包括前端的一个机身调试测试
3212154	3214054	或者后端的一个自动化测试
3214054	3218114	大家都可以基于这个子智能体去做一个实战
3218114	3220214	回头我们可以去看一下