须弥芥子

想象一张网。

不是互联网那种——是一张铺满整个宇宙的网，每一个结点上挂着一颗宝珠。每颗宝珠的表面完美映照出所有其他宝珠的影像。而被映照的那些宝珠，表面上也映着这颗宝珠——于是你在每一颗珠子里看到无穷层嵌套的倒影。

这是华严经里的因陀罗网（Indra’s Net）——大约公元三世纪成文，由唐代法藏系统化阐释。它不是一个装饰性的宗教意象。它是人类已知最早的对”部分包含整体”这一结构性质的系统表述之一。

须弥山是佛教宇宙观里最大的山。芥子是芥菜的种子，比芝麻还小。须弥山放入芥子，芥子不变大，须弥不变小——尺度变了，结构完整保留。

这两段经文出自不同的经典，表达同一个结构直觉。因陀罗网说”每个局部映射整体”——网中任取一珠，便可见全网。须弥芥子说”最大的东西能装进最小的容器而不失真”——容器的尺度与内容的结构无关。

两种说法，一个强调映射关系，一个强调尺度无关性。合在一起，它们勾勒出一种结构性质的轮廓：整体的信息存在于每一个局部之中，而这种存在不因尺度的缩放而损失。

这不是神秘主义的修辞。它是一个关于结构的精确陈述——只是用佛学的语言说出来的。

一千七百年后，一位数学家在完全不同的路径上，撞见了同一件事。

海岸线有多长？

1961 年，英国气象学家 Lewis Fry Richardson 去世后，留下一批未发表的手稿。里面有一个奇怪的发现：他在研究国家边界长度和战争概率的关系时注意到——同一条海岸线，不同的数据来源给出不同的长度。

不是测量误差。是系统性的：量具越细，海岸线越长。

你拿一把 200 公里的尺子沿英国海岸线量，得到一个数。换成 100 公里的尺子，能捕捉到更多的海湾和岬角，总长度变大了。换成 50 公里，更多细节被纳入，更长。25 公里，12 公里，6 公里——每缩短一次量具，总长度都在增加，而且没有收敛的趋势。

理论上，如果你的尺子无限细，英国海岸线无限长。

这挑战了一个深层假设：我们默认一个物理对象的长度是一个确定的数。桌子 1.2 米，房间 5 米，公路 300 公里——这些数字不会因为你换把尺子就变。但海岸线不一样。它的长度取决于你测量的精度，而且不收敛到一个极限值。“英国海岸线有多长？“这个问题，在经典测量框架里没有答案。

1967 年，Benoit Mandelbrot 在 Science 上发表了一篇标题直白到近乎挑衅的论文：How Long Is the Coast of Britain?（英国海岸线有多长？）。他从 Richardson 的数据出发，给出了一个数学框架：海岸线的长度不收敛，因为它不是一维的光滑曲线——它的维度是一个分数。

英国海岸线的分形维数（fractal dimension）D ≈ 1.25。比一条直线复杂——直线是 1 维的；但又没有复杂到填满一个平面——平面是 2 维的。它落在 1 和 2 之间。

这里有一个关键直觉：海岸线的统计特征在不同尺度上是一致的。你站在卫星照片前看到的锯齿状轮廓，和你站在悬崖边俯视脚下岩石时看到的锯齿状轮廓，形状不同，但”锯齿的统计规律”是一样的。

放大，新细节出现。再放大，又有新细节。每一层的细节，统计上长得像上一层。

这叫统计自相似性（statistical self-similarity）——不是精确复制，而是统计分布上的尺度不变。

自然界里到处都是：河流的分支网络、肺部的支气管树、闪电的分叉路径、山脉的轮廓线。你在一个尺度上观察到的模式，换一个尺度还能看到。

但自然界的自相似是近似的、统计的。有没有一种形状，自相似到数学意义上的精确？

Koch 雪花

1904 年，瑞典数学家 Helge von Koch 构造了一条曲线。

取一个等边三角形。把每条边三等分，在中间那段上向外搭一个小等边三角形，然后去掉底边。现在每条边变成了四段，每段长度是原来的三分之一。对新的每条边重复同样的操作。再重复。再重复。无限次。

结果是一片”雪花”——边界无限精细，每一段边缘都是整体的缩小版。

两个性质让 Koch 雪花成了分形的教科书样本：

有限面积，无限周长。 面积在每次迭代中只增加一点点，总量收敛到原始三角形面积的 8/5。但周长在每次迭代中乘以 4/3——无限迭代后趋向无穷。一个有限大小的形状，边界却无限长。

精确自相似（exact self-similarity）。 取雪花边缘的任何一段，放大 3 倍，你得到的形状和整条边完全一致。不是”统计上类似”——是数学上全等。部分就是整体的精确缩放。

Koch 雪花让一件事变得清晰：自相似结构不需要复杂的生成机制。一条简单的规则——“把每条边的中间三分之一换成一个凸起”——无限重复，就够了。

复杂性不是被设计出来的。它是被迭代出来的。规则的简单性和结果的复杂性之间，存在着巨大的落差——而填补这个落差的，是重复。

z → z² + c

把这个想法推到极致。

取一个复数 c。从 z = 0 开始，反复计算 z → z² + c。如果这个序列不发散（不飞向无穷大），就把 c 对应的点涂黑。对复平面上每一个 c 都做这件事。

六个字符的规则。画出来的图形叫 Mandelbrot set（曼德博集合）。

它的边界是数学中已知最复杂的形状之一。放大边界的任何区域，你会看到新的结构——旋涡、触须、微缩的集合副本。再放大，还有。无限放大，无限新细节。而且——这些细节里反复出现整体形状的变体。部分回响着整体。

注意两件事。

第一，Koch 雪花的规则还涉及几何操作：“取中间三分之一，搭三角形”。Mandelbrot set 的规则连几何都不涉及——它只是一个代数迭代：z² + c。没有人”设计”了那些旋涡和触须。它们是同一条规则反复作用于自身的产物。

第二，Mandelbrot set 的自相似既不像 Koch 雪花那样精确（每个局部是整体的完美缩放），也不像海岸线那样只是统计近似。它是一种更微妙的第三类：放大后出现的”小 Mandelbrot”和母体形状相似但不全等，每一个都带着自己独特的装饰细节。相似，又不完全相同——如同主题与变奏。

分形不是被设计出来的。分形是简单规则反复施加的涌现结果。

这句话值得停一下。Koch 雪花是一条替换规则反复执行。Mandelbrot set 是一条代数规则反复执行。海岸线是海浪和地质力在不同尺度上反复侵蚀的结果。三者的复杂性都不存在于规则本身——规则极其简单。复杂性存在于迭代的积累之中。

从庙堂到数学

回到开头。

须弥芥子说：最大的结构能装进最小的容器，尺度变了，结构不变。因陀罗网说：每一个局部映射出整体，整体存在于每一个局部之中。

Mandelbrot set 说：放大边界的任何局部，你会看到整体形状的回声。Koch 雪花说：取任何一段边缘，放大到和整体同样大小，二者全等。

一个是佛学直觉，一个是数学发现。路径完全不同，描述的是同一种结构性质：部分与整体之间存在结构回声（structural echo）。

这里需要一个诚实的边界声明。

这个系列讨论的是 agentic systems 的心智模型。我们不是在说 agentic systems 是数学意义上的分形——它们不满足严格自相似性的数学定义，也没有可精确计算的分形维数。这是一个类比，不是一个等式。

我们在说的是：分形的核心直觉——部分与整体之间的结构回声——提供了一个有工程价值的思维透镜。一个 agent 内部的”观察-推理-行动”循环，一个 multi-agent 编排层面的”分发-执行-汇总”流程，一个 agent 网络层面的涌现协作模式——当这些不同尺度上的结构呈现出相似的特征时，这不是巧合，而是值得追问的线索。

但在追问工程意义之前，有一个更基本的问题。

本文看到的每一个分形——Koch 雪花、Mandelbrot set、海岸线——都有一个共同特征：它们不是被一次性设计出来的，而是一条简单规则反复施加于自身的结果。迭代（iteration）才是生成机制。

那么，迭代本身到底是什么？什么条件下简单规则的反复施加会生成结构，什么条件下只会生成噪声？

概念与实体

本文涉及的核心概念与实体，在项目知识库中有更详细的资料：

• 因陀罗网 — 华严经中的宇宙结构隐喻：每个局部映射整体，本文的开篇意象
• 海岸线悖论 — Richardson 的发现：测量单位越小，海岸线越长，本文引入分形维数的入口
• 分形维数 — 非整数维度：量化不规则形状的空间填充程度
• 统计自相似性 — 自然界分形的特征：不同尺度上统计分布一致
• 分形架构 — 自相似性在软件工程中的结构映射
• 华严经 — 因陀罗网意象的原始经典
• Benoit Mandelbrot — 分形几何学创始人，海岸线论文与 Mandelbrot set 的提出者
• Lewis Fry Richardson — 海岸线悖论的经验发现者

递归：复杂性的生成器

自相似确实无处不在——哲学里有须弥芥子，数学里有 Koch 雪花和 Mandelbrot 集合，自然界的海岸线和蕨叶也各自重复着自己的形状。

但”它存在”和”我们理解它为什么存在”是两件事。

一棵蕨和一条雪花曲线之间隔着几十亿年的进化和完全不同的物理过程，凭什么它们最后长出了同一种结构？自相似不是某个特定领域的特产——它在数学、生物学、计算科学中独立出现，每一次都没有从别的领域”借”来这个模式。这就逼出了一个更尖锐的问题：是什么机制让自相似结构反复涌现？

数学：迭代函数系统

1968 年，匈牙利裔植物学家 Aristid Lindenmayer 在《Journal of Theoretical Biology》上发表了一篇论文，提出了一种形式文法来描述丝状生物（如蓝绿藻）的细胞生长模式。他的出发点不是几何学，而是发育生物学——他想要一种能够精确描述”一个细胞如何分裂成两个，两个如何分裂成四个”这一过程的数学语言。

这套系统后来被称为 L-system，它的核心思想简洁得近乎粗暴：给一条规则，反复执行。

