重读 How Complex Systems Fail 后,我发现:AI 正在制造我们无法驾驭的复杂系统

本文永久链接 – https://tonybai.com/2026/11/20/ai-is-creating-complex-systems-we-cannot-control

大家好,我是Tony Bai。

【导读】

1998 年,芝加哥大学的 Richard I. Cook 写下了一篇只有几页的短文:《How Complex Systems Fail》。

它原本讨论的是医疗、交通、电力等复杂系统为什么会失效,却意外成为软件工程、航空安全和系统可靠性领域经常被引用的经典资料。

近 30 年后,AI 正在改变软件生产方式:代码生成越来越便宜,Agent 可以自主执行任务,多个 Agent 可以协同完成复杂工程。

但一个容易被忽略的问题是:我们制造复杂系统的速度,是否已经超过了理解和驾驭它们的速度?

Cook 的 18 条原则,或许能给今天的 AI 软件工程带来一些不一样的启示。

【文章要点】

  1. 复杂系统的故障往往不是单点错误,而是多个微小缺陷的组合。
  2. 系统长期正常运行,不代表它没有问题,冗余和人工补救可能掩盖了潜在故障。
  3. AI Agent 将改变故障的传播速度、范围和耦合方式。
  4. AI 不是简单地替代人类操作员,它也可能成为新的系统风险源。
  5. 安全不是某个组件的属性,而是整个系统持续运行、监测和防御的结果。
  6. AI 时代的软件工程师,需要从代码生产者转向复杂系统的设计者、观察者和防御者。


引言:代码越来越便宜,复杂性却越来越昂贵

过去,构建一个复杂的软件系统,需要大量工程师、漫长的开发周期,以及昂贵的协作成本。

今天,AI 正在改变这个等式。

一个开发者借助 Claude Code、Codex 等编程 Agent,可以在很短时间内完成过去需要一个小团队才能完成的工作。多个 Agent 还可以并行开发、测试、审查,甚至自主完成从需求到交付的整个流程。

软件生产效率正在发生质变。

但这里隐藏着一个值得警惕的反差:

构建复杂系统的成本正在下降,理解和驾驭复杂系统的成本却没有同步下降。

甚至可能正在上升。

当代码生成速度提高十倍,我们是否有能力以十倍的速度理解这些代码?当十个 Agent 可以并行修改一个系统,我们是否有能力理解它们之间所有可能的交互?

这让我想起一篇经典旧文:《How Complex Systems Fail》。

1998 年,Richard I. Cook 在芝加哥大学认知技术实验室撰写了这篇短文。Cook 是一位研究复杂系统与患者安全问题的医生。他通过长期观察医疗等高风险系统,总结了 18 条关于复杂系统失效的规律。

这篇文章原本不是为软件工程而写,却对今天的 AI 软件工程有着惊人的解释力。

28 年前的 18 条警告

Cook 的 18 条原则并不是一份传统意义上的故障排查手册。

它真正想表达的是:复杂系统的失效,不应该被简单归结为某个人犯了一个错误,或者某个组件出现了一个 Bug。

它揭示的是系统内部各个因素相互作用、相互影响,最终形成灾难的过程。

如果把这 18 条原则归纳一下,可以分成四个主题:

第一组:复杂系统为什么会失效。

  1. 复杂系统本质上具有危险性。
  2. 复杂系统通常有多层防御机制。
  3. 灾难需要多个故障共同作用,单点故障通常不足以造成灾难。
  4. 复杂系统中始终存在不断变化的潜在故障。
  5. 复杂系统经常处于退化运行状态。
  6. 灾难可能随时发生。

第二组:我们为什么经常误判故障。

  1. 事故发生后,将其归结为一个根本原因,往往是错误的。
  2. 事后分析容易受到结果偏见的影响。

第三组:人类在复杂系统中的角色。

  1. 操作者既是生产者,也是系统的防御者。
  2. 所有实际操作都伴随着不确定性。
  3. 系统末端的操作者最终承担了消除模糊性的责任。
  4. 人类操作者是复杂系统中具有适应能力的部分。
  5. 复杂系统中的专业知识始终在变化。

第四组:如何让系统持续安全运行。

  1. 改变会引入新的失效模式。
  2. 对故障原因的错误理解,会限制未来防御能力。
  3. 安全是整个系统的属性,而不是某个组件的属性。
  4. 人们持续创造着安全。
  5. 无故障运行需要对故障有足够的经验。

