从晶体管到 Agent

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

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

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

故事从最底层开始。

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

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

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

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

Amdahl 定律：并行化的结构性天花板

Gene Amdahl 在 1967 年指出：程序的加速比受限于其中无法并行化的部分。如果一个程序有 10% 的工作必须串行执行，那么无论你加多少核心，理论加速比上限是 10 倍。

\[S = \frac{1}{(1 - P) + P/N}\]

其中 \(P\) 是可并行化比例，\(N\) 是核心数。当 \(N \to \infty\) 时，\(S \to \frac{1}{1-P}\)。

串行瓶颈决定了系统的扩展上限——这个结构性约束在后面的 agent 系统中会以不同的形式回响。

MESI 协议：协调的代价

多核系统中，每个核心有自己的 L1/L2 缓存。当核心 A 修改了一个缓存行，核心 B 的同一缓存行就失效了——B 必须重新从共享缓存或内存中读取。MESI 协议（Modified, Exclusive, Shared, Invalid）通过总线广播来维护这种一致性。

核心数越多，失效广播的开销越大。这就是为什么消费级处理器很少超过 16 核——协调成本最终会吞噬并行带来的收益。

这个"协调成本随参与者数量非线性增长"的模式，在 agent 系统中也存在结构性的回响。但必须诚实地标注边界：缓存行是确定性的——一个地址要么有效要么无效，没有中间状态；agent 的状态是概率性的——两个 agent 对同一段代码的"理解"可能重叠、矛盾或部分正确。结构层面的类比成立，实现层面的机制截然不同。

前一章讨论的操作系统调度，管理的正是这个硬件层级的分形——多个核心各自运行相同的执行循环，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 面对"单个核心不够用"时选择多核，是同一个故事。动机相同，约束不同，解法殊途同归。

一条演化线

把这条线拉出来看：

年代	领域	基本单元	结构	协调机制
1947	硬件	晶体管	输入 → 状态翻转 → 输出	电路布线
2005	硬件	CPU 核心	N × fetch-decode-execute	缓存一致性协议（MESI）
1978	操作系统	Unix 命令	stdin → process → stdout	管道 \|
2015	前端	Cycle.js 组件	sources → sinks	框架 driver 层
2025—2026	AI	Agent	context → action → verify → loop	编排层 / 权限约束

时间线不是完美的线性排列——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 的开发者