公理：    F
规则：    F → F[+F]F[-F]F

注意这里发生了什么：一条替换规则，作用于自身的输出，重复四五次之后，一个肉眼可辨的树形结构从纯粹的字符串操作中浮现出来。规则本身不包含任何关于”树”的知识——没有”主干”、“枝干”、“树冠”的概念，只有”把 F 替换成一个分叉模式”。但当这条规则被递归地施加于自身的产物，宏观结构就从微观规则中涌现了。

Lindenmayer 本人大概没有想到，他为描述蓝绿藻发育而发明的这套文法，后来会成为计算机图形学中生成虚拟植物的标准工具。改变规则中的角度和分叉模式，你可以生成灌木、蕨类、花朵——所有这些形态都来自同一个机制：规则作用于自身的输出。

Mandelbrot 集合的生成逻辑在本质上完全一样，只是换了一个数学领域。取一个复数 $c$，从 $z_0 = 0$ 开始，反复计算：

$z_{n+1} = z_n^2 + c$

观察 $z$ 的轨迹是发散到无穷大，还是被束缚在有限范围内。不同的 $c$ 值给出不同的命运——有的点迅速逃逸，有的永远被困在原地附近，有的在边界上做出极其复杂的运动。所有不发散的 $c$ 的集合，就构成了那个著名的黑色图形。

一条迭代规则。不同的初始条件。结果是一个在任意放大倍率下都涌现新细节的无穷复杂结构。你在 Mandelbrot 集合的边界上放大一万倍、一亿倍，看到的不是像素和模糊——而是全新的、精致的、与整体结构遥相呼应的图案。小 Mandelbrot 集合的复制品散落在边界的各个角落，它们周围又环绕着更小的复制品。$z^2 + c$ 这五个字符编码的信息量是有限的，但这条规则迭代产出的结构复杂性是无限的。

L-system 和 Mandelbrot 集合来自完全不同的数学分支——一个是形式语言理论，一个是复动力系统。但它们指向同一个结论：简单规则 + 重复迭代 = 自相似结构涌现。

不过这里有一个必须诚实面对的区分。L-system 生成的是严格自相似——每一级分支都是上一级的精确缩小复制，因为替换规则在每一步都完全相同。而自然界的植物是统计自相似——树枝的分叉角度、长度比例、分支数量在统计特征上跨尺度一致，但没有哪两根树枝完全相同。L-system 是对植物生长的数学抽象，不是精确描述。真实的生物系统有风力、光照角度、土壤中的营养分布、与邻近植物的竞争等随机因素介入，把严格自相似”打散”成了统计自相似。数学模型揭示了底层机制，但自然界在这个机制上叠加了噪声。

L-system 诞生于 1968 年，Mandelbrot 集合在 1978 年首次被计算机绘制出来。两者相隔十年，来自不同的研究传统，最终却指向了同一个核心机制。数学到此给出了它的回答：迭代是自相似的生成器。

那自然界有没有一台真正运行了几十亿年的迭代机器？

生物：DNA 与细胞分裂

有。而且它几乎和地球上的生命一样古老。

最早的化石证据表明，大约 35 亿年前地球上就已经存在细胞生命。从那时起，DNA 复制加细胞分裂就构成了一台从未停机的递归引擎。每一次细胞分裂，完整的基因组被复制一份，传递给子代细胞。这个过程从最初的单细胞生命一直持续到此刻——你正在用来阅读这段文字的视网膜细胞，和你的肝脏、骨骼、皮肤里的每一个细胞，都是同一颗受精卵经过大约 37 万亿次分裂的产物。

这台机器有几个值得注意的结构特征。

部分包含整体的蓝图。 你身体里的每一个细胞（极少数例外，如成熟红细胞）都携带着完整的基因组——大约 32 亿个碱基对，编码了构建整个有机体所需的全部信息。一个肝细胞里装着造眼睛的全部指令，一个皮肤细胞里装着构建大脑的全部代码。它之所以是肝细胞而不是神经元，不是因为它缺少某些信息，而是因为特定的基因被激活了而其他的被沉默了。信息是完整的，表达是选择性的。

这不是隐喻，这是分子生物学的事实。须弥芥子——部分完整地包含整体——在这里获得了它最直接的生物学实例。

跨层级的编码一致性。 从碱基对到密码子，从密码子到氨基酸，从氨基酸到蛋白质——信息的编码机制在每个层级上都遵循相同的语法。四种碱基（A、T、G、C）的三联体组合翻译为二十种氨基酸，这套翻译表在几乎所有已知生命中都是通用的。无论这段代码在大肠杆菌里还是在蓝鲸的神经元里，密码子 AUG 都编码甲硫氨酸，UAA 都意味着”停止翻译”。规则不随尺度变化，不随物种变化。

细胞不只是信息的容器。 一个常见的误解是把细胞看作被动的”硬盘”——只负责存储基因组，等着被读取。但单个细胞是一个完整的功能单位。它有自己的能量代谢系统（线粒体），有对外界信号的感知和响应机制（受体蛋白和信号通路），有物质的输入输出通道（离子通道、胞吞胞吐），有自己的质量控制系统（蛋白酶体降解错误折叠的蛋白质）。一个细胞不是大机器里的零件——它本身就是一台完整的、能够独立运行的机器。单细胞生物已经证明了这一点：一个细胞就是一个完整的生命。

时间维度的自相似。 遗传给自相似引入了一个 L-system 和 Koch 雪花都不具备的维度：时间。Koch 雪花的自相似是空间上的——放大局部，看到和整体相同的图案。L-system 的自相似是迭代层级上的——每一级替换都产生相同的分叉模式。但生物遗传的自相似跨越的是世代：父代与子代共享同一套基因组，祖父母与孙辈共享同一套编码语法，甚至人类和酵母菌共享着大量同源基因。生命的自相似不仅是”放大后看到相同的模式”，还包括”在时间轴上每一代都重新执行相同的基本架构”——而这条时间轴已经延伸了 40 亿年。

这里需要做一个明确的声明。后面的章节会讨论 genome 与 system prompt 之间的结构映射——两者都是”在系统运行前写入的、塑造系统行为的编码信息”。但这个映射是结构层面的，不是机制层面的。基因组由细胞内的分子机器（核糖体、RNA 聚合酶、剪接体等）读取和执行——这些分子机器本身是基因组编码的产物，但它们是独立于基因组的物理实体。而 prompt 由 LLM 自身处理——同一个模型既是”读取者”也是”执行者”。执行者的身份和执行的方式完全不同，只是”编码信息在系统启动时塑造其后续行为”这个抽象模式是共享的。把结构相似误读为机制等价，是类比推理中最常见也最危险的陷阱之一。

数学给出了迭代生成自相似的原理，生物学给出了一台运行了 40 亿年的真实实例，而且这台机器展现出了数学模型中没有的特征——部分包含整体的完整蓝图，编码语法的跨物种不变性，以及时间维度上的代际自相似。

在最简的条件下——最少的规则、最小的空间、最随机的起点——递归能不能从零开始涌现出自组织结构？

计算：Conway 的生命游戏

1970 年，Martin Gardner 在《Scientific American》的”数学游戏”专栏中介绍了一个由英国数学家 John Conway 发明的细胞自动机。这个游戏的规则可以写在一张便签纸上：

一个无限的二维网格，每个格子要么活要么死，每一步所有格子同时按照上面四条规则更新状态。没有玩家操作，没有随机事件注入，没有外部干预。你只需要设定初始状态，然后按下”开始”，系统自行演化。

从随机初始状态开始运行，最初几步看起来只是噪声——细胞大片死去，大片复活，毫无可辨认的模式。但运行几十步之后，一些奇怪的事情开始发生。混沌逐渐沉淀，秩序从中凝结出来。

首先出现的是稳定的静态结构：2x2 的方块、六细胞的蜂巢。它们在 B3/S23 规则下不再变化——每个活细胞恰好有两三个存活邻居，处于完美的平衡态。然后是周期性振荡器：三个一排的”信号灯”（blinker）在水平和垂直之间交替翻转，永远不停；“蟾蜍”（toad）在两个状态之间每步切换一次。这些结构没有人设计——它们是四条规则在局部条件恰好满足时的自然稳定解。

更惊人的是运动结构的出现。“滑翔机”（glider）是一个仅有五个活细胞的图案，每四步沿对角线移动一格，永不停歇。它不是在”滑行”——每一步它都在经历细胞的生生死死，但四步之后，它恢复了原来的形状，只是位置偏移了。整个移动是死亡和新生的精确编排，而这个编排完全由四条局部规则自动产生。

后来人们又发现了”滑翔机枪”（glider gun）——一个能够周期性发射滑翔机的稳定结构。有了枪和滑翔机，就有了信号的发射和传递。有了信号，就可以构建逻辑门。有了逻辑门，原则上就可以构建任何计算机。

Conway 的生命游戏后来被严格证明是图灵完备的。四条关于生死的局部规则，在一个二维网格上，原则上能够计算任何可计算的问题。Paul Rendell 在 2016 年出版的专著《Turing Machine Universality of the Game of Life》中给出了完整的构造性证明。

但故事还没完。这里有一个更深层、与自相似直接相关的事实。

通过一种叫做 OTCA metapixel 的精巧构造，可以用大约两千多个生命游戏的细胞组成一个”元细胞”（metacell）。这个元细胞内部的细胞按照标准的 B3/S23 规则运行——和所有其他细胞一样。但从宏观上看，这个元细胞作为整体的行为，完美模拟了生命游戏中单个细胞的规则：当它的”元邻居”（相邻的其他 metacell）中恰好有三个是”活的”，它就从”死”变”活”；当存活的元邻居少于两个或多于三个，它就”死去”。

也就是说，你可以在生命游戏内部构建另一个生命游戏。内层的每个”像素”不再是一个格子，而是一大片格子组成的功能单元，但从远处看，它遵循的是完全相同的四条规则，涌现出完全相同的滑翔机、振荡器、静态结构——只不过每个都大了几千倍，每一步的演化也慢了几千倍。