这 18 条原则中,一些观点看起来甚至有些反直觉。

例如,复杂系统本来就存在缺陷,却依然能够长期运行;人类操作既可能造成事故,也可能阻止事故;安全不是安装某个安全组件就能获得的。

这些观点放在传统软件工程中已经很有价值。

而在 AI Agent 开始参与甚至主导软件生产之后,它们变得更加值得重视。

复杂系统为什么会失效?

先看 Cook 最重要的一个观点:

灾难通常不是由一个错误造成的,而是多个看似无关的小故障组合在一起的结果。

假设一个软件系统有以下几层防御:

  • 代码层:静态检查和单元测试。
  • 服务层:超时、重试和熔断。
  • 基础设施层:资源隔离和故障转移。
  • 业务层:限额、权限和异常处理。
  • 人员层:监控、告警和人工干预。

每一层都不完美,但它们共同工作,让系统能够抵御大量局部故障。

真正危险的是,这些防御机制可能同时出现缺口。

例如:

  1. 一个服务出现延迟,触发自动重试。
  2. 重试流量迅速增加,导致下游服务过载。
  3. 限流配置存在遗漏,没有阻止流量继续放大。
  4. 监控系统也依赖同一套基础设施,无法及时发出告警。
  5. 人工值班人员没有足够信息判断故障范围。

最终,一个普通的服务延迟演变成整个系统的级联故障。

可以用下面的示意图理解:

注意,这个例子中的每个组件都可能是正常工作的。

重试机制没有 Bug,监控系统没有 Bug,服务本身也没有 Bug。

问题出在它们之间的相互作用。

这就是复杂系统最难处理的地方:单独看每个组件都没有问题,不代表整个系统没有问题。

另一个值得注意的观点是,Cook 认为复杂系统经常处于退化运行状态。

也就是说,系统之所以能够持续工作,并不意味着它内部没有缺陷,而是因为存在冗余机制和人的持续补救。

在软件系统中,这种情况非常常见:

某个服务长期存在性能问题,但缓存一直在掩盖它;某个接口依赖不稳定,但重试机制让它看起来正常;某个数据库已经接近容量极限,却因为暂时没有流量高峰而一直没有暴露。

系统并不是没有问题,而是问题暂时没有组合成事故。

这也解释了为什么很多严重故障发生之前,系统往往已经出现过多次小规模异常。

还有一个非常重要的观点:

复杂系统事故往往不存在一个简单的 Root Cause。

事故发生后,我们习惯寻找一个责任点:某段代码、某个配置、某个人的操作。

但这可能只是事故链条中的最后一环。

如果只修复最后一环,而不改变整个系统中潜在故障的组合方式,下一次事故依然可能发生,只是表现形式不同。

AI 正在改变复杂系统的失效方式

Cook 的这些原则原本讨论的是医疗、交通等复杂系统。

那么,AI 究竟改变了什么?

我认为,至少有四个方面值得关注。

故障的传播速度变快了

传统软件系统中,很多操作需要人工发起、确认和执行。

AI Agent 不同。

它可以自主规划任务、调用工具、修改代码、执行命令,并根据结果继续下一步行动。

当多个 Agent 协同工作时,一个局部错误可能迅速影响其他任务。

例如,一个负责需求分析的 Agent 对需求产生了错误理解,将错误的设计写入任务规格;多个编码 Agent 根据这个规格并行开发;测试 Agent 又根据同一份错误规格生成测试。

最终,多个看似独立的工作都完成了,但整个系统建立在错误的前提之上。

这里最危险的不是某个 Agent 犯错,而是错误被整个自动化流水线放大了。

系统的复杂性增长速度变快了

AI 让增加功能、增加服务、增加自动化流程变得更加容易。

以前,工程师需要考虑开发成本,可能会主动放弃一些复杂设计。

现在,Agent 可以快速实现这些设计,组织也更容易接受增加新的自动化环节。

但每增加一个组件,都可能增加新的依赖关系、状态和故障传播路径。

尤其是多 Agent 系统。

假设一个系统有 N 个 Agent,如果每个 Agent 都可能与其他 Agent 发生交互,那么潜在的两两交互关系最多可以达到:

E = N * (N-1) / 2

注:在这个全连接的数学模型中,E 为边数,N 为顶点数。

当 Agent 数量从 5 增长到 20 时,潜在交互关系从 10 增长到 190。

