一、一件事，两个窗口

派一个子智能体，其实是开了第二个对话：它有自己的系统提示、自己的窗口、自己的一串工具调用。 它在自己那边读文件、跑命令、试错、改方案——这些过程一个字都不进主窗口。 干完之后，它把结果写成一一段话交回来。主窗口收到的只有这一段。

所以主窗口看到的是：一条指令出去，一条结论回来。中间那三十次工具调用它根本不知道发生过。 这就是「独立上下文」的全部含义。不是「更聪明的助手」，是一段隔离出来的工作区。

二、演示里那两个数

主窗口自己读三十个文件：峰值八千，累计十八万五，而且前十三个被挤掉。 派出去：主窗口峰值一千三，累计也是一千三——就两轮对话，指令六十二 token、回传七十。 一千三对八千，这个差距不是「优化了百分之多少」，是量级不同。

关键在于委派之后，主窗口那个数跟任务规模无关了：读五个文件和读六十个文件，主窗口都是同一千三。 这件事的意义在「后面还能接着干」。主窗口还剩六千多空间，用户可以继续问、继续改。

三、省的是主窗口，不是总账

这里必须说清一件事：派出去不省钱。子智能体自己那边也要读三十个文件，它也有窗口、也会满、也要重发。 演示里两边加起来十八万六千九百，比直接做还多一千三。 多的就是主窗口那一份系统提示，加上一来一回那两轮。 所以「派出去省 token」这个说法是错的。总账上它略贵，规模小的时候还贵不少（4.6 节算）。

它买的是主窗口的干净。主窗口干净了，同一段会话就能装下更多轮后续工作。 换个说法：token 是钱，主窗口是工位。委派不省钱，它腾工位。

四、干净体现在哪

直接做的那一路，三十个文件读完，主窗口里塞满代码片段。 这时候用户问「刚才第三个文件那个问题怎么改」，模型得在八千 token 里翻——而第三个文件早被挤掉了。 派出去的那一路，主窗口里只有一条结论。问同样的问题，它知道去查结论、或者再派一次。 差别不只是「能不能答」，还有「答得稳不稳」：窗口里内容少，指代就不容易错。

还有一层：主窗口里的历史会被后续每一轮重发。塞进去的代码片段，在接下来二十轮里每次都要付一次钱。 这才是委派真正的收益——它把「一次性的过程」变成了「不进历史的过程」。

五、它的代价也得说清

第一，多了一层「它可能理解错」。主窗口自己读，读到什么就是什么； 派出去，你只能看到它的结论，看不到它是不是漏了。 第二，回执写不好就白派。 它回一段散文，主窗口还得再读一遍、再判断一遍，等于把省下来的活做回去了（4.7 节）。 第三，它不知道的规矩它不会问。 项目里「测试必须放 tests 下」这种约定，不写在派它出去的指令里，它就按通用的做法来（4.5 节）。

所以委派不是「无脑外包」，它是一次接口设计：指令写什么、权限给什么、回执要什么格式， 三件事都得当场定。

六、动手 Demo：同一个任务，直接做和派出去做，差在哪

还是审三十个文件。两路：主窗口自己一路读到底，或者派一个子智能体去读、只收回结论。 比较主窗口峰值、主窗口累计、以及覆盖面——注意「覆盖面」这一列才是真正的痛点。

# 直接做：主窗口一路涨
cur = min(WIN, SYS_TOK + i * FILE_TOK)
direct_peak, direct_tot = max(direct_peak, cur), direct_tot + cur

# 派出去：主窗口只有两轮——发指令、收结论
main_peak = SYS_TOK + tokens(brief) + tokens(back)

实跑输出：

--------------------------------------------------------------------
同一个任务，直接做和派出去做，差在哪
--------------------------------------------------------------------

  还是审三十个文件。这次分两路：一路主窗口自己读，一路派一个子智能体去读。

  ① 主窗口自己读：峰值和累计
  --------------------------------------------------------------------
  峰值 8000，累计 185600，而且窗口里只剩最后 17 个——前面 13 个的结论拿不到。

  ② 派子智能体：主窗口只发指令、只收回结论
  --------------------------------------------------------------------