而理论上，这个内层的生命游戏还可以再用 metacell 构建更内层的生命游戏。第三层的每个像素是第二层的一个 metacell，而第二层的每个像素又是第一层的一个 metacell。层层嵌套，每一层都在运行相同的 B3/S23 规则，每一层都涌现出相同类型的结构。嵌套的深度没有理论上限。

这是”计算内部的计算”的最简实例。一个系统用自己的基本元素搭建出了自己的完整副本，在更大的尺度上运行着相同的规则，产生着相同的涌现行为。

三条线收敛

回头看刚才走过的三个领域：

• 数学：L-system 的字符串替换规则迭代出树形结构，$z \to z^2 + c$ 迭代出 Mandelbrot 集合。机制是形式化的，结果是确定性的。
• 生物学：DNA 复制加细胞分裂迭代了 40 亿年，在空间和时间两个维度上产生自相似。机制是分子层面的，结果是统计性的。
• 计算科学：四条局部规则在二维网格上迭代，涌现出自组织结构，甚至能在自身内部复现自身。机制是离散的，结果是涌现性的。

三个完全独立的领域，三种截然不同的物理基底——符号系统、有机分子、离散格子——同一个模式：一条简单规则，作用于自身的输出，重复执行。 不需要外部的总设计师来安排整体布局，不需要精心挑选的初始条件，不需要每一步的人为干预。只需要一个递归过程持续运行足够长的时间，复杂的自相似结构就从简单的规则中长出来。

这也解释了为什么自相似在自然界中如此普遍：递归是自然界最廉价的构建策略。编码一条规则所需的信息远远少于编码一个完整的复杂结构。用一条简单规则反复迭代来”生长”出复杂性，比从零开始设计一个完整的复杂系统，在信息成本上便宜了几个数量级。自然选择偏好经济的方案——这就是为什么蕨叶用递归来长出自己的形状，而不是在基因组里逐像素描述每一片叶子。

但这里必须加一条诚实的注脚。

递归并不总是产生自相似。有些递归系统产生的是混沌——Lorenz 吸引子由三个互相耦合的微分方程驱动，每一步的输出都是下一步的输入，这毫无疑问是递归的。但它的轨迹对初始条件极度敏感，宏观形态虽然被限制在一个蝴蝶形的区域内，内部结构并不在每个尺度上重复自身。有些递归系统产生的是均匀性——热传导方程也是递归的（每一时刻的温度分布由上一时刻的分布决定），但它的迭代最终消除所有局部差异，走向平淡无奇的热平衡。还有些递归系统产生的是周期性——某些初始条件下的 logistic map 会落入简单的固定点循环，既不混沌也不自相似。

自相似是递归的一个常见结果，但不是必然结果。递归是必要条件，不是充分条件。

那什么条件下递归才会产生自相似？回到三个例子中找共性：

更精确地说：当递归规则在执行过程中保持了跨层级的结构一致性时，自相似才会涌现。 L-system 的替换规则在每一级都完全相同——第一次替换和第一百次替换用的是同一条规则——所以每一级的分支模式相同。DNA 的编码语法在大肠杆菌和蓝鲸的每一个细胞里都相同，所以每个细胞都携带着构建整体的蓝图。生命游戏的四条规则在单个格子和整个 metacell 的尺度上都相同，所以元细胞能够复现细胞的行为。

规则不随尺度变化——这一条件听起来简单，但它恰好是最关键的。把规则的跨尺度不变性拿掉，L-system 的每一级用不同的替换规则，生成的就不再是自相似的树，而是某种不可预测的混合体。

规则的跨尺度不变性，才是自相似的真正生成器。

分形维数：度量自相似的工具

到目前为止，“自相似”还是一个定性的描述——我们说某个结构”在不同尺度上看起来类似”，但”类似”到什么程度？一棵蕨”比”一条海岸线”更”自相似吗？有没有一把尺可以量化这种特性？

有。它就是分形维数。

回到英国海岸线的例子：分形维数 $D \approx 1.25$。当时我们说这个数字意味着”海岸线的复杂程度介于一维和二维之间”，但没有解释这个数字是怎么来的。

分形维数的工程价值在于：它是一个跨领域的复杂性指纹。

海岸线的 $D \approx 1.25$，Koch 雪花的 $D \approx 1.26$，二者几乎相同。这两个完全不同来源的结构——一个是数学家用确定性规则构造的理想曲线，一个是千万年的海浪侵蚀和地质运动雕刻出的自然地貌——在”复杂性如何随测量精度增长”这个维度上的行为几乎一致。分形维数把形态各异的对象映射到同一把标尺上，让跨领域的结构比较成为可能。

一棵蕨叶的分支模式和一段河流网络的分支模式可能有相近的分形维数。一段音乐信号的频率波动和一只股票的价格波动可能有相近的分形维数。这并不意味着它们的物理机制有任何关系——蕨叶不关心股价，河流不遵循音阶。但它意味着生成这些结构的递归过程，在”跨尺度保持结构一致性”这个抽象特征上是相似的。

这才是分形维数作为工程工具的真正力量：它不描述内容，它描述复杂性的”形状”。当你在两个看似无关的系统中测量到相近的分形维数时，你有了一个值得追问的线索——也许它们背后的生成机制共享某种结构特征，即使表面上毫无关联。分形维数是发现隐藏联系的探针，而不仅仅是描述已知复杂性的标签。

从生成器到世中世

递归是复杂性的生成器。一条简单规则反复作用于自身的输出，在条件合适时——特别是当规则保持跨尺度不变时——自相似结构就会涌现。数学用 L-system 和 Mandelbrot 集合证明了这一点，生物学用 40 亿年的细胞分裂验证了这一点，计算科学用四条规则和一个二维网格把它推到了逻辑极限——生命游戏在自身内部运行了另一个生命游戏。

最后这个例子尤其值得停下来想一想。

一个系统，用自己的元素构建出了自己的完整副本，在更大的尺度上运行着相同的规则，产生着相同的涌现行为。这不只是”部分看起来像整体”的自相似——这是整体在部分之内被完整地重新实现。外层的生命游戏不知道自己的内部正在运行着另一个生命游戏；内层的生命游戏不知道自己的每个像素其实是外层的一大片细胞。两个层级各自独立地遵守着同一套规则，各自涌现出同样的结构。

世界之中还有世界。而那个内部的世界，遵循着同样的法则。

这个结构——不只是”像”，而是在内部完整地”是”——正是下一篇文章要探讨的核心。当递归的嵌套深到一定程度，“部分包含整体”就不再是修辞。它变成了一个可以操作的工程事实。

概念与实体

本文涉及的核心概念与实体，在项目知识库中有更详细的资料：

• 分形维数 — 度量自相似结构复杂度的数学工具，本文介绍了盒计数维数的工程直觉
• 统计自相似性 — 严格自相似与统计自相似的区分，理解 L-system 抽象与自然分形之间的关键差异
• 分形架构 — 自相似原理在软件工程中的应用，“统一接口”规则与本文”跨层级结构一致性”的结构呼应
• Benoit Mandelbrot — 分形几何的奠基者，将 Richardson 的经验参数识别为 Hausdorff 维数

世界中的世界

每个细胞都携带完整的基因组。不只是存着——是随时准备表达。一个肝细胞里装着造眼睛的全套代码，一个皮肤细胞里有搭建心脏的完整蓝图。它们之所以是”肝”或”皮肤”，不是因为缺了什么，而是因为在特定的环境中，特定的基因被激活了。

信息完整，表达选择性。

这件事值得停下来想一想。因为它不只是一个生物学事实——它暗示了一种结构性质，这种性质在哲学、计算科学和 agent 工程中反复出现。

一个统一的结构

第一篇文章观察到了一个现象：部分与整体之间存在结构回声。须弥芥子、Koch 雪花、Mandelbrot 集合——无论是佛学直觉还是数学发现，都指向同一件事：放大局部，看到整体的影子。

第二篇追问了原因：这种结构回声从哪来？答案是递归。简单规则反复作用于自身的输出，在规则保持跨尺度不变时，自相似结构涌现。

但”部分像整体”和”部分是整体”之间有一道鸿沟。

Koch 雪花的每一段边缘是整体的缩小版——没错，但那段边缘不会自己”运行”。它没有独立的存在，没有自己的因果链，没有可以独立演化的状态。它只是一个几何形状的碎片，恰好和母体形状相同。

而细胞不一样。一个细胞不只是”看起来像”整个有机体——它携带着构建整个有机体的完整信息，并且它本身就是一个能独立运行的完整系统。把一个细胞放进培养皿，它能存活、能代谢、能分裂。它不是零件。它是一个完整的世界。

这篇文章要说的就是这道鸿沟的另一边：不只是部分像整体，而是部分本身构成一个完整的、可独立运行的世界——而这个世界遵循着和整体相同的结构法则。

芥子中的须弥

华严经的因陀罗网（Indra’s Net）里，每颗宝珠映照着所有其他宝珠。但”映照”这个词容易让人低估它的含义。

唐代法藏是华严宗的实际建构者。他在《华严金狮子章》里用了一个精妙的比喻来解释这种结构：一尊金狮子。

金没有固定的形态，随工匠的手艺呈现为狮子。狮子的形状是”虚”的——不是说不存在，而是说它不是独立于金的另一种实体。形状和材质是一回事。然后关键的一步来了：取狮子身上任何一个毛孔——这个毛孔里就包含了整头狮子。每一个毛孔都是如此。

这不是”毛孔长得像狮子”的视觉相似。法藏说的是：毛孔中的金，和整头狮子的金，是同一种金。结构和基底不可分离。部分不是”映射”了整体——部分就是整体，只不过在不同的位置和尺度上表达。

“一即一切，一切即一”——华严经里这句话经常被当作禅宗式的玄谈。但在法藏的系统化阐释里，它是一个精确的结构描述：每一个局部都包含足够的信息来重建整体，而整体不过是所有局部的同时呈现。

一千年后，一位英国诗人写下了几乎相同的直觉。