当然,真实系统并不一定是全连接的网络,但这个简单计算揭示了一个问题:

Agent 数量的增长,不一定只是线性增加系统复杂度。

人类对系统的可见性可能下降

过去,工程师大致知道系统中发生了什么。

一个请求经过哪些服务,一个任务修改了哪些文件,一个操作由谁执行,通常可以通过日志和调用链追踪。

但在 Agent 系统中,一次任务可能包含:

  • 多轮模型推理。
  • 多次工具调用。
  • 动态任务拆分。
  • 多个 Agent 之间的消息传递。
  • 自动重试和任务恢复。
  • 对共享文件、数据库和外部服务的修改。

如果没有完整的执行记录,工程师可能只看到最终结果,却无法理解系统是如何走到这个结果的。

更麻烦的是,Agent 可能在执行过程中不断改变计划。

系统的真实行为不再完全由静态代码决定,还受到模型输出、上下文、工具结果和运行状态的共同影响。

这让传统的软件调试和故障分析变得更加困难。

新的自动化防御可能成为新的风险源

这是 Cook 第 14 条原则在 AI 时代特别值得注意的地方:改变会引入新的失效模式。

我们引入 AI,往往是为了消除旧问题。

例如:

  • 用 AI Code Review 减少代码缺陷。
  • 用 AI 测试提高测试覆盖率。
  • 用 Agent 自动修复故障。
  • 用多 Agent 协作提高开发效率。

但这些新机制本身也可能引入风险。

AI Code Review 可能漏掉真正重要的问题;自动修复可能引入新的回归;Agent 为了完成任务,可能修改原本不应该触碰的文件;自动重试可能放大外部服务的压力。

更值得警惕的是,这些新风险可能发生得很少,却具有更大的影响范围。

这恰恰符合 Cook 对复杂系统新型失效模式的观察。

AI 时代,我们需要重新设计五道防线

如果复杂系统的失效规律没有改变,那么 AI 时代的软件工程应该如何应对?

我认为,不能只依赖更好的模型,也不能只在 Agent 外面增加一个安全提示词。

我们需要从系统工程的角度重新设计防御体系。

第一,限制自主性,而不是无限扩大自主性

Agent 越强大,并不意味着应该给它越多权限。

一个能够读取代码的 Agent,不一定需要写入生产环境的权限;一个能够创建 Pull Request 的 Agent,不一定需要合并代码的权限。

应该根据任务风险划分权限边界:

  • 只读任务:允许读取,禁止修改。
  • 开发任务:允许修改隔离的工作区。
  • 发布任务:需要明确授权和审批。
  • 高风险操作:必须有人类确认。

尤其要避免把模型输出直接转换成高权限操作。

第二,建立故障隔离和有限爆炸半径

多 Agent 系统应该尽量采用隔离的执行环境。

例如:

  • 不同 Agent 使用独立的工作区或 Git Worktree。
  • 限制 Agent 可以访问的文件和目录。
  • 限制工具调用的范围和数量。
  • 为任务设置时间、Token 和资源预算。
  • 对外部 API 调用设置限流和熔断。
  • 对共享状态的修改建立明确的协调机制。

核心原则是:

一个 Agent 的错误,不应该轻易演变成整个系统的错误。

第三,建立独立验证机制

AI 生成的代码,不应该由同一个 AI 简单地宣布正确。

如果编码 Agent 根据某份需求生成代码,测试 Agent 又直接根据同一份需求生成测试,那么两者可能共享同一个错误假设。

这是一种容易被忽略的验证盲区。

因此,验证应该尽可能独立:

  • 使用明确的需求和验收标准。
  • 使用确定性测试验证关键行为。
  • 使用静态分析和安全扫描检查代码。
  • 对关键操作进行人工审查。
  • 对 AI 生成的结果保留可追溯的证据。

AI 可以参与验证,但不能把 AI 的自我确认当成系统正确性的最终证明。

第四,让系统真正可观察

传统系统需要日志、指标和分布式追踪。

Agent 系统还需要记录:

  • 谁发起了任务。
  • Agent 接收了什么目标。
  • 使用了哪些模型和工具。
  • 每次工具调用的输入和结果。
  • 任务状态如何变化。
  • 哪些文件或外部资源被修改。
  • 最终结果由什么证据验证。

这些记录不仅用于调试,还应该形成完整的审计链。