| 做法 | 主窗口峰值 | 主窗口累计 | 覆盖面 |
|---|---:|---:|---|
| 主窗口自己读 | 8000 | 185600 | 前 13 个丢了 |
| 派子智能体 | 1332 | 1332 | 三十个全覆盖 |

  主窗口峰值从 8000 降到 1332。指令 62 token、回传 70 token，一来一回只花了 132。

  ③ 省的是主窗口，不是总账
  --------------------------------------------------------------------
  子智能体自己那边也要读三十个文件，它也有窗口、也会满、也要重发。它那边的峰值 8000、累计 185600。
  两边加起来 186932，比直接做还多 1332。
  多出来的就是主窗口这一路自己的系统提示，加上一来一回那 132。
  ! 所以子智能体不是「省钱工具」。它买的是主窗口的干净：主窗口只留结论，过程全在外面。
  这件事的价值不在 token，在「后面还能接着干」。

  ④ 干净体现在哪
  --------------------------------------------------------------------
  直接做的那一路，三十个文件读完，主窗口里塞满了代码片段。
  接下来用户问一句「刚才第三个文件那个问题怎么改」，
  模型得在八千 token 里翻——而第三个文件已经被挤掉了。
  派出去的那一路，主窗口里只有一条结论和一张附表。问同样的问题，它知道去查附表，或者再派一次。
  这就是「只回结论不回过程」的全部意义：主窗口是稀缺资源，过程是廉价资源。
  把过程留在外面，主窗口才能继续装新东西。

①直接做那一路：峰值八千、累计十八万五，而且窗口里只剩最后十七个——前面十三个的结论拿不到。 ②派出去那一路：主窗口峰值一千三，累计也是一千三。 指令六十二 token、回传七十，一来一回只花了一百三十二。 一千三对八千不是百分比优化，是量级差别。 而且这个数跟任务规模无关——读五个和读六十个，主窗口都是同一千三。 ③这一段是全节最该记住的：子智能体自己那边也要读三十个文件，它也有窗口、也会满、也要重发。 两边加起来十八万六千九，比直接做还多一千三——多的就是主窗口那一份系统提示，加上一来一回那两轮。 所以子智能体不是省钱工具。它买的是主窗口的干净：主窗口只留结论，过程全在外面。 这件事的价值不在 token，在「后面还能接着干」。 ④干净体现在哪：直接做那一路，问「刚才第三个文件那个问题怎么改」，模型得在八千 token 里翻， 而第三个文件已经被挤掉了。 派出去那一路，主窗口里只有一条结论，问同样的问题它知道去查结论、或者再派一次。 还有一层没写在表里：主窗口里的历史会被后续每一轮重发。 塞进去的代码片段，在接下来二十轮里每次都要付一次钱。

30 秒实验

1. 把回执从七十 token 写到七百，重跑第 ② 步。主窗口峰值变成多少？这说明「只回结论」这句话值多少？
2. 把任务改成读五个文件，重跑两路。派出去还划算吗？为什么？
3. 假设主窗口里已有二十轮历史（每轮平均三百 token），重跑第 ① 步。 直接做那一路还能读几个文件就满了？

常见误区

1. 以为子智能体是「省 token 的工具」。总账上它略贵，规模小的时候还贵不少；它省的是主窗口。
2. 以为派出去之后主窗口就「什么都不知道」。 主窗口知道回执里写的那些，只不过不知道过程——这正是设计意图。
3. 让子智能体把过程也写回来（「我先看了 A，然后看了 B……」）。那等于把噪声请回主窗口，白派一次。
4. 以为子智能体天然懂项目规矩。它不知道的规矩不会问，只会按通用做法来。
5. 把委派当成「无脑外包」。它是一次接口设计：指令、权限、回执格式三样都得定。

本质清楚了，下一节看怎么把这么一个子智能体定义出来：字段就四个，但少一个就变味。

• ☐ （本篇完，下一篇 4.3 子智能体的定义与配置）

相关笔记

• 窗口的困境：为什么装不下
• 定义与配置：四个字段定一个子智能体
• Claude Code 橙皮书 · 索引
• 🐎 Claude Code 实战 · 索引