一粒沙中一个世界。不是”一粒沙让人联想到世界”——是沙粒本身就是一个世界。这和法藏的毛孔-狮子逻辑完全同构：部分包含足够的结构来构成一个完整的、自洽的存在。

这些哲学直觉在各自的文化中独立生长了千年。它们没有互相借鉴——法藏不认识 Blake，Blake 大概没读过华严经。但它们汇聚在同一个结构性洞见上：部分不仅映射整体，部分本身就是一个完整的世界。

细胞中的基因组

哲学直觉是一回事，生物学事实是另一回事。

人体大约有 37 万亿个细胞。每一个（除了极少数例外，比如成熟红细胞丧失了细胞核）都携带着完整的基因组——约 32 亿个碱基对，编码了构建整个有机体所需的全部信息。

但细胞不只是被动地存储这些信息。这才是关键。

一个干细胞（stem cell）携带完整的基因组。当它接收到来自周围环境的信号——化学梯度、物理接触、来自邻近细胞的分子信号——它的基因表达谱发生变化。某些基因被激活，其他的被沉默。同一份蓝图，不同的环境，不同的表达结果：

• 在神经管附近，干细胞分化为神经元——开始表达离子通道蛋白，形成轴突和树突，获得电信号传导能力。
• 在骨髓中，干细胞分化为红细胞——大量表达血红蛋白，最终甚至排出细胞核来腾出更多空间装载氧气。
• 在肌肉组织附近，干细胞分化为肌纤维——表达肌动蛋白和肌球蛋白，获得收缩能力。

同一份完整信息。不同的上下文。完全不同的功能。

这个模式在 agent 工程中有一个直接的结构对应：同一套 agent 架构（相同的模型、相同的核心能力），配置不同的 system prompt 和 tool set，表现出完全不同的行为。一个 agent 架构可以是代码审查者，可以是文档撰写者，可以是数据分析师——取决于你在它的”环境”中放入了什么信号。

这里必须做一个明确的声明：这是结构映射，不是机制等价。

基因组由细胞内的分子机器读取——核糖体翻译 mRNA 为蛋白质，RNA 聚合酶将 DNA 转录为 RNA，剪接体对 pre-mRNA 进行编辑。这些分子机器本身是基因组编码的产物，但它们是独立于基因组的物理实体。“读者”和”蓝图”是两个东西。

而 system prompt 由 LLM 本身处理。同一个模型既是”读取者”也是”被指令塑造的执行者”。读者和蓝图融为一体。

两者共享的是一个抽象模式：编码信息在系统启动时写入，通过与环境的交互选择性地表达，从而塑造系统的功能特化。 这个模式是真实的、可检验的。但如果把结构相似误读为机制等价——认为 system prompt “就是”数字基因组，认为 tool set “就是”表观遗传调控——那就从有用的类比滑入了错误的等式。

模拟中的模拟

2003 年，牛津大学哲学家 Nick Bostrom 在《Philosophical Quarterly》上发表了一篇论文：Are We Living in a Computer Simulation?。

这篇文章的结论是一个三难推理（trilemma），三个命题至少有一个为真。我们不需要讨论它的结论是否正确——对本文有用的是它的前提结构。

Bostrom 的推理建立在一个假设上：如果一个足够先进的文明拥有足够的计算资源，它可以模拟出包含有意识存在的完整宇宙。而这个模拟中的文明，如果也发展出了足够的技术，可以在模拟内部再运行模拟。

剥掉所有关于意识和概率的争议，剩下的是一个纯粹的结构性陈述：计算可以嵌套。一个计算系统内部可以运行另一个完整的计算系统，而内部系统对外部系统的存在一无所知。

这不是思想实验。Conway 的生命游戏已经给出了最小的实现。

OTCA metapixel 用大约两千多个生命游戏的细胞构成一个”元细胞”。这个元细胞的内部严格遵循标准的 B3/S23 规则运行——和网格中的每一个普通细胞一样。但从宏观上观察，这个元细胞作为整体的行为完美模拟了一个单细胞的规则。用足够多的 metacell 铺满一层，你就得到了一个在更大尺度上运行的完整生命游戏。

内层的”世界”对内层的”居民”来说是完备的。它有自己的规则（B3/S23——虽然和外层相同，但内层不需要”知道”这一点），有自己的状态（metacell 的开/关），有自己的因果链（内层的滑翔机和振荡器遵循内层的动力学演化）。内层世界不需要知道外层世界的存在。它自身就是一个完整的、自洽的系统。

这里有一个关键性质：内部世界的完整性不依赖于对外部世界的感知。 你不需要知道自己在一个模拟里，才能在这个模拟里跑完一整套因果链。完整性是结构性的——它取决于规则是否足以支撑自洽的演化，而不取决于你是否知道规则从哪来。

Agent 创建 Sub-agent：世界构造

现在从哲学和计算理论回到工程。

当一个 agent 创建一个 sub-agent 时，它在做什么？

表面上看，它在”分派任务”。但从结构上看，它在做一件更有意思的事：构建一个完整的世界。

• System prompt 是这个世界的物理法则——它定义了什么是允许的、什么是重要的、什么是存在的边界。
• Tool set 是这个世界中可交互的环境——sub-agent 能”触碰”到的东西，就是它的现实。
• Task description 是这个世界存在的理由——它给了 sub-agent 一个方向，一个”为什么在这里”的答案。
• Context 是这个世界的初始状态——sub-agent 从这些信息开始它的存在。

Sub-agent 在这个世界里运行。它观察环境（读取上下文和工具输出），做出决策（生成 next token），执行行动（调用工具），验证结果（检查反馈）。它经历了一个完整的感知-决策-行动循环。然后世界关闭，结果被传回给创建者。

关键是：sub-agent 不知道、也不需要知道 orchestrator 的完整上下文。

Orchestrator 可能同时在管理十个 sub-agent，每个处理不同的子任务。Sub-agent 看到的只有自己的 system prompt、自己的 tool set、自己的任务描述。它不知道自己是”第三个被创建的”，不知道另外九个 sub-agent 的存在，不知道 orchestrator 的最终目标是什么。对它来说，它的世界就是全部。

这和 metacell 内部的生命游戏结构完全同构。内层不知道外层。内层有自己完整的规则和因果链。内层的”完整性”是结构性的——它取决于 system prompt 是否足以定义清晰的行为空间、tool set 是否足以支撑任务的执行，而不取决于它是否”知道”orchestrator 的全貌。

2025 到 2026 年间，这种结构在主要的 agent 产品中独立出现。Claude Code 的主 agent 可以派生 sub-agent，每个 sub-agent 有自己的 system prompt 和 tool 权限集合，和主 agent 的配置不同。OpenAI 的 Codex 在 2026 年 3 月 GA 了 subagent 功能，允许 agent 在运行时动态创建子 agent。Devin 的多步骤工作流也展现了结构相似的嵌套模式。

这些产品是否互相借鉴了设计？可能有，也可能没有——从公开信息无法确定。但无论各自的设计过程如何，最终收敛到的结构惊人地相似：一个 orchestrator 为 sub-agent 构建一个完整的运行环境（world），sub-agent 在其中独立运行，完成后将结果交还。

结构的收敛，往往比人的意图更值得注意。

模式统一

四个领域，同一种结构。

四行描述的不是四个”看起来有点像”的类比。它们共享一个可检验的结构性质：一个部分包含足够的信息来构成一个完整的、可独立运行的功能世界。

“可检验”这个词不是修辞。它意味着一个具体的测试：

把”部分”从”整体”中剥离出来，它能独立运行吗？

• 细胞可以。从有机体中取出一个细胞，放进培养皿，给它合适的培养基——它能存活、能代谢、能分裂。单细胞生物的整个生命就是这么过的。
• Metacell 构成的内层生命游戏可以。把内层的初始状态提取出来，在一个独立的模拟器中按 B3/S23 规则运行——它的演化和在外层中完全一致。
• Sub-agent 可以。把 sub-agent 的 system prompt、tool set 和 task description 提取出来，在一个独立的 agent 运行时中启动——它能正常执行任务，不需要 orchestrator 的存在。

如果不能通过这个测试——如果一个”部分”离开”整体”就无法运行——那么你面对的不是世界中的世界，而只是一个零件。零件可以有自相似的形状，但它没有独立的因果链，没有自己的”物理法则”，没有作为”世界”的资格。

Koch 雪花的一段边缘就是零件。它看起来像整体，但取出来之后什么也不会发生。它没有状态，没有演化，没有自己的时间线。

而细胞、metacell、sub-agent 是世界。它们各自拥有完整的运行规则、可独立演化的状态、自洽的因果链。它们不只是”像”整体——它们各自就是一个整体，只不过嵌套在另一个整体之内。

这种”部分即完整世界”的结构性质，不是某个天才的一次性发明。它在自然界、哲学和计算科学中各自独立地出现。

更值得注意的是，工程师们也在独立地重新发明它——不是因为读了华严经或者研究了 metacell，而是因为在解决实际问题的过程中，这种结构一次又一次地证明自己是有效的。

这不是巧合。当完全不同的领域在没有互相参照的情况下收敛到同一种结构时，通常意味着这种结构触及了复杂性管理的一个基本事实：递归分解为自足的子单元，是信息成本最低的构建策略。

下一篇来看看，工程师们到底是怎么独立走到这条路上的。

概念与实体

本文涉及的核心概念与实体，在项目知识库中有更详细的资料：

• 因陀罗网 — 华严经中的宇宙结构隐喻：每个局部不只是映射整体，而是构成完整世界
• 须弥芥子 — “部分包含整体”的佛学原型，本文从”映射”推进到”即是”
• 分形架构 — 自相似性在软件工程中的结构映射，sub-agent 世界构造是其具体实例
• 层级系统 — Simon 的层级嵌套理论，“部分即完整世界”是其在 agent 系统中的分形表达
• 隐式循环架构 — sub-agent 内部的运行模式：gather → act → verify → repeat
• 编排器-工作者 — Orchestrator 为 sub-agent 构建完整运行环境的工程模式
• 华严经 — 因陀罗网与”一即一切”的原始经典，法藏在此基础上系统化华严宗哲学
• Claude Code — 主 agent 派生 sub-agent 的工程实例，每个 sub-agent 拥有独立的 system prompt 和 tool 权限
• Codex — 2026 年 3 月 GA subagent 功能，与 Claude Code 结构收敛的独立证据