一个无法解释自己执行过程的 Agent 系统,很难成为一个值得信赖的生产系统。

第五,保留人类的紧急干预能力

Cook 有一个非常重要的观点:人类操作者既是系统的生产者,也是系统的防御者。

这在 AI 时代依然成立。

我们不应该把人类仅仅放在流程末尾,充当一个机械的审批按钮。

真正有价值的人类干预应该发生在关键边界:

  • 目标是否合理。
  • 计划是否存在重大风险。
  • 权限是否超出任务需要。
  • 系统是否正在偏离预期。
  • 是否应该暂停或终止任务。

对于高风险任务,还应该设计全局停止机制,确保人类可以在必要时立即终止 Agent 的执行。

可以将这五道防线概括为:

需要强调的是,这五道防线不是简单的线性流水线,而是相互补充的系统防御机制。任何一道防线失效,都不应该让其他防线同时失去作用。

AI 时代,软件工程师的角色正在改变

回到 Cook 的第 18 条原则:无故障运行需要对故障有足够的经验。

这句话放在今天尤其值得深思。

一个从未经历过生产事故、没有分析过级联故障、不了解系统退化模式的工程师,即使能够借助 AI 快速构建复杂系统,也未必真正具备驾驭复杂系统的能力。

AI 可以生成代码,可以分析日志,可以提出修复方案。

但系统运行过程中,始终存在大量无法预先完全描述的情况。

我们需要有人理解系统的边界,知道哪些操作可能引发连锁反应,知道什么时候应该停止自动化,知道如何在局部故障中保护整个系统。

这也是我认为 AI 时代软件工程师不会简单消失的一个重要原因。

当然,工程师的工作重心正在改变。

过去,我们花费大量时间编写代码、实现功能、修复 Bug。

未来,我们可能需要花更多时间:

  • 设计 Agent 的执行边界。
  • 管理多 Agent 之间的协作关系。
  • 构建独立的验证体系。
  • 观察系统运行状态。
  • 识别潜在故障和级联风险。
  • 设计恢复机制和人工干预机制。

换句话说:

工程师正在从软件的主要生产者,逐渐转变为软件生产系统的设计者、观察者和防御者。

这并不意味着代码能力不再重要,而是代码能力需要与系统工程能力结合起来。

小结:不要让系统复杂度跑赢我们的理解能力

重新阅读《How Complex Systems Fail》,我最大的感受是:

这篇文章真正讨论的,从来不只是如何避免 Bug,而是如何在一个无法彻底消除不确定性的复杂系统中,持续维持安全和可靠。

AI 并没有改变复杂系统的基本失效规律。

但它改变了我们制造复杂系统的速度、规模和方式。

过去,一个团队可能需要数月才能构建的复杂系统,现在可能只需要几天。

过去,需要多人协作才能完成的自动化流程,现在可能由多个 Agent 自主运行。

效率提高了,但复杂性并没有消失。

甚至可能被隐藏在更多层自动化、更多组件和更多动态交互背后。

因此,AI 时代真正值得追求的,不应该只是更高的代码生成速度,或者更多的 Agent 数量。

而是让系统的构建能力、理解能力、验证能力和防御能力保持同步增长。

我们需要的不是能够无限制造复杂性的 AI,而是能够帮助人类驾驭复杂性的工程体系。

否则,AI 可能让我们以前所未有的速度,构建出一些连自己都无法真正理解的系统。

参考资料:Richard I. Cook,How Complex Systems Fail,1998。原文:https://how.complexsystems.fail/


还在为写 Agent 框架频频死循环、上下文爆炸而束手无策?我的新专栏 《从0 开始构建 Agent Harness》 将带你:

  • 抛弃臃肿框架,回归“驾驭工程 (Harness Engineering)”的第一性原理
  • 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等,复刻极简OpenClaw
  • 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
  • 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
  • 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码,开启从 0 开始构建Agent Harness 的实战之旅。


还在为“复制粘贴喂AI”而烦恼?我的新专栏 《AI原生开发工作流实战》 将带你:

  • 告别低效,重塑开发范式
  • 驾驭AI Agent(Claude Code),实现工作流自动化
  • 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码,开启你的AI原生开发之旅。


商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求,请扫描下方公众号二维码,与我私信联系。

内容来自 Tony Bai,版权归原作者所有。

阅读原文 ↗

用 HomepageTab 新标签页关注 RSS,打开浏览器就能看到更新。

安装 HomepageTab