从晶体管到 Agent

工程师们一直在独立地重新发明这个结构。不是因为他们读过 Mandelbrot 或者研究过蕨叶的分支模式。大多数时候，他们甚至不知道彼此在做什么。但当问题的复杂度超过单一组件的处理能力时，他们一次又一次地走向了同一个解法：把系统分解为更小的副本，让每个副本遵循相同的接口契约，然后用一层薄薄的协调机制把它们粘合起来。

这不是一组平行的例子。这是一条演化线——从硅片上的开关到屏幕上的 agent，抽象层级在上升，但结构模式保持不变。

硬件层：晶体管 → 多核处理器

故事从最底层开始。

一个晶体管是最小的计算单元：输入电压，状态翻转，输出电压。开或关，0 或 1。1947 年，贝尔实验室的 Bardeen、Brattain 和 Shockley 造出了第一个能工作的点接触型晶体管。它的全部功能就是一个受控开关，但这个开关是一切数字计算的原子操作。

把几十亿个晶体管组织起来，你得到一个 CPU 核心。核心内部运行的是 fetch-decode-execute 循环：从内存取指令，解码指令含义，执行运算，写回结果。输入 → 处理 → 输出。和晶体管的逻辑相同，只是抽象层级上升了：单个晶体管翻转一个比特，一个核心在一个时钟周期内完成一条完整指令的处理。

2005 年，Intel 发布了第一款商用双核处理器 Pentium D。这个时间节点不是偶然——单核频率的提升撞上了功耗墙（Dennard scaling 失效），工程师没有选择造一个”更大的核心”，而是选择了放 N 个相同的核心。每个核心独立运行自己的 fetch-decode-execute 循环，通过缓存一致性协议协调共享状态。

这个选择本身就值得停下来想一想。面对”单一单元不够用”的困境，工程师的第一反应不是改变单元的结构，而是复制单元、加入协调层。多核不是”一个更大的核心”——它是 N 份相同结构 + 一层协调协议。这个模式会反复出现。

前一章讨论的操作系统调度，管理的正是这个硬件层级的分形——多个核心各自运行相同的执行循环，OS 的调度器决定哪个进程在哪个核心上运行，上下文切换保存和恢复的是每个核心的寄存器状态。硬件提供了自相似的计算单元，操作系统提供了协调这些单元的机制。

软件层：Unix 管道

硬件的分形是物理约束逼出来的——功耗墙堵死了频率提升的路，工程师别无选择。接下来这个分形不一样。它是一群人坐下来想清楚之后，刻意设计出来的。

1978 年，Doug McIlroy、E. N. Pinson 和 B. A. Tague 在 Bell System Technical Journal 第 57 卷上发表了一篇文章，系统阐述了 Unix 的设计哲学。这篇文章不是事后总结，而是对一个已经运行了将近十年的操作系统背后设计决策的理论化表达。其中最核心的一条原则：每个程序做好一件事，程序的输出可以成为另一个程序的输入。

单看一个命令：

grep "error" server.log

stdin → 处理 → stdout。和晶体管、和 CPU 核心的模式一样：输入，变换，输出。

用管道串联：

grep "error" server.log | sort | uniq -c | sort -rn | head -20

五个命令，每个都是 stdin → stdout，管道把一个的输出接到下一个的输入。整条管道从外部看？还是 stdin → stdout。

再往上一层。把这条管道写进 shell 脚本：

#!/bin/bash
# top_errors.sh
grep "error" "$1" | sort | uniq -c | sort -rn | head -20

这个脚本对外暴露的接口？stdin → stdout。它可以被另一个脚本调用，被另一条管道串联，被 cron 定时执行——消费者不需要知道它内部是一条管道还是一个 Python 程序。

四个尺度——单个命令、管道、脚本、脚本的组合——同一个接口契约。

Unix 的力量不来自任何单个命令的强大。grep 不强大，sort 不强大，uniq 不强大。力量来自接口的一致性：因为每个组件都遵守同一个契约（文本流进，文本流出），任意组件可以和任意其他组件自由组合。组合的结果仍然遵守同一个契约，所以组合的结果可以继续被组合。

这和数学中的”闭包性质”是同一回事——运算的结果仍然属于同一集合，因此可以继续参与运算。整数加法的结果还是整数，所以你可以无限地加下去。Unix 命令的输出还是文本流，所以你可以无限地管道下去。自相似结构的真正力量不在于任何单一层级的能力，而在于层级之间的可组合性。

这是一个被刻意设计并严格维护的自相似结构。McIlroy 和他的同事们不是碰巧造出了这个模式——他们把它写成了设计原则，用它审查每一个进入系统的新工具。任何不遵守 stdin/stdout 契约的程序，都会被视为不合格的 Unix 公民。和多核处理器的自相似不同（那是物理约束逼出来的），Unix 的自相似是一个社会契约——需要每一位开发者的自觉遵守才能维持。

前端层：Cycle.js——自觉的分形

从晶体管到 Unix，自相似结构在工程中反复出现，但始终是隐含的。设计多核处理器的工程师不会说”我在做分形”，写 shell 脚本的程序员也不会说”我在维护自相似性”。它只是”好的工程实践”。人人都在用，没人专门给它起名字。

但到了 2015 年，有人开始给这个模式命名了。而命名这件事本身，改变了一切。

André Staltz 在那一年发表了一篇比较单向数据流架构的文章，其中给出了一个精确的定义：

“A unidirectional architecture is said to be fractal if subcomponents are structured in the same way as the whole is.”

——如果子组件的结构与整体相同，这个单向架构就是分形的。

Cycle.js 是他创建的框架，也是这个定义的直接体现：每个组件是一个纯函数，接收 sources（输入流），返回 sinks（输出流）。整个应用的签名是 sources → sinks。应用内部的每个子组件的签名也是 sources → sinks。子组件内部的子组件？还是 sources → sinks。

一年后，Anton Telesh 在此基础上进一步形式化，归纳出分形架构的四条规则：

1. 统一接口：应用是由相同 API 的组件组成的树
2. 递归组合：每个组件可以包含其他组件
3. 无特权根节点：顶层组件与叶子组件没有本质区别
4. 胶水与逻辑分离：装配代码在组件体系之外完成

回头看这四条规则，Unix 管道满足其中三条——统一接口（stdin/stdout）、递归组合（管道可以嵌套在脚本中）、胶水与逻辑分离（shell 负责管道连接，程序负责数据处理）。它唯一没有做到的是”无特权根节点”——Unix 的 init 进程（PID 1）确实是特殊的，它不能被杀死，也不遵循普通进程的生命周期规则。

从 Unix 的”每个程序做好一件事，输出是另一个的输入”到 Cycle.js 的”子组件与整体结构相同”——模式没变，但工程师对它的意识变了。Unix 是隐式的分形，Cycle.js 是显式的、自觉的分形。一个概念从无名的实践变成了有名的原则。

这个从”做到”到”意识到”的跃迁本身就很有意思。自然界的分形不需要知道自己是分形——蕨叶不读 Mandelbrot 的论文。但工程系统不一样：当工程师意识到自己在使用分形结构时，他们可以更刻意地维护它、推广它、把它变成设计约束。Staltz 和 Telesh 做的正是这件事——他们把一个隐性的工程直觉变成了显性的架构原则。

Agent 层：2025—2026 的收敛

然后，在 2025 到 2026 年间，同一个模式在一个全新的领域里再次浮现。这一次不是在硅片上，不是在终端里，也不是在浏览器中——而是在 LLM 驱动的 agent 系统里。

Claude Code 的架构中有一个叫做 AgentTool 的组件。主 agent 在判断任务需要隔离的上下文或并行处理时，可以启动一个 sub-agent。这个 sub-agent 运行的是什么？一个完整的 agent 循环——gather context → take action → verify → repeat。和主 agent 完全相同的循环，只是作用域更小、上下文独立。Sub-agent 拿到的工具集、权限模型、推理能力和主 agent 一样，区别仅仅在于它看到的是一个更窄的任务切片。

一个值得注意的细节：sub-agent 不能再启动 sub-agent。这是一个刻意设置的终止条件——递归必须有 base case，否则就是无限递归。L-system 有迭代次数上限，生命游戏的 metacell 嵌套受限于计算资源，Claude Code 用权限约束实现了同样的功能。每个递归系统都需要一个”到此为止”的机制。

2026 年 3 月，OpenAI 的 Codex 正式上线（GA）了子 agent 功能。Manager agent 将任务分解后分发给 worker subagent，每个 worker 运行相同的推理循环——获取上下文、执行操作、验证结果、决定是否继续。和 Claude Code 的 AgentTool 一样，每个 worker 都是一个结构完整的 agent，不是一个被阉割的执行器。

Devin 2.0 走了一条略有不同的路：多个完整的 agent 实例在各自隔离的虚拟机中并行运行，由一个编排层负责协调。每个实例内部是完整的 agent 循环，拥有自己的文件系统、终端和浏览器。编排层管理的是实例间的任务分配和结果汇总——而不是实例内部的推理过程。

这些产品在 2025—2026 年间各自发展出了结构相似的架构。它们之间是否存在直接的相互影响？不清楚，也不重要。重要的是这个事实本身：当”单个 agent 不够用”的复杂度门槛到来时，递归分解是工程师不约而同的回答。

为什么是递归分解而不是别的方案？因为替代方案更难。你可以造一个”更大的 agent”——更长的上下文窗口、更强的单次推理能力——但这条路有物理极限（上下文窗口有上限，单次推理的可靠性随任务复杂度下降）。你也可以造一个完全不同的架构——比如一个中央调度器加一群没有推理能力的执行器——但这等于放弃了 LLM 最强大的能力：每个节点都能自主推理和决策。递归分解之所以反复出现，是因为它同时保留了单元的完整能力和系统的可扩展性。

这和 Unix 面对”单个命令不够用”时发明管道，Intel 面对”单个核心不够用”时选择多核，是同一个故事。动机相同，约束不同，解法殊途同归。

一条演化线

把这条线拉出来看：

时间线不是完美的线性排列——Unix 在多核之前就已经存在了。但抽象层级是单调上升的：从电信号到指令流水线，到文本流，到响应式数据流，到自然语言驱动的推理循环。

每一步的设计者面对的是不同的问题，使用的是不同的材料，工作在不同的约束下。但他们独立地抵达了同一个架构模式：将系统分解为结构相同的子单元，通过统一接口实现自由组合，用协调机制管理子单元之间的状态一致性。

这不是巧合。它是第二篇文章结论的工程验证。

那篇文章在数学、生物学和计算科学三个领域中找到了同一个模式：递归是复杂性的默认生成方式。一条简单规则反复作用于自身的输出，在规则保持跨尺度不变的条件下，自相似结构就会涌现。

这条从晶体管到 agent 的演化线说的是同一件事，只是视角反转了——不是”递归自然地产生了自相似”，而是”工程师在解决复杂性问题时，自然地选择了递归”。L-system 的替换规则不知道自己在生成分形；McIlroy 不知道自己在设计分形架构；Claude Code 的开发团队不知道自己在重复 Unix 的模式。但他们都走向了同一个结构，因为这就是管理复杂性最自然的方式——把整体分解为结构相同的部分，让每个部分独立运行，用协调机制维持一致性。

但每一行表格里都藏着一个没有展开的词：“协调”。晶体管靠布线，多核靠 MESI 广播，Unix 靠管道缓冲区，agent 靠编排层。这个协调机制在每个层级都存在，而且在每个层级都是系统复杂度的主要来源。

Amdahl 定律说：串行瓶颈决定扩展上限。MESI 协议说：协调成本随参与者数量非线性增长。Unix 管道的缓冲区满了会阻塞上游。Agent 编排层的上下文窗口有长度限制。这些约束没有随着抽象层级的上升而消失。它们只是换了形态，从物理层面的功耗墙变成了信息层面的协调墙。

分形结构给了工程师一把管理复杂性的利器，但这把利器自身也受制于一组结构性的限制。这些限制是什么，它们在什么条件下开始显现？

概念与实体

本文涉及的核心概念与实体，在项目知识库中有更详细的资料：

• 分形架构 — Telesh 形式化的四条规则，本文演化线的理论框架
• 隐式循环架构 — agent 循环的核心模式：gather → act → verify → repeat
• 编排器-工作者 — 中央编排器动态分解任务并分发给工作者的模式，sub-agent 范式的结构基础
• Agentic Systems — agent 系统的分类框架，从 workflow 到 autonomous agent 的光谱
• Cycle.js — 第一个自觉使用”分形”作为架构术语的前端框架
• Claude Code — Anthropic 的 agentic 编码工具，AgentTool 实现了 sub-agent 的递归分解
• Codex — OpenAI 的 agent 编码平台，2026 年 3 月 GA 的子 agent 功能
• Anthropic — Claude Code 的开发者
• OpenAI — Codex 的开发者

分形的边界

协调成本在每一个层级都存在。晶体管靠布线，多核靠缓存一致性广播，Unix 靠管道缓冲区，agent 靠编排层。从晶体管到 agent，抽象在上升，但协调的开销从未消失——它只是换了一副面孔。

如果前四篇文章给了你一种”一个模型解释一切”的舒适感，这篇文章的任务是把这份舒适感拿走一部分。不是因为分形模型错了，而是因为它是一张骨架图——骨架告诉你结构在哪里重复，但没有告诉你每层的物理特性有多不同。

一个模型在哪里停止工作，和它在哪里工作同样重要。接下来的四个维度——延迟、成本、协调、容错——不是随机的工程困难，它们有一个共同的根源：分形描述的是结构的自相似性，但运行时的物理特性在每个层级都不一样。

延迟：乘法，不是缩放

几何分形可以无限缩放而不改变性质。放大海岸线的一截，它和整条海岸线呈现相同的粗糙度。放大 Koch 雪花的一个分支，你看到的还是同样的雪花。尺度变了，性质不变——这是数学分形的核心承诺。

但在 agent 系统中，“尺度”不只是空间维度，还有时间维度。而时间维度上发生的不是缩放，是质变。

单次 prompt 调用的延迟通常在百毫秒到秒级——取决于模型大小、输入长度和基础设施。这是原子操作的时间尺度，和晶体管的纳秒级翻转在结构上处于同一位置：最小单元的一次完整执行。

一个 agent 循环（gather → act → verify → repeat）一般迭代数步到十数步，总延迟进入数十秒到分钟量级。注意这里的乘法关系：不是”一次调用加上一点额外开销”，而是”N 次调用，每次都有自己的上下文构建、模型推理和结果解析”。

一个多 agent 协作系统——多个 agent 各自运行自己的循环，再加上彼此之间的信息交换——延迟进入分钟到数十分钟量级。即便工作者之间是并行执行的，编排器的综合步骤仍然是串行的：它需要等所有工作者返回，逐一解析结果，构建全局视图，然后决定下一步。并行化缩短了工作者层的延迟，但没有消除编排层的串行瓶颈。

每一次 agent 间的交接都不是零成本的。一次交接意味着：一次 API 调用的网络延迟，一次上下文的构建和填充，一次结果的解析和验证。如果工作者返回的结果不符合预期，还有重试和澄清的额外开销。这些开销本身不大，但它们是乘法性的——每增加一个协作层级，延迟不是加一个常数，而是乘以一个系数。

几何分形在不同尺度上保持自相似性，因为它的递归不消耗时间。Koch 雪花从第一次迭代到第一百次迭代，每一步只是描述上的展开，不是物理过程。但 agent 系统的递归是真实的物理过程——每一层的展开都消耗时间，而且消耗的时间随层级增加而增长。在时间维度上，分形的”无限嵌套”承诺在第三、四层就开始显现出代价：用户的耐心是有限的，任务的时效性是有限的，世界在等待期间可能已经变化了。

成本：超线性增长

延迟可以等，但 token 要花钱。

单个 agent 的 token 消耗主要来自两部分：输入（system prompt + 上下文 + 用户指令）和输出（推理 + 工具调用 + 结果生成）。当你把一个 agent 分解为编排器加若干工作者时，token 消耗不是简单地分摊——编排器要理解任务全貌才能分解，每个工作者要理解自己的子任务才能执行，工作者完成后编排器还要理解返回的结果才能综合。

理解这个超线性的来源很重要。假设一个任务被分解为三个子任务，每个工作者处理一个。编排器需要消耗 token 来理解原始任务并生成分解方案。三个工作者各自消耗 token 来理解子任务并执行。然后编排器再消耗 token 来理解三份返回结果并综合。这里面有大量的”理解”开销是重复的——编排器要理解任务全貌两次（分解时和综合时），每个工作者要重新理解一遍它所需的上下文。这些重复理解的 token 消耗，在单 agent 架构中根本不存在。

工程经验表明，多 agent 系统的总 token 消耗通常是同等复杂度单 agent 的数倍甚至一个数量级以上。具体倍数取决于任务性质、分解策略和上下文管理质量，但方向是确定的：超线性增长。

这里有一个真正的分形不具备的特征：有损压缩。当工作者 agent 完成子任务后，它不可能把自己完整的推理过程返回给编排器——那会超出编排器的上下文窗口。它只能返回一个摘要，一个压缩后的结果。这个压缩是有损的——某些细节在压缩过程中被丢弃了，而编排器无法知道被丢弃的是否是关键信息。

数学分形的递归不涉及信息损失。Mandelbrot 集的每一次迭代 $z_{n+1} = z_n^2 + c$ 是精确的——没有舍入，没有遗漏，没有”摘要”。但 agent 系统的层级间通信天然是有损的。结构在重复，但信息在每一次跨层传递中都在衰减。

还有一个硬约束：上下文窗口。数学分形没有”画布大小”的限制——你可以无限放大，无限嵌套，不存在”到这里就画不下了”的问题。但每个 agent 的上下文窗口是有限的。这个有限性不只是存储限制——它决定了 agent 能处理的信息量、能维持的对话深度、能协调的子任务复杂度。更微妙的是，即便在窗口没有物理溢出的情况下，随着上下文越来越长，模型对早期信息的注意力也在衰减。上下文窗口不只是一个硬墙——它是一个逐渐变软的地板，越远的信息站得越不稳。

分形的递归可以无限深入，agent 的递归被这个有限且会退化的”画布”截断。

协调：从零到 O(n²)

协调成本是这一系列边界中最具结构性的一个，因为它直接决定了系统能扩展到多宽。

单次 prompt 调用的协调成本是零。一个请求，一个响应，没有需要同步的对象。这是最简单的情况——一个封闭的输入输出过程，不涉及任何其他参与者。

单个 agent 循环内部有隐式协调——上下文窗口本身就是共享状态。每一步的输出成为下一步的输入，不需要显式的同步协议。上下文窗口扮演了共享内存的角色，而只有一个”线程”在访问它，所以不存在竞争条件。协调是免费的，但有一个前提：只有一个参与者。

多 agent 协作把协调从隐式推向了显式。编排器需要跟踪每个工作者的状态，工作者之间可能需要共享中间结果，任务的依赖关系需要被显式管理。最坏情况下，N 个 agent 之间的两两通信通道是 O(n²) 的——每多一个参与者，不是多一条通信线路，而是多 N-1 条。即便用编排器模式把拓扑简化为星形，编排器本身也成为了 O(n) 的瓶颈——它需要理解每个工作者的输出，而”理解”在 LLM 语境下意味着把输出放进上下文窗口并推理，这本身就消耗 token 和时间。编排器的上下文窗口越装越满，推理质量开始退化，这是一个隐蔽但真实的瓶颈。

工程中可以观察到的现象是：随着 agent 数量增加，边际收益递减得很快。从 1 个到 3 个工作者，任务完成质量和速度通常有明显提升——每个工作者处理一个独立子任务，编排器的综合负担还在可控范围内。从 3 个到 10 个，提升变得不确定——有些任务受益于更细的分解，有些反而因为编排器的综合负担加重而整体退化。超过这个范围，协调成本往往开始吞噬并行带来的收益。Amdahl 定律的回声在这里很清晰：编排器的综合步骤是串行瓶颈，无论你加多少并行工作者，瓶颈不会消失。

这不是新故事。MESI 协议的困境在这里回响——核心数越多，缓存一致性广播的开销越大，消费级处理器很少超过 16 核。Agent 系统面对的是同一类问题，只是介质不同。MESI 协议在总线上广播的是精确的缓存行状态——Modified、Exclusive、Shared、Invalid，四种状态，没有歧义。Agent 之间传递的是自然语言——一段摘要、一个指令、一份结果。自然语言的协调精度比总线广播低了不止一个数量级，这意味着协调失败的概率也高了不止一个数量级。同一类结构性约束，在更高抽象层级上表现得更严峻而非更宽松。

容错：错误不衰减，放大

传统软件中，一个组件失败了会怎样？它抛出一个异常，返回一个错误码，或者干脆崩溃。无论哪种，信号是明确的：这里出了问题。下游组件可以捕获异常、检查错误码、或者被监控系统重启。错误是离散的、可识别的事件。

Agent 失败的方式完全不同。一个 agent 在推理过程中犯了错——比如误解了任务要求，或者错误地调用了工具——它不会抛出异常。它会输出一段看起来完全合理的文本，语法正确，逻辑连贯，格式规范，只是内容是错的。错误以”合理但错误的输出”的形态出现。

这段输出到达下游 agent 时，下游 agent 没有任何内建的机制来区分”这是正确的输入”和”这是上游犯的错”。它没有错误码可以检查，没有异常可以捕获，没有 CRC 校验和可以验证——它面对的只是一段自然语言文本，而自然语言没有”语义校验和”。下游 agent 会把这段错误的输出当作可靠的输入，在此基础上继续推理，继续犯错——而且可能犯得更离谱，因为它在一个被污染的基础上构建了新的推理链。

这就是错误级联：错误在层级间传播时不衰减，反而放大。传统软件的错误传播模型建立在一个假设上——每一步面对的是正确的前置状态，故障是独立事件，总概率是各步故障概率的乘积。但在 agent 系统中，这个独立性假设不成立：前一步的错误改变了后一步面对的问题本身。一个 agent 改错了函数签名，下游 agent 调用这个函数时面对的是一个”看起来合理但语义错误”的接口——它不只是可能犯自己的错，还被上游的错误引导向了错误的方向。这是耦合放大，不是独立累积。

分形结构意味着嵌套：外层包含内层，内层的输出是外层的输入。在这个结构中，错误放大不是偶然的 bug，而是结构性的风险。嵌套层级越深，错误在到达最外层之前经过的放大步骤越多。而且放大的方式特别隐蔽——不像传统软件那样用异常或错误码大声报警，agent 的错误输出穿着”正确答案”的外衣，在层级之间安静地传播、变形、累积。等最外层发现结果不对时，回溯排查的成本已经很高了——你需要逐层检查每个 agent 的输出，才能找到错误的源头，而每一层的输出都是”看起来合理”的。

数学分形的递归是精确的——每一步的输出忠实地成为下一步的输入，$z_n$ 多精确，$z_{n+1}$ 就多精确。Agent 分形的递归是概率性的——每一步都可能在不发出任何警告的情况下引入偏差，而这个偏差会被后续步骤当作事实来处理。

Simon 的修正：近可分解性

到这里，四个维度的边界已经摆开：延迟质变、成本超线性、协调爆炸、错误放大。这些边界是否意味着分形模型应该被抛弃？

不是。它意味着分形模型需要一个修正项——一个能解释”为什么结构重复但物理特性不重复”的理论框架。

1962 年，Herbert Simon 在 The Architecture of Complexity 中提出了一个概念：近可分解性（near-decomposability）。Simon 不是在研究分形，他在研究一个更基本的问题：为什么复杂系统几乎总是呈现层级结构？他的答案是演化压力——他用钟表匠寓言说明，由稳定子组件构成的系统在演化中存活的概率远高于没有中间结构的系统。

而这些层级结构有一个共同特征——子系统内部的交互远强于子系统之间的交互。强，但不是绝对隔离；弱，但不是完全独立。“近可分解”这个”近”字，承载了所有的微妙之处。完全可分解意味着各子系统之间零交互，各自孤立——那只是一堆不相关的系统碰巧摆在一起。完全不可分解意味着所有部件等强度交互，无法区分子系统边界——那是一团无法理解的复杂性。现实中几乎所有值得研究的复杂系统都落在两者之间。

Simon 还指出了一个关键的动力学特征：频率分离。子系统内部的动态过程是高频的——变化快、局部影响；子系统之间的动态过程是低频的——变化慢、以聚合方式相互影响。不需要知道另一个子系统内部每个零件的状态，只需要知道它的聚合输出。

把这个框架叠加到 agent 系统上：

• 单个 agent 内部是高频动态——每一步 gather-act-verify 都在快速迭代，内部状态频繁变化
• Agent 之间是低频动态——编排器不需要知道工作者每一步的推理细节，只需要它的最终输出（聚合结果）
• 短期内各 agent 可以近似独立运行——这就是并行化之所以可行的结构性前提
• 长期行为通过聚合接口涌现——系统整体的表现不是各 agent 内部状态的简单加总，而是通过聚合输出的交互逐渐浮现的

这个频率分离不只是描述性的，它有设计含义。如果一个系统中不同层级以不同速率运动，那么试图用同一套协调策略管理所有层级就是错配的。内层的高频迭代需要轻量、低延迟的协调（上下文窗口内的隐式状态共享就够了）；外层的低频交互需要的是结构化、可验证的协调（聚合摘要、类型化接口、显式状态确认）。把高频策略用在低频层级上——比如让编排器实时追踪每个工作者的每一步推理——是浪费；把低频策略用在高频层级上——比如让 agent 每一步都走一遍正式的结构化汇报流程——是瓶颈。

分形模型说的是：结构在不同层级重复。Simon 的近可分解性补充的是：虽然结构重复，但不同层级的运行时物理特性是异质的。内层快、外层慢；内层紧耦合、外层松耦合；内层高频、外层低频。

回头看前四个维度的边界，Simon 的框架给了它们统一的解释：

• 延迟质变——因为不同层级的动态过程运行在不同的时间尺度上，内层的高频迭代和外层的低频综合天然不在同一个节拍
• 成本超线性——因为近可分解系统的层级间通信是聚合性的，而聚合意味着压缩，压缩意味着信息损失和额外开销
• 协调爆炸——因为层级间的交互虽然弱但不可忽略，维持这些弱交互的成本随参与者数量增长
• 错误放大——因为聚合输出丢弃了内部细节，下游无法区分正确的聚合和错误的聚合

这四个边界不是四个独立的工程问题。它们是同一个结构性事实的四个投影：分形描述骨架，但骨架的每一层在不同的物理条件下运行。

这个修正不削弱分形模型的价值。恰恰相反——它给分形模型划定了适用范围，让它从一个”听起来很美但不知道怎么用”的隐喻，变成了一个有边界条件的分析工具。

边界即自由

延迟在层级间乘法增长，这使得层级间交互的同步/异步性质成为一个关键结构变量。同步等待意味着外层的时钟被内层的最慢路径锁定；异步交互则把层间耦合从时间维度上松开。

协调成本随参与者数量非线性增长，这意味着 agent 的并行宽度不是一个可以无限拓展的参数——它受制于协调开销与并行收益的交叉点。超过这个点，每多一个参与者带来的边际成本大于边际收益。

错误在层级间放大而非衰减，这使得层级边界处的信息质量成为系统可靠性的瓶颈。一个错误在三层放大之后的纠正成本，远高于它在第一次跨层传递时被发现的成本。

这些恰恰是分形模型被工程化使用时的前提条件。一张地图标注了悬崖和沼泽，是在告诉你哪些路是通的、哪些地方需要换装备。不标注悬崖的地图只是更危险的地图。

四个边界中每一个都在做同一件事：把分形从一个无限递归的理想模型修正为一个有限层级的实用模型。延迟设定了层级的深度上限。成本设定了每一层的资源预算。协调复杂度设定了同一层级内的并行宽度。容错特性设定了层级之间的信任模型。这四个维度一起，把”无限自相似”塑形为”有约束的自相似”。

边界划定了可用空间的形状，而可用空间的形状决定了你能在里面建什么。

分形给了骨架。近可分解性给了每一层不同的物理特性。边界条件给了工程约束。这三者叠在一起，才是完整的图景。那么在这些约束之内，分形结构到底给了工程师什么？它的回报是什么？

概念与实体

本文涉及的核心概念与实体，在项目知识库中有更详细的资料：

• 近可分解性 — Simon 的核心概念：子系统内部强交互、子系统之间弱交互的层级结构属性
• 层级系统 — Simon 论述的复杂系统最普遍的组织形式，近可分解性的载体
• 误差级联 — 多步任务中前一步的小错在后续步骤中被放大的现象
• 编排器-工作者 — 中央编排器动态分解任务并分发给工作者的模式，多 agent 协调的基础拓扑
• 分形架构 — 本章核心概念：自相似性驱动的软件组织模式

分形之道

从分析到理解

五篇文章走下来，我们做了一件事：从不同角度拆解同一个结构。

须弥芥子是直觉——部分与整体之间存在结构回声。递归生成器是机制——简单规则反复施加于自身产生自相似。世界中的世界是更深一层的洞察——每个层级不只是”像”整体，它就是一个完整的世界。从晶体管到 Agent 是历史验证——工程师在不同时代、不同领域、互不知情地走向了同一个结构。分形的边界是诚实的约束——延迟、成本、协调爆炸、故障传播，这些力限定了结构的适用范围。

分析完成了。当分形结构从外部概念变成内化的认知透镜，哪些工程洞察会自然浮现？

跨层原则迁移

Anthropic 在 Building Effective Agents 中有一句话：

“Think about your tools […] tool descriptions deserve just as much prompt engineering attention as your overall prompts.”

工具描述值得像系统提示词一样精心设计。这是一个在 prompt 层级得到的观察——写好 tool description，agent 就能更准确地选择和使用工具。大多数人读到这里点点头，然后把它归档为”prompt engineering 技巧”。

如果你内化了分形结构，这句话不会停在”工具”这个层级。它会自动在你脑中展开——不是因为你刻意去推导，而是因为你已经看到了三个层级共享同一副骨架。它不再是一条关于”工具”的孤立建议，而是一个原则的某一层投影。

三个层级——prompt、agent、swarm——共享相同的骨架：输入描述 → 理解 → 决策 → 执行。这是第三篇的结论：每一层不只是”像”整体，它就是一个完整的世界，运行着相同的逻辑。如果”描述的质量决定理解的质量”在 prompt 层成立，那么在 agent 层和 swarm 层，同一个原则应该同样成立——不是因为有人验证过，而是因为结构相同。

在 agent 层：一个 orchestrator 需要知道每个 sub-agent 能做什么，才能正确分配任务。Sub-agent 的能力描述和工具描述在结构上是同一个东西——它们都是”让上层理解下层能力边界”的接口契约。能力描述模糊，orchestrator 就会误分任务，和 tool description 模糊导致 agent 选错工具是同一种失败模式。

在 swarm 层：orchestrator 给 sub-agent 下发的任务描述，在结构上等价于系统提示词——它们都是”定义执行者行为边界”的上下文。任务描述含糊，sub-agent 的输出质量下降，和系统提示词含糊导致模型输出偏离是同一种失败模式。同一条原则在三个尺度上成立，不需要修改。

注意这里发生了什么。我们没有做三次独立的分析，没有在三个层级上分别收集经验数据，没有写三份白皮书。我们只是在一个层级上认真理解了一条原则，然后沿着分形结构的自相似性，把它映射到了相邻层级——映射成立，因为骨架相同。

这是分形结构的第一个认知收益：跨层原则迁移。当你在某一层发现一个有效的原则，不用重新发现它——检查一下相邻层级的对应结构，如果骨架相同，原则直接迁移。认知负荷从”每层独立思考”降维到”一层想透，逐层映射”。反过来也成立：如果你在某一层遇到了一个难以解决的问题，往上或往下看一层——同构的问题可能早就在另一个层级被解决过了。

递归分解的 base case

分形是递归的。但工程递归有一个数学递归不需要面对的硬约束：它必须停下来。

Koch 雪花可以无限迭代——数学不收你计算费，也不会因为第一百万次迭代里某条线段画歪了而导致整个图形坍塌。工程系统没有这个奢侈。每多一层递归，就多一份延迟、多一段 token 消耗、多一条可能断裂的调用链。没有终止条件的递归在数学里叫无穷，在工程里叫灾难。

Claude Code 的 sub-agent 架构有一个不起眼但关键的设计：sub-agent 不能再生成 sub-agent。AgentTool 在子进程中不可用。这就是 base case——递归分解到这一层就停了，剩下的事情由单次 prompt 调用直接完成，不再委派，不再拆分。

这个设计选择不是随意的。没有 base case 意味着什么？一个 agent 拆任务给 sub-agent，sub-agent 觉得任务还是太复杂，继续拆给 sub-sub-agent——链条可以无限延伸。每一层加一次网络往返延迟，每一层消耗一个完整的上下文窗口，每一层的错误都可能向上传播。更致命的是，当出了问题，你要在一条深度未知的调用链里找到故障点。

所以，任何递归分解都存在一个终止层级。在这个层级上，问题直接执行，不再向下委派。这个终止层级通常是一次 prompt 调用——输入足够具体，输出足够明确，不需要再拆。

Base case 的存在不是对分形结构的否定。恰好相反——正因为每一层是一个完整的世界（第三篇的结论），base case 层级的 agent 才能独立完成任务，不依赖进一步的分解。自相似保证了 base case 的自足性：一个 sub-agent 拿到一个足够具体的任务，它拥有和顶层 agent 完全相同的推理能力、工具访问权限、输入-处理-输出的循环结构。它不是一个”降级版”的 agent——它就是一个完整的 agent，只是作用域更小。

怎么判断递归该在哪里终止？一个自然的信号是：当任务的描述已经具体到可以在单次 prompt 交互中完成，继续分解不会降低复杂度，只会增加协调开销。这不是一条精确的分界线——它随模型能力、上下文长度、任务性质而变化。但”继续拆分是否还在降低复杂度”这个问题本身，是一个稳定的判断锚点。

层间解耦：Simon 的工程化

第五篇引入了 Simon 的近可分解性——子系统内部交互强，子系统之间交互弱但非零。这个概念在那篇文章里是作为理论工具出现的。当你把它和分形结构叠在一起看，一个更具体的图景浮现出来。

分形系统中，每一层是一个完整的世界。层内的组件共享同一个上下文窗口（或同一片状态空间），彼此高度耦合——这是正确的。一个 agent 内部的多步推理共享同一段对话历史；一个 sub-agent 处理任务时，前一步的输出直接构成后一步的输入。层内耦合是功能实现的前提，削弱它等于每一步都从零开始重建上下文。

层与层之间则相反。Claude Code 的 sub-agent 完成任务后，返回的是一段文本摘要，不是完整的上下文窗口。AgentTool 不会把子进程的全部对话历史注入父进程——它做的是有意的信息压缩。Sub-agent 内部可能经历了十轮工具调用、三次错误修复、两次策略调整，但向上传递的只是最终结论和关键发现。

这种”有损压缩”正是近可分解性在分形架构中的具体实现。层间交互不是零——orchestrator 确实需要知道 sub-agent 做了什么。但交互的粒度被刻意降低了：不是逐步骤的完整记录，而是聚合后的摘要。Simon 说的”子系统之间的长期行为仅以聚合方式相互影响”，在这里有了一个几乎字面意义上的工程对应。

为什么是有损的？回到第五篇的协调成本分析：如果层间传递完整信息，每个 sub-agent 的全部上下文都注入 orchestrator，协调成本随参与者数量非线性增长——O(n²) 的信息交换。当 sub-agent 数量从两个变成五个，orchestrator 的上下文窗口会被下层细节淹没，留给自身决策的注意力预算急剧缩小。

为什么不能无损？因为并非所有信息都与上层决策相关。Sub-agent 在执行过程中遇到的具体语法错误、尝试过的替代路径、调用过的工具细节——这些是层内高频动态，对层间的低频决策没有贡献。压缩掉它们不是信息丢失，是噪声过滤。

层内高耦合保证执行效率，层间低耦合（有损压缩）控制协调成本。这两条不是独立的原则——它们是同一个结构性质（近可分解性）在分形系统中的两面。

Simon 在 1962 年描述近可分解性时，用的是物理系统和社会组织的例子。六十多年后，同一个结构性质在 agent 系统中以几乎未经修改的形态重新出现。这不令人意外——如果分形结构确实跨尺度保持自相似，那么约束分形结构的性质也应该跨尺度保持一致。近可分解性不是被”应用”到 agent 系统的——它是 agent 系统采用分形结构之后，自然附带的结构属性。

分形性检验

以上三个洞察——跨层迁移、base case、层间解耦——都是从分形结构中自然浮现的。但怎么判断一个具体的系统是否真的具备良好的分形性？

两个问题足够了。

这两个问题是诊断工具，不是教条。不是所有系统都需要分形性，也不是所有分形性的缺失都是问题。

举个反例：有些系统的不同层级面对的是本质不同的约束——比如底层受延迟支配，顶层受成本支配。在这种情况下，两层的设计原则本就不该相同，第一个问题的答案是”否”，但这个”否”是正确的。诊断的价值不在于追求两个”是”，而在于：当答案是”否”的时候，你能清楚地说出为什么，以及那个断裂点是不是你有意放在那里的。

它们的价值在于：当你面对一个复杂系统感到困惑时，这两个问题能快速定位结构上的不一致——然后你自己判断那个不一致意味着什么。

正交 × 分形

正交告诉你力的方向——在模型能力持续增强的前提下，你的工程投入该指向哪里。方向对了，投入累积；方向错了，投入消耗。

分形告诉你结构的纹理——当一个系统在不同尺度上重复相同的骨架时，你理解一层就等于理解了所有层。它的认知收益是降维：不是每个层级都需要独立思考，而是在一个层级想透之后，检查相邻层级的结构对应关系。

方向和结构，这两个维度本身是正交的。知道该往哪使力不告诉你系统长什么样；看清系统结构不告诉你哪些投入值得做。它们各自独立地提供信息，合在一起覆盖的认知空间比任何一个单独大得多。

可以观察到的是，正交性这个原则本身也通过了分形性检验：它在 prompt 层成立（选择 prompt 投入的方向），在 agent 层成立（选择 harness 工程的投入方向），在 swarm 层同样成立（选择系统架构的投入方向）。一个心智模型自身满足另一个心智模型的检验条件。这可能说明两个模型触及了同一层结构，也可能只是巧合。值得留意，但不值得过度解读。

方向和结构，是理解 agentic system 的两根坐标轴。但坐标系还没画完——还有其他维度等着被识别出来。

概念与实体

本文涉及的核心概念与实体，在项目知识库中有更详细的资料：

• 分形架构 — 自相似性的软件工程映射：统一接口、递归组合、无特权根节点
• 近可分解性 — Simon 的核心概念：层内强耦合、层间弱耦合，本文”层间解耦”一节的理论基础
• 层级系统 — 近可分解性的载体：交互强度定义层级边界
• 工具设计 — “跨层原则迁移”的起点：tool description 的质量决定 agent 选择工具的准确性
• 编排器-工作者 — 跨层迁移的 agent 层映射：orchestrator 分配任务依赖 sub-agent 的能力描述
• Harness Engineering — 正交性与分形性的工程交汇点：harness 层的设计同时受方向和结构约束
• Anthropic — Building Effective Agents 的发布者，tool description 原则的来源
• Claude Code — sub-agent base case 和层间信息压缩的工程实例