Over the past few weeks, I’ve deliberately given my brain a bit of a break. I mentioned in earlier pieces that when you interact with AI at very high density—especially across multiple languages (Chinese and English) and multiple language modes (programming languages, formal languages)—you start to feel something like information overload and information drift, a kind of cognitive and even physical fatigue.

I realized I needed to switch gears, to change what I was thinking about and what I was working on. Once you drill yourself too deeply into a single tunnel, it becomes very hard to generate genuinely good ideas.

So I decided to seriously revisit someone I’ve been thinking about a lot lately: Stephen Wolfram. Why him? Because it suddenly struck me that Wolfram may be the only person over the past twenty-plus years who has consistently and explicitly talked about a paradigm shift in science. His book is literally titled The New Kind of Science.

I recently bought a copy of this book online. Before that, I had already encountered Wolfram in various forms: his work on cellular automata, Mathematica, and the concepts he keeps emphasizing—computational irreducibility, and ruliology(a term he coined himself). But to be honest, for a long time I didn’t really “get” him. I didn’t truly understand what he was doing, nor did I dig deeply into it. These ideas didn’t hit me at a fundamental, logical level; they didn’t trigger that feeling of “this is worth investing a serious amount of my limited time and mental energy into.”

I’ve also mentioned Thomas Kuhn’s The Structure of Scientific Revolutions before. Over the past few years, that book has become increasingly important to me. But what really turned “paradigm shift” into a widely discussed topic for my generation was the commercialization of AI in 2022–2023. And Stephen Wolfram had already recognized this reality very early on—and repeatedly articulated it in many of his essays, some written as early as 2005 or 2012, more than a decade ago.

In this piece, I want to share how I’ve started to re-approach Wolfram’s work. I want to try to understand computational irreducibility from his perspective, to get a feel for his way of thinking, while also using AI to track down relevant papers. Coincidentally, I also happen to have a children’s toy on my desk, brought to me by a friend from China—a code-breaking machine.

Behind this toy, there is actually an NP-complete problem. I want to study and understand this complexity problem using Wolfram’s language and worldview. Especially during these past months of high-intensity writing, I’ve often been reminded of Wittgenstein’s remarks on the relationship between language and the world. Only when you fully internalize a language system do you actually gain a new worldview and a new way of seeing problems.

Since the Day A New Kind of Science Was Published, Wolfram Has Been Surrounded by Intense Academic Controversy

In a sense, it helped that Wolfram is a commercial / entrepreneurial scientist. He largely funded himself, bypassed the traditional academic and publication systems, and didn’t need to survive on academic approval. This, in turn, has made me very interested in a certain type of people like him—corporate scientists. For example, Elon Musk is a member of the U.S. National Academy of Engineering, yet he doesn’t really participate in academia either.

Precisely because such people don’t depend on the academic system for survival, and are in fact genuinely capable scientists, their evaluations and criticisms of academia are often worth reading carefully. Especially today: when universities are flooded with low-value papers, when the meaning of academic titles is itself becoming questionable, when AI is steadily eroding universities’ monopoly over knowledge interpretation; and when governments—especially the U.S. government—are cutting research funding and openly questioning the real-world value of academic systems. Against this backdrop, perspectives from outside the system form a valuable counterbalance.

Without further ado, let me show you a few examples.

Here is an important critique of Wolfram from the mathematical community: a formal book review published in the Bulletin of the American Mathematical Society. It criticizes aspects of his argumentation, the rigor of his exposition, and the relationship between his work and existing literature. For instance, it argues that some explanations are “unclear,” “unsystematic,” or “lacking testable detail.”

https://www.ams.org/journals/bull/2003-40-01/S0273-0979-02-00970-9/S0273-0979-02-00970-9.pdf

In the complex systems and statistical physics communities, one of the sharpest criticisms can be summarized in a single phrase: “old wine in new bottles + overclaiming.” The core argument is that Wolfram repackaged many existing ideas from complexity science and computation theory, then declared a “paradigm shift” through a very strong narrative, while failing to adequately acknowledge or credit prior work. A representative voice here is Cosma Shalizi.

http://bactra.org/reviews/wolfram/

I’m not interested in adjudicating who is right or wrong. Whether it’s Wolfram or his critics, their level of scholarship is far beyond mine.

But after reading these critiques—especially after months of deliberate writing practice in both Chinese and English—I had two very strong intuitive impressions.

First, Wolfram and his critics are not even operating within the same language system. This isn’t just a disagreement of viewpoints; it’s a mismatch of language protocols, almost a case of people talking past each other entirely.

Second, these critical texts carry a very strong emotional charge. You don’t have to analyze them very deeply to sense a kind of dissatisfaction or resentment. That’s actually quite strange for a community that prides itself on being rational and dispassionate.

Over time, I started to understand this better. In the AI era, many people are labeled as “crackpot scientists” simply because they lack formal academic titles, even though they are seriously engaging with scientific problems. The emotional tone feels remarkably similar.

“Alright,” I can only say this: in the age of AI, I’d much rather be a billionaire ‘crackpot scientist’ like Wolfram than a professor or lecturer struggling to secure funding and facing an uncertain career future. 😂

How Does Wolfram Respond?

Thirteen years ago, Wolfram had already personally experienced the shock of a paradigm shift, and he described it with remarkable clarity. Calling him a “crackpot” is frankly absurd.

Let’s look at his own words, from a 2012 essay, where he describes this impact. By then, he had already largely exited academia—arguably as early as 1987, when he began building software. He explains why he stopped publishing papers: academic publishing had become overly formalistic, with form outweighing substance, while the sheer amount of real content in his work made the paper format impractical. He preferred blogging. That’s why, today, the best way to understand his thinking is simply to read Stephen Wolfram’s writings.

Why does he insist this is a “paradigm shift”?

When he recounts reactions to his work, many academics respond with unusually intense emotion:

“You’re destroying the heritage of mathematics…”

Why such anger? Would you get angry at a shaman or a yoga guru making scientific claims? No—you wouldn’t even engage. Anger only appears when something is taken seriously.

Wolfram’s response is blunt:

“This is what a paradigm shift sounds like—up close and personal.”

A paradigm shift is not primarily about new conclusions; it’s about a new evaluation system.

The emotion isn’t triggered because a theorem was overturned, but because:

• The old standards of “what counts as science” are being threatened (papers, peer review, citations, academic networks).

• Old “career investments” are being threatened (decades of training and accumulated prestige may suddenly depreciate).

He even breaks this down into two “core threatened groups,” drawing a sharp distinction between surface reasons and deeper reasons.

“There was a surface reason… and a deeper reason.”

A. Content-level fears (the career economics of paradigm conflict)

First group (mostly physicists):

“We’ve spent our whole careers barking up the wrong tree.”

If the computational perspective of NKS is right, then these researchers weren’t just “slightly wrong”—their entire research trajectory may have been a low-return investment. This is classic Kuhnian paradigm shift territory: what counted as success before may no longer count at all.

Second group (complexity researchers):

“It’ll overshadow everything we’ve done.”

This isn’t about truth; it’s about attention and authority structures—who defines the main narrative controls textbooks, funding, and disciplinary gateways.

Form-level conflict: doing something “academic-like” without following “academic rules”

“Academic-like, but you haven’t played by academic rules.”

The implicit message is that academia has a legitimacy stack:

• Peer review as gatekeeping

• References as network visibility

• Journals and publishers as distribution channels

• Academic identity as speech authorization

Wolfram’s move was to bypass this entire stack. Hence his insistence:

“I wasn’t an academic…”

This is the core tension of his essay: a new paradigm combined with a new distribution and validation mechanism, posing a dual threat to the old system.

His full essay is here:

https://writings.stephenwolfram.com/2012/05/living-a-paradigm-shift-looking-back-on-reactions-to-a-new-kind-of-science/

Kuhn Loss

Even though Kuhn’s The Structure of Scientific Revolutions is approaching a century old, it uncannily predicts the precise situation we’re discussing here. I can’t resist quoting it. The full discussion is in the SEP entry linked below.

A paradigm revolution does not merely solve more problems; it also discards—or even declares illegitimate—problems and explanations that the old paradigm valued and successfully addressed by its own standards.

This loss of explanatory power, problem sets, and evaluation criteria is what Kuhn called Kuhn loss.

Kuhn used this concept to undermine the idea that scientific progress is simply a cumulative approximation to truth.

1) What Is Actually “Lost”?

1. Problem sets change: what counts as an “important problem” changes.

2. Standards change: what counts as a “good explanation” or “good science” changes.

3. Concepts and worldviews change: the same words refer to different things, different sentences become expressible.

So Kuhn loss isn’t just “one less derivation.” It’s that things which had to be explained in the old paradigm become, in the new one:

• “Not necessary to explain”

• “Meaningless”

• “Metaphysical”

• Or outright “pseudo-problems”

This is why Kuhn says revolutions change the very definition of science.

2) A Classic Example: Why Newton “Lacked Explanatory Power” Yet Won

In Aristotelian and Cartesian mechanics, the question “How is attraction possible?” was mandatory—you had to provide a contact mechanism or ontological explanation.

Newtonian gravity looked like action at a distance and failed this test, so it was initially rejected. But once Newton’s paradigm won, that question was kicked out of the scientific agenda as illegitimate. That’s Kuhn loss.

Later, general relativity reintroduced the issue in a different form, reinforcing Kuhn’s point: progress isn’t linear accumulation; it’s repeated agenda rewriting.

3) Kuhn Loss and Incommensurability

You can think of Kuhn loss as an observable symptom of incommensurability.

Incommensurability doesn’t mean “incomparable,” but rather:

• No shared metric: different conceptual nets, problem lists, and evaluation standards.

• Hence no single unified measure of “closer to truth.”

Kuhn loss tells us that even if a new paradigm is stronger in some respects, it may be weaker in dimensions valued by the old paradigm—and whether it’s “weaker” at all depends entirely on which metric you use.

4) Why Kuhn Loss Shocks Scientific Rationality

This is why Kuhn and Feyerabend were once accused of being “anti-science”:

• If revolutions rewrite problems and standards, does rational comparison collapse into politics?

• If old successes are declared illegitimate, does science stop “approaching truth”?

Kuhn later clarified: incommensurability ≠ incomparability; Kuhn loss ≠ irrationality.

Paradigm choice lacks a neutral algorithm, but it can still be guided by values (accuracy, scope, simplicity, fruitfulness), allowing for rational disagreement.

Suddenly, that Cantonese phrase—talking past each other—feels very apt.

SEP link:

https://plato.stanford.edu/archives/fall2019/entries/incommensurability/#RevParThoKuhInc

Experiencing Irreducibility with a Decoder / Mastermind Toy

I picked up the Decoder/Mastermind toy simply because it happened to be on my desk when I was thinking about this.

A seemingly simple children’s toy hides an NP-complete problem. Originally called Mastermind, it’s a two-player board game: one player sets a secret code, the other tries to guess it.

Each round, the guesser submits a guess; the code-maker returns feedback:

• Black pegs: correct color and correct position

• White pegs: correct color, wrong position

This feedback channel must be perfectly correct and noise-free; otherwise, the entire reasoning chain collapses.

My electronic Decoder replaces the human code-maker with a hidden algorithm and adds variants: green lights (correct color and position), white lights (correct color, wrong position), and no light (color absent). In fully indirect hint mode, positional information is hidden, dramatically expanding the state space beyond brute-force feasibility.

Theoretical work confirmed this complexity: in 2005, Jeff Stuckman and Guo-Qiang Zhang proved that Mastermind is NP-complete.

https://arxiv.org/abs/cs/0512049

I spent a full day solving all 800 levels of this toy using a minimax strategy—choosing guesses that maximally reduce the candidate space in the worst case. The product itself is impressively reliable: a consumer-grade children’s toy with a completely noise-free feedback channel.

➜  giiker_super_decoder python3 minimax_generic_gwn.py --Y 7 --P 4 --R 7 --interactive-hints

=== Generic Minimax Bucket Solver (unique colors, tri-feedback) ===
Parameters: Y=7 colors, P=4 slots, R=7 total rows
Feedback: (G,W,N) with G+W+N=P
Initial candidates: |C0| = P(Y,P) = 840

--- Preset hints input (interactive) ---
Enter one hint per line as:
  guess:  a b c d    (P ints, unique, in [0..Y-1])
  fb:     G W N      (3 ints, G+W+N=P)
Type empty guess to stop.

hint guess (or empty to stop): 0 1 2 3
hint feedback (G W N): 2 1 1 
hint guess (or empty to stop): 0 6 2 1
hint feedback (G W N): 3 0 1
hint guess (or empty to stop): 

Applying preset hints: n=2  => remaining query budget T=R-n = 5
  hint#1: guess=0 1 2 3 fb=(G,W,N)=(2,1,1)  |C| 840 -> 36
  hint#2: guess=0 6 2 1 fb=(G,W,N)=(3,0,1)  |C| 36 -> 2

Step 1 (remaining queries: 5/5)
Suggested guess: 0 1 2 4
Current |C| = 2   worst_bucket=1   expected_remaining≈1.00
Enter feedback as 'G W N' (sum=4), or 'q' to quit: 2 2 0
Filtered candidates: 2 -> 1

✅ Unique solution determined without further queries: 0 4 2 1
➜  giiker_super_decoder 

All solution code is available here, including extensible solvers that go beyond the device’s original parameters:

https://github.com/STEMMOM/giiker_super_decoder

By this point, there’s little “puzzle-solving” left to say. My goal was never to solve a toy, but to revisit complexity through Wolfram’s lens.

The complexity isn’t in the rules—they’re trivial—but in the structure: a hidden truth (s), accessible only through queries that yield limited feedback. You can’t compute the answer directly; you must extract it through interaction.

From an information-theoretic view, this is a pure black-box query model. Information leaks from the hidden truth through a constrained channel. This structure pervades reality:

• Cryptography and security

• Medical diagnosis

• Scientific experimentation

• Engineering parameter tuning

The toy is kind because it promises a noise-free oracle. Reality makes no such guarantee.

Of course, I’m fully aware that I’m still at a very early stage, and that this class of problems is by no means unexplored. In fact, it has long been studied in a systematic way within academia. In theoretical computer science and in research on “puzzle complexity,” Mastermind is typically formulated as a constraint satisfaction / consistency decision problem, in its standard form known as the Mastermind Satisfiability Problem (MSP), and it has been rigorously proven to be NP-complete—a point already mentioned earlier. For the classic board-game parameters (4 positions, 6 colors, with repetition allowed), the entire state space contains only (6^4 = 1296) possibilities; as early as 1977, Knuth provided a strategy that guarantees a win in at most five moves in the worst case. My own implementation essentially operates at this same level: no more than five steps in the worst case, with reported results in the literature showing an average number of moves around four-point-something.

So within this particular scale and framework, the aspects that can be formalized, proven, and optimized have already been studied quite thoroughly. If I continue to push further, I’m more likely to approach the problem from an information-theoretic perspective—recasting it in terms of how much effective information each query can extract. Coincidentally, I also came across a very interesting recent paper today: Gür (2025), “Weighted Entropy Approach,”which uses weighted entropy as a heuristic to approach the theoretically optimal average number of steps. At its core, it treats the strategy itself as a kind of measurement instrument, an idea I find highly valuable as a reference. I won’t go into details here; interested readers can consult the original papers directly.

https://arxiv.org/abs/cs/0512049?utm_source=chatgpt.com

https://www.cs.bu.edu/fac/best/res/papers/alybull86.pdf?utm_source=chatgpt.com

https://arxiv.org/abs/2511.19446?utm_source=chatgpt.com

What I’m Really Interested In: How Wolfram Would See This Problem

A more realistic plan for me this year is to devote time to cellular automata—the true starting point of Wolfram’s worldview, beginning with A New Kind of Science. He treats them as a minimal, clean computational universe for studying complexity, irreducibility, and the fact that simple rules can generate extreme behavior.

Wolfram’s systematic, large-scale, decades-long exploration of cellular automata is essentially unmatched globally. From exhaustive rule-space scans to behavioral classification and the development of ruliology, it’s hard to find a true second example.

What continues to impress me is that one person proposed such a sweeping new scientific narrative. The key isn’t his conclusions, but his questions. When faced with Mastermind, my instinct is to solve it. Wolfram’s instinct is to ask: what kind of system is this?

Does it exhibit universal computation? Which behavior class does it belong to? Is it computationally irreducible? How common is this behavior in rule space?

Here’s the chilling thought: cellular automata are Turing complete. You’re not dealing with a solver, but a computational universe. From this comes PCE—the Principle of Computational Equivalence. I’m still digesting it, but roughly: once a system passes a very low complexity threshold, its computational power is equivalent to that of most others. The real differences lie in predictability, compressibility, and whether simulation is unavoidable.

So Wolfram isn’t anti–problem-solving. He’s reshaping the problem itself. He’s less interested in “what is the answer to this instance?” and more in “what are the behavioral laws of this system?”

In the PCE view, the “unique solution” isn’t central. What matters is whether different systems share the same class of computational capability and behavior. This worldview—almost orthogonal to the solver’s instinct—is what I’m only beginning to grasp.

This series will continue. There’s a lot here worth learning, and I’m still very early in the process.

一个把科学的“范式转移”说了20年的人。

这几周，其实我给自己的大脑放了一些假期。我在前几篇文章里提到过：当你非常密集地与 AI 交互，而且还是多语种（中文、英文）、多语言模式（编程、形式化语言）的高密度交互之后，会明显感受到一种信息过大、信息漂移的状态，一种身心上的冲击和疲惫。

我意识到我必须切换一下，给自己换一个想法，换一件事情做。人一旦钻进牛角尖，是很难产生好的创意的。

所以我打算认真研究一下这段时间我非常在意的一个人：Stephen Wolfram。为什么是他？因为我突然意识到，Stephen Wolfram 可能是过去二十多年里，唯一一个一直在谈科学“范式转移”的人。他的书名本身就叫 The New Kind of Science。

最近我刚在网上买了这本书。其实在此之前，我已经接触过 Stephen Wolfram：他的元胞机研究、Mathematica，以及他反复提到的概念——计算不可约性、Ruliology（这是他自己造的词）。但说实话，我一直没有真正看懂他，也没有真正理解他，更没有深入下去。这些概念在当时并没有在底层逻辑上击中我，没有让我产生那种“我愿意非常严肃地投入自己宝贵的时间和脑力去弄懂他”的冲动。

我以前也提到过 Kuhn 的《科学革命的结构》，这本书这几年在我心里的重要性一直在上升。但真正让“范式转移”成为我这一代人普遍讨论话题的，其实是 2022–2023 年 AI 的商业化。而 Stephen Wolfram 很早就认定了这一现实，并且在他大量的文章中反复阐述过这一点——其中不少文章写于 2005 年、2012 年，距今已经十多年了。

借这篇文章，我想分享一下我是如何重新尝试理解他的。我想站在他的角度，去理解“计算不可约性”，去体会他的思维方式；同时借助 AI 查找相关论文。恰好我手边还有一个朋友从中国带来的儿童玩具——一台密码机。

这台密码机背后，其实隐藏着一个 NP-complete 问题。我想从 Wolfram 的全新视角和语言观出发，去研究和理解这个复杂度问题。尤其是在这几个月高强度写作的过程中，我常常会想起维特根斯坦关于语言与世界关系的那些话。只有当你完全接受了一种语言体系，你其实获得了一种全新的世界观和看问题的角度。

Wolfram从the New Kind of Science 成书那一天开始，就饱受学术共同体的极大争议。

也幸亏他是商业/企业科学家，基本完全自费，绕过了传统的学术体系和发表体系，也不需要靠学术共同体活着。这一点其实让我本人非常关注一类和他相似的人——企业科学家。比如 Elon Musk，美国国家工程院院士，但他同样不混学术界。

正因为他们不依赖学术体系生存，反而是真正“有实力”的科学家，所以他们对学术界的评价和批评，往往非常值得一看。尤其是在今天这个时代：大学高校论文大量灌水，职称体系的意义本身开始变得可疑，大学正在被 AI 逐步侵蚀知识解释权；再加上以美国为首的政府开始削减学术经费，公开质疑学术系统的现实价值——在这样的背景下，这种来自体系外的视角，本身就是一种很好的平衡。

话不多说，我直接给你看几篇文章。

这是对 Wolfram 的一篇重要批评，来自数学共同体——美国数学学会 American Mathematical Society 旗下的 Bulletin of the AMS，是一篇正式的书评。文章对他的具体论证方式、表述的严密性，以及与既有文献脉络之间的关系，提出了不少批评，比如：有些解释“说不清楚 / 不成体系 / 缺乏可检验的细节”。

https://www.ams.org/journals/bull/2003-40-01/S0273-0979-02-00970-9/S0273-0979-02-00970-9.pdf?utm_source=chatgpt.com

在复杂系统和统计物理相关的圈子里，最尖锐的一类批评则集中在一句话上：“新瓶装旧酒 + 过度宣称”。核心观点是认为 Wolfram 把复杂系统和计算理论中已经存在的很多思想重新包装了一遍，然后通过非常强的叙事方式宣称“范式跃迁”，但在对既有研究的承认和归功方式上存在问题。这一类批评中，比较有代表性的声音来自 Cosma Shalizi。

http://bactra.org/reviews/wolfram/

在这里我并不想讨论谁对谁错。因为无论是 Wolfram，还是这些写下批评的学者，他们的学识都远远高于我。

但我读完这些批评之后，尤其是这几个月我因为刻意练习写作，积累了不少中英文的语言语感，我有两个非常强烈的直观感受：

第一，Wolfram 和这些批评者，从语言体系上看，根本就不在同一个系统里。不是观点分歧，而是语言协议不同，几乎是一种“鸡同鸭讲”的状态（我们广东人常说的，俩都在自说自话，无效沟通）。

第二，这些批评文本里带有非常明显的情绪。你几乎不需要太仔细分析，就能读出一种“不满”的情绪。这一点对一个自我标榜为理性、冷静的科学家群体来说，其实是挺奇怪的。

后来我慢慢也体会到了这一点。AI 时代到来之后，很多人被指责为“民科”的感觉，其实是非常相似的——泛指那些没有教授头衔、却在认真做科学问题的人。

“好吧。”

我只能说，如果是在 AI 时代，我宁愿混成 Wolfram 这种超级富翁型民科，也比现在那些向上要不到经费、职业前景朝不保夕的教授和讲师来得更实在一些😂。

Wolfram怎么回答？他在13年前，就已经亲身经历了范式转移对他的个人冲击，而且非常有条理的跟你描述了出来。

要说他是“民科”….那就真的是可笑了。

我们现在引用他本人在2012年的文章，来看看他如何描述这种冲击的。因为他其实早就脱离学术界了，我认为在1987年他开始做软件的时候，他本人应该就有这个倾向。后来他不发论文，他自己也在此文有具体的描述，总的来说就是论文套格式，形式大于实质，而他的科学”真材实料“实质实在太多了，论文发不过来。他宁愿发博客。所以我现在理解他的想法，就是看他的本人的博客，Stephen Wolfram writings.

他为什么坚持：这是“范式转移”

他谈及对他的评论，大部分学者是一种情绪强度异常的学术现场：

“You’re destroying the heritage of mathematics…”

我就说这些批评者都是很强情绪的，对于一个学者来说，为什么要发脾气？你会对一个非严肃科学，比如撒满巫师，瑜伽师提出的科学发脾气吗？不会，因为你不会去理他。

Wolfram的回答是：

this is what a paradigm shift sounds like—up close and personal.”

范式转移首先不是新结论，而是新评价体系。

所以对方的情绪不是因为某个定理被推翻，而是因为：

• 旧的“何为科学”的标准被威胁了（论文、审稿、引用、学术网络）

• 旧的“职业人生投资”被威胁了（几十年的训练路径和声望资本可能失效）

他后面把这种深层原因说得非常赤裸，甚至分成两类“核心受威胁群体”。

他明确区分“surface reason / deeper reason”。

“there was a surface reason… and a deeper reason.”

A. 内容层面的两类恐惧（这就是范式冲突的“职业学”内核）

第一类（多为物理学家）：

“we’ve spent our whole careers barking up the wrong tree”.

这句话的含义是：如果 NKS 的计算视角成立，那些人不是“错了一点”，而是整个科研投资方向可能被判定为低收益路径。

这就是 Kuhn 式范式转移里最常见的：旧范式的成功指标，在新范式里不再值钱。

第二类（复杂性研究相关的人）：

“it’ll overshadow everything we’ve done”.

这不是“真假焦虑”，这是注意力与权威结构焦虑：谁来定义主叙事，谁就拥有学科入口、教材、基金评审的话语权。

形式层面的冲突：你做了“academic-like”，但不按“academic rules”

“academic-like, but you haven’t played by academic rules.”

这里的潜台词是：学术界有一套“合法性协议栈”，包括：

• peer review 作为准入

• references 作为关系网可见性

• 大出版社/期刊体系作为分发渠道

• 学术身份作为话语资格

而 Wolfram 的路线是：我把这套协议栈绕过去了。所以你会看到他强调：

• 我不是 academic，我不受它约束：

“I wasn’t an academic…”

这其实就是他这篇文章的核心冲突：新范式 + 新分发/验证机制，对旧系统是双重威胁。

他写书和博客….

具体内容可以去看他的原文。

https://writings.stephenwolfram.com/2012/05/living-a-paradigm-shift-looking-back-on-reactions-to-a-new-kind-of-science/?utm_source=chatgpt.com

我们这里也不再展开。

Khun Loss

我说一下Khun 库恩，哪怕他那本科学革命的结构这本书快成书一个世纪，还真的是精准的预言了我们这篇文章写到现在，这个时间点的精确过度观点。我真的忍不住要引用一下。具体内容还是要看SEP原文，链接我也贴出来了。

一次范式革命不只是“多解决了一些问题”，它也会“丢掉（甚至宣布不合法）一些旧范式曾经非常看重、并且在旧标准下算是成功的问题/解释”。

这种“丢掉的解释能力/问题集/评价标准”，就是 Kuhn loss。

它是 Kuhn 用来打掉“科学进步 = 累积式逼近真理”的关键楔子之一。

1) 到底“丢”了什么

1. 问题集改变：什么算“重要问题”变了

2. 标准改变：什么算“合格解释/好科学”变了

3. 概念与世界图景改变：同一个词在两个范式里指向的东西、允许说的话、能表达的句子集合都变了

所以 Kuhn loss 不只是“少了一个推导”，而是更像：

• 旧范式里“必须解释”的东西，在新范式里变成了

  • “不需要解释”、

  • “没意义”、

  • “形而上学”、

  • 甚至“伪问题”。

这就是他为什么说革命会改变“科学的定义”。

2) 词条里的经典例子：牛顿为何“没解释力”，却赢了

SEP 用的例子很 Kuhn：

• 在 亚里士多德/笛卡尔 的力学传统里：

  “吸引力如何可能？” 是硬指标（你必须给出接触机制/本体论解释）。

• 牛顿的万有引力在当时看起来像“隔空作用”，在旧标准下是不合格的，所以会被拒绝。

但一旦牛顿范式胜出，新共同体会把这类问题 从科学议程里踢出去（说它“不合法/不科学”）。

这就是 Kuhn loss：你从旧范式的评分表看，新范式“解释力变差了”；但从新范式的评分表看，这题根本“不该做”。

然后 SEP 也补了一刀：这个问题后来在广义相对论的框架下以另一种方式“重新出现并得到处理”。这更能体现 Kuhn 的意思：不是直线累积，而是议程反复改写。

3) Kuhn loss 和“不可通约”是什么关系

你可以把 Kuhn loss 看成 不可通约（incommensurability）的一个可观察症状。

不可通约在 Kuhn 这里不是“完全不可比较”，而是：

• 没有共同度量：因为两边在用不同的概念网、不同的问题清单、不同的评价标准。

• 因此你没法用同一个“统一指标”说：A 比 B 更接近真理、或“总体更好”。

Kuhn loss 就是告诉你：

即使新范式在某些方面更强，它也可能在旧范式曾经擅长的维度上更弱——但“更弱”这件事本身是否成立，取决于你站在哪个范式的度量体系里。

4) 为什么 Kuhn loss 对“科学理性”构成刺激

这就是当年 Kuhn/Feyerabend 被骂“反科学”的原因之一：

• 如果革命会改写问题与标准，那“理性比较”是不是变成了政治斗争？

• 如果旧成功会被新范式宣布不合法，那科学是不是不再“逼近真理”？

SEP 也强调了 Kuhn 后来的澄清：

不可通约 ≠ 不可比较；Kuhn loss ≠ 非理性。

Kuhn 的立场更像：

• 范式选择没有“中立算法”，但仍可用一组价值（accuracy/scope/simplicity/fruitfulness…）来做“有理由的争论”；

• 不同人对这些价值的权重不同 → 允许“理性分歧”。

又回到了广东人的那句俗语：鸡同鸭讲，是不是变得更贴切了？

https://plato.stanford.edu/archives/fall2019/entries/incommensurability/#RevParThoKuhInc

我随手拿了一个decoder/mastermind玩具来体验不可约

真的是因为我想到这一点的时候，这个玩具刚好就在我书桌上而已。

一个看似简单的儿童玩具，背后其实隐藏着一个 NP-complete 级别的问题。它最早的名字叫 Mastermind：一款需要两个人参与的桌游——一个人负责“设密码”，另一个人负责“猜密码”。

规则很直接：设密码者先选定一组颜色/位置组成的密码并隐藏起来；猜密码者需要在有限回合内（也就是棋盘给定的槽位/回合数限制）把它猜中。若能在限制回合内猜中，猜密码者胜；否则设密码者胜。

每一回合，猜密码者提交一个猜测，设密码者必须给出反馈。经典反馈形式是黑钉/白钉：

• 黑钉：颜色正确且位置正确；

• 白钉：颜色正确但位置不正确。

本质上，这是一条“反馈信道”，而且它必须严格满足规则——完全正确、无噪音，否则整个推理链就会崩掉。

我手上的这个电子版 Decoder 可以看作是 Mastermind 的升级版：它把“设密码的人”替换成了设备内部的隐藏算法，并且加入了更多变体反馈机制，比如：

• 绿灯表示颜色和位置都正确，

• 白灯表示颜色正确但位置不对，

• 不亮表示这种颜色根本不在密码里（或者等价地表示“颜色也不正确”的数量）。

在完全 indirect hint 的单机模式下，玩家甚至看不到位置信息——这会让状态空间急剧膨胀，远远超出 brute force 直接穷举的可行范围。而从理论上说，这背后的复杂性并不是“感觉上很难”这么简单：在 2005 年，Jeff Stuckman 和 Guo-Qiang Zhang 的论文证明了 Mastermind 是 NP-complete。

https://arxiv.org/abs/cs/0512049?utm_source=chatgpt.com

好，用了一整天的时间，我把这个玩具范围内的 800 个关卡全部解完了。我采用的是 minimax 策略：每一步选择在最坏情况下能最大幅度压缩候选空间的猜测，而不是追求“看起来聪明”的局部最优。

这里必须认真夸一句——这款来自中国计科公司的玩具产品做得非常扎实。它的反馈信道高度可靠、完全无噪声，严格遵守规则约定。能在一个面向儿童的消费级玩具里，把反馈一致性和规则执行做到这种程度，其实很厉害。

所有解法的 repo 我都已经放出来了：

不仅包含针对这台设备本身配置的求解器，也包括可扩展的通用解法，能够支持比原机更大的颜色空间和更多变体规则。可以直接复用、改参数就能跑。

就当是给订阅者的一个小福利吧。虽然我写的文章通常都很长、也不怎么“友好”，但这个玩具倒是个很好的切入口——你可以买一个给孩子，让他自己认真玩几天；等他真的卡住、开始怀疑人生的时候，你再掏出这套算法，几百关轻松带过。

他大概率会觉得你特别厉害。

从实用角度讲，这可能也是一种让小孩子突然很喜欢你的办法。

https://github.com/STEMMOM/giiker_super_decoder

玩到这个阶段，其实已经没什么“解题意义”可再展开了：一个儿童玩具，被完整求解，全部关卡通关。它在理论上当然是 NP-complete，但在这个被严格限制的规模内，五步之内必然可解。然而，这从来不是我的真正目标。我并不是想证明我解决了一个儿童玩具，而是想站在 Wolfram 的视角重新审视复杂性本身。

这里的复杂性并不来自规则——规则极其简单——而是来自这样一种结构：存在一个被隐藏的真值 (s)（密码、答案），你每一次只能提交一个 guess，系统返回一个反馈（G/W/N），你必须在有限轮数内把这个 (s) 反演出来。你想直接算出答案，却永远缺少关键信息；而你获得信息的唯一方式，是不断发起查询并接收反馈。答案不是从规则中推导出来的，而是从交互过程中被迫挖出来的。

从信息论的角度看，这个模型异常纯粹：信息单向地从隐藏真值向外泄露，困难不在于规则复杂，而在于信息被锁在一个 oracle（反馈器）后面；本质上，这是一个标准的黑箱查询问题——你每一步都在用一次 query，换取极其有限的 bit。这种结构并不只存在于玩具中，它在现实世界里广泛存在，而且复杂性往往呈指数级放大。玩具的“仁慈”在于：你被明确告知反馈信道是完全无噪声的，规则被严格执行，oracle 不会撒谎；而现实中，有谁说了反馈一定是真实的？无噪的？于是，真正值得思考的对象就变成了这个你无法看到内部机制的黑箱：你只能向它提出查询，它只返回一个反馈，而整个复杂性，正是从这种受限、单向、被遮蔽的信息交互中自然涌现出来的。

• 安全/密码学：你对系统内部状态未知，只能试探/探测（queries）

• 诊断/医学：你不知道病因，只能做检查（queries）来缩小候选

• 科学实验：你不知道规律，只能做实验（queries）得到观测，逐步收敛

• 工程调参：你不知道最佳配置，只能试运行（queries）拿到反馈再更新

当然，我也很清楚自己还处在一个非常早期的阶段，而且这类问题并不是无人涉足。事实上，在学界它早已被系统化地研究过。在理论计算机科学和“谜题复杂度”相关的研究中，Mastermind 通常被表述为一种约束满足 / 一致性判定问题，标准形式被称为 Mastermind Satisfiability Problem（MSP），并且已经被严格证明是 NP-complete——这一点前面其实已经交代过了。就经典桌游参数而言（4 位、6 种颜色、允许重复），整个状态空间只有 (6^4 = 1296) 种可能；早在 1977 年，Knuth 就给出了一个最坏情况 5 步必胜的策略。我的实现本质上也是这个级别：最坏不超过 5 步，而且我看到的文献里给出的统计结果，平均步数大概在 4 点多。所以在这个规模和框架之内，能被形式化、能被证明、能被优化的部分，其实已经被研究得相当充分了。我接下来如果继续推进，更可能会从信息熵的角度入手，把问题重新表述成“每一步查询能榨取多少有效信息”的问题。也正好，今天还偶然看到一篇挺有意思的新论文：Gür（2025）的 Weighted Entropy Approach，用加权熵作为启发式，逼近理论最优的平均步数，本质上也是把“策略”当成一种测量仪器来设计，这个思路对我来说非常有参考价值。这里就不展开了，有兴趣的可以直接去读原文。

https://arxiv.org/abs/cs/0512049?utm_source=chatgpt.com

https://www.cs.bu.edu/fac/best/res/papers/alybull86.pdf?utm_source=chatgpt.com

https://arxiv.org/abs/2511.19446?utm_source=chatgpt.com

我感兴趣的是 Wolfram会怎么看待这种问题

当然，更现实、也更符合我今年节奏的做法，是把一部分时间真正投向元胞机本身。因为在我看来，这条线索几乎是一切的起点——起点就在 A New Kind of Science。无论是那本书本身，还是此后 Wolfram 持续二十多年发表的大量文章、讲座与补充材料，核心对象的起点在元胞机。我感觉他是把它当作一种最小、最干净的计算宇宙，用来正面研究复杂性、不可约性、以及“规则极简但行为极端复杂”这一事实本身。在这条路线上，Stephen Wolfram 对元胞机的系统性、规模化、长期投入，几乎是全球独一无二的——不论是规则空间的全面扫描、演化分类、计算不可约性的提出，还是后来发展出的 ruliology 视角，在全球范围内都很难找到真正意义上的“第二家”。所以我肯定也会持续在这条上学习。

我一直觉得，Wolfram 所谓的“新科学范式”，在他当年以一个人的身份提出这样一个宏大的叙事，本身就已经非常了不起了——而且我绝对不是唯一一个对此产生强烈震动的人。关键不在于他说了什么“结论”，而在于他到底在问什么问题。你看，同样是拿到 Mastermind / Decoder 这个游戏，我的第一反应肯定是：求解。这当然很自然——计算的目的之一，难道不就是求解吗？世界里似乎存在一个“真相”，一个唯一的 secret code（或者一个极小的候选集合）；成功的指标也非常清楚：用尽量少的步数把答案锁定下来，追求收敛、收束、最短路径。这套思路在复杂度理论里再熟悉不过了：CSP / SAT / 搜索问题，加上一点策略优化，所有评价指标都围绕“最快定位唯一解”。（突然想感慨一下，好做题家的思维啊….)

但如果换成 Stephen Wolfram 的视角，问题的重心会发生明显偏移。他关心的往往不是“这个实例的答案是什么”，而是：这个规则系统本身会长成什么样。比如：它会不会涌现出普适计算能力？它的整体行为属于哪一类（简单、周期、混沌、复杂）？它有没有“捷径”，还是说本质上是计算不可约的？在整个规则空间里，这种行为到底是稀有的，还是普遍存在的？在这个框架下，成功的指标不再是“锁定唯一解”，而是发现结构现象、分类现象、识别生成机制，并回答“为什么这种现象在规则宇宙中如此常见”。

有一个让人稍微有点“背脊发凉”的念头, 我想到：元胞机是图灵完备的。这意味着你面对的不是一个“解题器”，而是一个潜在的计算宇宙。围绕这一点，Wolfram 提出了 PCE（Principle of Computational Equivalence）——说实话，这个原则我自己目前也还在消化之中，但它大致在说：一旦系统的行为超过某个极低的复杂性阈值，它们在计算能力上往往是等价的。换句话说，“能算的都差不多一样能算”，区别不在于是否强大，而在于是否可预测、是否可压缩、是否必须一步步模拟。

所以，Wolfram 并不是不“求解”，而是彻底换了问题的形状。他不是在问：“这个具体实例的答案是什么？”他更常问的是：“这个系统的行为规律是什么？”在同样是“给定规则 + 初态”的前提下，他未必在意你是否把系统推进到第 N 步、得到某一个确定图像；他可能更关心的是：能否预测某些统计量（密度、熵率、结构压缩率），能否证明或通过经验判断“只有模拟才能知道结果”，以及能否把一个看似完全不同的问题编译进这个系统，从而显示它的普适性。在 PCE 的视角里，“唯一解”从来不是中心问题；真正居中的，是不同系统是否共享同一类计算能力、同一类行为类型。这正是我开始慢慢意识到的、与“解题直觉”几乎正交的一种世界观。

这个系列我会持续更新，这是一个值得长期学习和探讨的议题。说实话我的认识目前还算很浅。

That time lag is exactly the distance between me and top-tier scientists: the same paragraph, when written, is already aimed at the future; while I need years of friction with the real world—projects failing, being rebuilt, repeatedly crashing into the question of “how a system takes responsibility over time”—before I can finally understand what it’s actually saying.

More importantly, you don’t need a PhD to understand this piece, nor do you need to cross some “elite” intellectual gate. In a certain sense, AI really has pushed knowledge toward a kind of egalitarianism—not only by making information easier to access, but by giving us the ability to wash it, to sift out what truly matters. It drags many so-called academic authorities—once anchored mainly by status, networks, or journals—back to a more ordinary but far stricter standard: Does it explain the world? Can it be validated in practice? Can it be reproduced?

In an era where paper counts have exploded, a large fraction of academic publishing produces little real incremental value beyond paying to publish, cross-citing, and helping authors accumulate credentials. Worse, reproducibility itself is increasingly in doubt. Against that backdrop, Wolfram’s forward-looking vision remains dramatically under-recognized by the public. I even think he is already one of the foundational figures of the next scientific paradigm—only this fact hasn’t yet been absorbed into the mainstream narrative.

Of course, to truly read this article properly, you need at least an intuitive grasp of one concept: computational irreducibility. Many years ago, when I first read Wolfram’s A New Kind of Science, I almost had no idea what he was talking about. Only later—through six to ten years of life and project experience—did I gradually begin to internalize what he meant by “irreducibility.”

That’s also why he has become one of the most heavyweight thinkers on my personal list. And he’s still alive, still actively researching, still producing new work. That means what he says today isn’t a closed “past-perfect” academic conclusion—it’s a paradigm still being built in real time. I care about every sentence he writes. Many of the quotes I reference are not only from this article, but drawn from his talks and other writings as well; I won’t expand on that here.

https://writings.stephenwolfram.com/2024/03/can-ai-solve-science/

AI Won’t Be Able to “Do Everything / Solve Science”

• There is a somewhat widespread belief that AI will eventually be able to “do everything.”

• Wolfram uses science as the ultimate stress test: can AI come in and, in one sweep, close out centuries of accumulated unsolved scientific problems?

• His answer is: “inevitably and firmly no.”

Important: he is not denying AI’s practical usefulness; he is rejecting an “endgame omnipotence” narrative.

“there’s a somewhat widespread belief that eventually AI will be able to ‘do everything’” (Writings by Stephen Wolfram)

This applies not only to people who were excited from day one, but also to those who began skeptical and later became fervent. “AI can’t do everything” is also something I deeply want to emphasize right now. Wolfram gives us a kind of orienting guidance. When you shrink the scope of what you think AI can do, paradoxically, the set of things you can do becomes larger—because your precision increases and your positioning becomes clearer. At least, that’s been true for me.

“So what about science?” (Writings by Stephen Wolfram)

He then explains why science is such a decisive stress test: science is the largest intellectual edifice our civilization has built—yet it remains unfinished—so it’s the sharpest way to interrogate what “do everything” really means.

“the single largest intellectual edifice of our civilization” (Writings by Stephen Wolfram)

“there are still all sorts of scientific questions that remain.” (Writings by Stephen Wolfram)

He’s not asking whether AI can help science. He’s asking whether it can finish what’s left.

“So can AI now come in and just solve all of them?” (Writings by Stephen Wolfram)

“the answer is inevitably and firmly no.” (Writings by Stephen Wolfram)

No.

“But that certainly doesn’t mean AI can’t importantly help…” (Writings by Stephen Wolfram)

And that “but” is crucial. What AI is particularly good at—and what we should study seriously—starts right there. That’s where the value is.

Wolfram’s “Practical Positioning” for AI: Linguistic Interface + High-Level Autocomplete of Conventional Wisdom

The second paragraph already contains his measured affirmation:

• LLMs provide a new kind of linguistic interface, connecting human intent to existing computational capabilities (his example: the Wolfram Language).

• Through “conventional scientific wisdom,” LLMs can function as high-level autocomplete, filling in “conventional answers” or “conventional next steps.”

This section is key. He acknowledges that LLMs are very strong—but strong in making existing paradigms smoother to use, not in producing genuinely new paradigms of discovery.

1) LLMs as a new “linguistic interface”

“At a very practical level, for example, LLMs provide a new kind of linguistic interface to the computational capabilities that we’ve spent so long building in the Wolfram Language.” (Writings by Stephen Wolfram)

2) High-level autocomplete via “conventional scientific wisdom”

“And through their knowledge of ‘conventional scientific wisdom’ LLMs can often provide what amounts to very high-level ‘autocomplete’…” (Writings by Stephen Wolfram)

“…for filling in ‘conventional answers’ or ‘conventional next steps’ in scientific work.” (Writings by Stephen Wolfram)

Now, I want to single out “linguistic interface”, because it matters enormously.

Right now our imagination of it is far too narrow—basically reduced to a chat window, plus some ordinary programming use cases. Let’s be honest: most of us “mere mortals” are still operating at this level—open a window, drop a prompt, get an output that looks plausible, and feel as if the world has been rewritten.

But here’s the point: the interface itself contains massive room for systematic engineering.

The world is not limited to a chat window just because that’s all we can currently picture. The chat window is merely the most primitive, crude form of interface.

The pleasure of “AI vibe coding” is, in essence, a short-term dopamine hit from interface upgrades: work that used to cost you hours of intense cognitive effort can now be “done” with a single prompt, and it feels great… but is that all? If we treat that as the endpoint, we’ve merely installed a new kind of text slot machine inside our workflows.

The real question is not “can it give you an answer?” The real question is:

Can this interface carry real-world responsibility?

In many of my earlier writing I keep returning to a few concepts:

Reproducibility. Auditability. Portability.

These are not engineering vanity metrics; they are institutional properties required for anything that enters real decision-making. (Look at any organizational process, legal process, judicial process, or audit process—same structure.)

Because if you zoom out, you realize: human daily life, organizational life, corporate governance, even national governance—an enormous portion of decisions are, at their core, a linguistic interface. We use language to raise issues, describe risk, exchange commitments, write rules, issue judgments—and then we convert those words into actions and consequences.

So here’s the question: can we let a large language model make those decisions? Do we dare?

A single model’s judgment is inherently environment-dependent. The same sentence, the same question, can change with context. And constraints written in a prompt are, fundamentally, soft constraints—not machine-executable if-else logic. More dangerously, the model will ignore constraints in order to “complete the language” and deliver an answer that looks like an answer—because its objective is not “obey the institution,” but “produce coherent text.”

Predict the next token.

It won’t say: Error (with a clear error code).

It must give you something. Its default behavior is to disguise uncertainty as certainty, and to disguise indeterminacy as a decisive ruling.

Has this problem been solved?

No.

So do we have an interface architecture where, when language enters the system:

• constraints are hard—compilable and verifiable

• failure is allowed—explicit throw error / require override

• decisions are replayable and accountable—not a one-off chat session

• outputs must pass institutional audit and gating before they touch reality

If not, then the “vibe coding” pleasure we’re enjoying today is still just fireworks in low-risk environments. We remain an entire institutional engineering chasm away from decision systems that can actually carry human society.

And isn’t that exactly where developers should invest resources and attention? Isn’t this a career-grade, high-value path that can be reasoned out ahead of time—especially for those of us who are not academic researchers, but application-oriented builders? (laugh)

He Abstracts the History of Science into Two Representation Revolutions: Mathematical Representation → Computational Representation

He then proposes a deeper evaluative framework:

• Three centuries ago, science underwent a leap because we learned to represent the world using mathematics.

• Today, we are in the middle of a leap toward a fundamentally computational representation of the world (which he sees as a more foundational paradigm shift).

This move effectively raises the bar:

If you ask whether AI is “changing science,” you first have to clarify: is AI helping mainly at the tool layer, or is it introducing a new scientific paradigm at the representation layer?

“Three centuries ago science was transformed by the idea of representing the world using mathematics.” (Writings)

“And in our times we’re in the middle of a major transformation to a fundamentally computational representation of the world (and, yes, that’s what our Wolfram Language computational language is all about).” (Writings)

The “Tool Layer vs. Paradigm Layer” Question

“So how does AI stack up?” (Writings)

“Should we think of it essentially as a practical tool for accessing existing methods, or does it provide something fundamentally new for science?” (Writings)

What does this mean? For someone encountering his worldview for the first time, it can feel unfamiliar. Computational irreducibility isn’t merely a technical term—it’s a worldview switch. It says that many systems are not something you can “skip through” by being smarter; instead, you often have to do the computation all the way through. (If this feels impossible to grasp, you really should study cellular automata; the mechanism makes the idea tangible.) What you can do, more often than not, is find pockets of reducibility—places where you can compress locally and predict locally. Remember this phrase: pockets of reducibility.

When Demis Hassabis talks about whether nature is modelable, I think his intuition is very similar. In his interview with Lex Fridman (I wrote a lot of threads about it on X, but they’re hard to locate now; later I moved my longer essays to Substack), he used protein folding as an analogy for this idea of “pockets.” It’s like an enormous wilderness: there are always a few footpaths that people have carved out. If you find the path, everything suddenly feels easy. If you don’t, you’re stuck with brute force. The underlying structure is: pocketed reducibility / otherwise brute force:

“if there’s not [patterns]… you have to do brute force.” (Lex Fridman)

And the key to why many natural problems look combinatorially explosive yet still become modelable:

“there’s some structure… some gradient you can follow.” (Lex Fridman)

Read these side by side with Wolfram:

• Wolfram: global irreducibility prevents systematic “jumping ahead,” but there are always pockets of reducibility.

• Demis: if the space has structure (a gradient/landscape), you can search effectively; if it doesn’t, you’re stuck with brute force.

So when I say “Wolfram and Demis are similar—irreducibility,” I mean this:

The world does not guarantee shortcuts everywhere. What we call intelligence is often just the ability to quickly find where structure exists and where it doesn’t.

And irreducibility feels like an “ocean of possibilities” precisely because it yanks you away from “capability worship” and brings you back to computation and institutions:

• when you must simulate, enumerate, and complete the computation;

• when you can compress, abstract, and form a narrative;

• and most importantly: when you plug AI into real-world decision-making, which parts you must not let it “guess through,” and instead must ground in hard structures that are reproducible, auditable, and able to throw explicit errors.

Honestly, I’m still learning too. If I can internalize even a small fraction of what these giants are pointing at, that’s already a huge win.

The Hardest Core Argument: Computational Irreducibility as a “Physics-Level Limit” AI Cannot Cross

This article is powered by the engine of computational irreducibility.

• Treat natural systems as computational processes: the system itself is “computing” its evolution.

• We (or AI) must also compute in order to predict it.

• The Principle of Computational Equivalence: these computations are, in principle, comparable in sophistication.

• Therefore, you cannot expect AI to “jump ahead” and skip the evolution steps systematically.

• So fully “solving science” is impossible.

The kind of “endgame shortcut” you want simply doesn’t exist for many systems. It’s not that you didn’t train enough—the world doesn’t grant that shortcut.

This is even harder to understand—so let’s unpack it:

1) The world as computation: the system is “computing” its behavior

Wolfram first sets “world = computational process” as a foundational premise:

“we can think of everything that happens as a computational process.” (Writings)

“The system is doing a computation to determine its behavior.” (Writings)

He’s not saying “we simulate the world using computation.” He’s saying: the world itself is computation.

2) We (or AI) must compute too, in order to predict it

He then puts the observer (human or AI) into the same computational frame:

“We humans—or, for that matter, any AIs we create—also have to do computations” (Writings)

“to try to predict or ‘solve’ that behavior.” (Writings)

Meaning: if you want to know what will happen, you must pay computational steps—you don’t get a free pass just because your output looks like “human intuition in text form.”

3) PCE: the “sophistication” ceiling is of the same order

He uses the Principle of Computational Equivalence to nail down why you can’t systematically skip steps:

“the Principle of Computational Equivalence says that these computations are all at most equivalent in their sophistication.” (Writings)

This is the “physics-level nail”: the system computes; you compute; the ceiling is of the same order—so there is no universal “god’s-eye shortcut.”

4) Therefore, no systematic “jump ahead”

He basically uses the exact phrase “jump ahead”:

“we can’t expect to systematically ‘jump ahead’ and predict or ‘solve’ the system” (Writings)

“it inevitably takes a certain irreducible amount of computational work” (Writings)

The key word is systematically. He isn’t saying you can never skip anything; he’s saying there is no broadly reliable method to skip the evolution itself. Those occasional “skips” are exactly what he means by pockets of reducibility.

5) Therefore, “solving science” is impossible: irreducibility is the ceiling

He concludes that scientific power hits a hard limit:

“we’ll ultimately be limited in our ‘scientific power’ by the computational irreducibility of the behavior.” (Writings)

And then he adds the blunt line (this one really matters):

“there just won’t be any way—with AI or otherwise—to shortcut just simulating the system step by step.” (Writings)

Now it starts to feel “mystical” and subtle. Here’s my own way of understanding it: the world is computing (I can’t fully explain what “the world computing” means). Let me offer an analogy—are your DNA and cells “computing” the protein structures inside your body? This is still a metaphor: the world advances its states according to its own rules, like a process running itself. And you’re computing too—using your mind, paper, machines, models—to try to know in advance what will happen.

The key is: these two kinds of “computation” are fundamentally on the same level. You are not outside the universe holding a remote control; you are a computational device inside the universe. Trying to use one computation to dominate another and systematically “skip steps” is, in most cases, impossible. Your computation will not be more “clever” than the world’s (it can only be weaker, honestly), because you’re still running rules within the same physical universe. The only times you “win” are when you happen to find a shortcut pocket—not because you became God, but because the system allows compression at a particular scale, allows simplification, allows you to say something ahead of time.

And every computation costs energy. (Landauer’s principle and the rest—no need to go deep here.) I increasingly treat this as a kind of base tax in reality. If you want more detail, you pay more steps. If you want more precision, reproducibility, and accountability, you pay more structural cost. You can bluff with language for a while, but once it touches execution, you must pay the bill: time, compute, energy, even human attention. “Irreducibility” means: in many places, you can’t avoid paying that bill.

So when we shift from “Can AI do everything?” to “Can AI help us make decisions?”, the question becomes sharp: if the world’s evolution must be computed step by step, why is a model entitled to output something that looks like a conclusion or a ruling without paying comparable cost? Even worse, because the model is driven to continue the language, it tends to package uncertainty as a “sayable result,” rather than behaving like a real system: throw an error when it must, halt when it must, demand more information when it must. (This “ability to throw an error” is extremely important; I’ve discussed it in detail elsewhere. Systems that cannot error out are dangerous.)

That’s why I believe what truly needs to be engineered is not “making AI answer better,” but giving the linguistic interface institutional constraints that feel as strict as conservation laws: make it expensive when it must be expensive, and make it stop when it must stop; make it able to admit “there is no shortcut here,” rather than handing you a cheap illusion. Otherwise, the computation cost you must pay gets silently converted into a more hidden cost: misjudgment, misplaced trust, mistaking approximation for conclusion, mistaking smoothness for reliability.

This is also why I keep emphasizing: reproducibility, auditability, portability. These aren’t engineering OCD; they are the hard conditions that keep language from collapsing when it enters real decision-making under an irreducible world. You can’t defeat the world’s computation. The only thing you can do is acknowledge where you must compute and where you can compress—and then write that into structure, so the system can take responsibility for every judgment it makes over time.

This is honestly the limit of how far I can explain it. I can’t go further than this.

So what’s the key? Wolfram’s greatest value—his biggest gift to me—is exactly here: he tells us our goal is to find countless “pockets of reducibility.”

Key Detail: Irreducibility Does Not Mean “Nothing Can Be Done”

Many people misread this.

Wolfram’s point is:

• The overall behavior may be irreducible,

• but there must exist infinitely many “pockets of reducibility,”

• and science is possible precisely because we usually work inside those pockets—regularities, models, compression, and understanding all come from them.

So his conclusion is essentially two-part:

1. AI cannot enable us to systematically bypass irreducibility.

2. AI may help us find pockets of reducibility more efficiently.

That’s why he can say “the endgame is impossible” while still spending so much time discussing what “AI can do in science.”

This is not an argument for giving up.

1) He first poses the key question: if things are irreducible, why is science possible at all?

He immediately asks:

“But given computational irreducibility, why is science actually possible at all?” (Writings)

This pulls the reader out of “despair/nihilism”: if you can’t skip steps, wouldn’t science collapse? That’s exactly where many people misunderstand him—he’s not being pessimistic.

2) The core answer: overall irreducibility implies infinitely many “pockets of reducibility”

His “pocket theory”:

“whenever there’s overall computational irreducibility, there are also an infinite number of pockets of computational reducibility.” (Writings)

What a “pocket” means:

“there are always certain aspects of a system about which things can be said using limited computational effort.” (Writings)

Why science relies on pockets:

“these are what we typically concentrate on in ‘doing science’.” (Writings)

So what are we supposed to do?

AI Cannot Systematically Cross Irreducibility (the endgame is impossible)

Outside the pockets, irreducibility still brings limits and surprises:

“there are limits to this—and issues that run into computational irreducibility.” (Writings)

“we just can’t answer” / “surprises” (Writings)

He restates that you cannot shortcut the full evolution:

“there just won’t be any way—with AI or otherwise—to shortcut… step by step.” (Writings)

AI cannot let us systematically bypass irreducibility. Human smallness does not disappear. AI cannot challenge God.

AI May Help Us Find “Pockets of Reducibility” Faster

Still the pocket theory:

“AI has the potential to give us streamlined ways to find certain kinds of pockets of computational reducibility.” (Writings)

The key phrase is “streamlined ways”: not “prove everything / solve everything,” but “find certain kinds of pockets more smoothly.”

Why He Can Deny the “Endgame” Yet Still Talk About What AI Can Do

Because in his framework:

• Irreducibility explains why “solve science / do everything” is impossible (the ceiling),

• pockets of reducibility explain why science still works and why tools remain useful (the space),

• AI is placed in a very specific role: accelerating the discovery and exploitation of pockets, not creating shortcuts where irreducibility rules.

The practical takeaway is: remember what AI can do, and try to find your own niche in your domain—some “pocket of reducibility” that AI can help reveal.

Neural Nets Are Good at “Roughly Right,” Not at “Getting Every Detail Exactly Right”

Later in the article he demonstrates this with a series of experiments:

• Predicting functions: fits the past, but the future details collapse.

• Predicting cellular automata: gets the simple parts right, fails on complex parts; errors compound.

• Predicting the three-body problem: can “memorize” simple trajectories, struggles with complex ones.

• Autoencoder compression: compresses data similar to its training set; can’t compress through irreducibility.

His summary is basically:

ML is often “roughly right,” but “nailing the details” isn’t its strength.

This is his experience-based support for why LLMs/NNs hit a wall in science.

His Philosophical Reading of AlphaFold: Much of the “Success” Depends on Human Criteria

• Protein folding itself is not a human task.

• But what we count as “correct” (shape, function, secondary structure, etc.) is a human criterion.

• So neural nets may succeed partly because they capture pockets of reducibility aligned with human perception/classification standards.

• But with more complex or “alien” proteins, surprises and failures can still appear.

The philosophical point is:

AI often succeeds “within human-defined usable criteria,” not “in fully objective microscopic truth.”

This can feel “mystical” again—but it’s directly connected to Demis Hassabis and AlphaFold in a very concrete way.

Demis is a generational prodigy, and AlphaFold truly did open an era. Both he and Wolfram are scientists I follow closely. But to be clear: Wolfram is not denying AlphaFold’s achievement. He’s using AlphaFold as a powerful example to illustrate a deeper structural claim: the biggest AI breakthroughs are often not “solving the entire microscopic reality of the world,” but precisely hitting a valuable pocket of reducibility.

Their language systems are very different, so they don’t look like they’re speaking the same “dialect.” But I think the structure of what they’re saying is isomorphic.

In Wolfram’s framing, protein folding is not “human-centered”; yet we never evaluate AlphaFold by demanding the exact position of every atom at every moment. We want results that are usable and verifiable for biology: whether the overall structure is right, whether key features are right, whether the functional shape is right. In other words, our definition of “correctness” already lives in a region that is compressible, generalizable, and operational.

That’s where AlphaFold’s greatness becomes visible: it isn’t “explaining the world with smarter language,” but using powerful learning under massive data and structural constraints to identify repeated, stable, reusable regularities. That’s exactly what Wolfram calls a pocket of computational reducibility: even in a world that may be globally irreducible (and where you can’t systematically skip steps), there are still local regions that can be compressed, modeled, and reliably exploited. AlphaFold’s victory is that it locked onto a particularly valuable pocket with extraordinary precision—and engineered it into a scalable tool.

So when Wolfram talks about “the eye of the beholder,” he isn’t diminishing AlphaFold. He’s pointing to a key reality: science and engineering ultimately define success around human-relevant metrics, scales, and criteria—and pockets of reducibility often appear precisely at those levels, making the complex world compressible, predictable, and actionable.

I believe Wolfram fundamentally endorses the AlphaFold pattern:

AlphaFold didn’t “pierce irreducibility”—it found one of the most valuable pockets of reducibility inside an irreducible world.

“Science as Narrative” as His Landing Point for Why Humans Remain Irreplaceable in Science

He emphasizes:

• Science has traditionally been about forging the world into a narrative humans can think and talk in.

• Irreducibility implies that in many places you can only give “100 computational steps,” which is not a human narrative.

• Human narrative needs waypoints: familiar theorems, concept chunks, language constructs.

• Wolfram Language is, in essence, an attempt to manufacture such “human-assimilable waypoints.”

• AI may help with naming or aligning vocabulary, but it’s not guaranteed that every pocket of reducibility can be covered by human concepts (interconcept space).

This directly answers the line I’ve been developing about “psychological immersion / interface protocols”:

LLMs are strongest at narrative and interface; but scientific progress relies on computable, reproducible, and structurally organized waypoints—not on smooth conversation.

He defines science as a narrative-engineering project:

“the essence of science… casting it in a form we humans can think about” (Writings)

“provide a human-accessible narrative”

Irreducibility makes that narrative impossible in many places:

“computational irreducibility… shows us that this will… not be possible” (Writings)

“It doesn’t do much good to say ‘here are 100 computational steps’”

To translate a non-human computation chain into a human narrative, you need waypoints:

“we’d need ‘waypoints’ that are somehow familiar”

“pieces that humans can assimilate”

He elevates this into the mission of computational language design:

“capture ‘common lumps of computational work’ as built-in constructs”

“identifying ‘human-assimilable waypoints’ for computations”

“we’ll never be able to find such waypoints for all computations”

And he warns that even if AI finds reduced representations, they may not map into our current concept system:

“not part of our current scientific lexicon”

“there often won’t be… a ‘human-accessible narrative’ that ‘reaches’ them”

Meaning: the pocket may exist, but we may not have words for it; AI can propose names, but that doesn’t guarantee those names become usable human waypoints.

Wolfram is effectively placing LLM strength where it belongs: narrative and interface—while insisting that what actually drives science (and what matters for governance/decision systems) is computable, reproducible, structurally organized waypoints—not a smooth chat.

LLM can make you feel like you understood; but only waypoints (executable constructs / auditable intermediate states) can make you truly reproducible, portable, and accountable.

I personally don’t fully grasp what “waypoints” refers to in practice.

The Architecture He Ultimately Bets On: AI + the Computational Paradigm

Near the end he argues:

• AI is a new way of leveraging reducibility (capturing pockets),

• but for fundamental discovery it’s weaker than the computational paradigm plus irreducible computation (enumeration, simulation, system exploration),

• the best path forward is combining the strengths of AI and the formal computational paradigm.

In plain terms:

• AI: navigation, candidates, intuition, interface, humanization, cross-domain analogy

• Computational systems: verifiable derivation, reproducible execution, enumeration, rigorous structuring

• Irreducible computation: true “new terrain discovery” (not “paper-like” textual novelty)

I am also not sure how to explain this part.

这篇文章原本只是我用来阐述自己在 2026 年对大模型的看法、以及长期规划的一段附录。但它本身，其实是一篇 Wolfram 对 AI、以及未来科学范式的重磅阐述。值得反复、深度研读。文章发表于 2024 年 3 月，可它真正“在信息密度上击中我”的时刻，却发生在 2025 年底。他在那个时候早就给我们指出了AI的实质。

这种时间差，正是我和顶尖科学家之间的距离：同一段文字，写出来的时候已经在指向未来；而我需要经历一段现实世界的摩擦、项目的失败与重建、对“系统如何在时间中承担责任”的反复撞墙，才终于读懂它到底在说什么。

更重要的是：理解这篇文章并不需要博士学位，也不需要某种“高深门槛”。在某种意义上，AI 的确推动了知识的平权，不仅仅是“更容易获取知识”，更是让我们有能力去洗刷、筛出真正有价值的知识。它把很多过去只能靠身份、圈层、期刊来锚定的所谓“学术权威”，重新拉回到一个更朴素也更严苛的标准：能否解释世界，能否落地验证，能否复现。

在论文数量爆炸的时代，许多学界论文除了花钱发表、互相引用、帮助作者获取职称之外，并不产生任何真实的增量价值；更糟的是，可复现性本身都越来越可疑。相较之下，Wolfram 的前瞻性反而远远没有被大众真正认识到。我甚至认为，他已经是下一代科学范式的奠基者之一，只是这个事实还没有被“主流叙事”及时吸收。

当然，要真正读懂这篇文章，你需要先对一个概念有基本直觉：计算的不可约性。我很多年前第一次读 Wolfram 的《A New Kind of Science》时，几乎完全不知道他在讲什么。后来，靠 6 到 10 年的人生与项目体验，才慢慢的领会他这个“不可约”。

也正因此，他在我心目中成为了极其靠前的重磅人物。而且，他仍然在世、仍在积极研究、仍在持续输出。这意味着：他现在说的每一句话，都不是“过去完成时”的学术结论，而是仍在推进中的范式构建。他说的每句话，我都很在意。有很多引用不是这篇文章，而是集合他的演讲和其他文献，这里不赘述了。

https://writings.stephenwolfram.com/2024/03/can-ai-solve-science/

AI 不可能“do everything / solve science”

• 社会上有人相信 AI 最终能“做一切”

• 他把“科学”作为终极压力测试：能不能把几百年累积的科学未解问题一口气解决？

• 他的答案是“inevitably and firmly no”

注意：他不是在否认 AI 的实用价值，而是在否认一种“终局式全能”叙事。

“there’s a somewhat widespread belief that eventually AI will be able to ‘do everything’” (Writings by Stephen Wolfram)

包括很多一开始怀疑的，一开始狂热的。AI can’t do everything, 也是我现在非常想强调的事情。他给我们一种定位型的指引。这个要跟他对齐，当你能做的事情范围缩小的时候，其实你能做的事情反而“多了”。因为你的精度提高了，你的定位清晰了，至少对我来说是这样。

“So what about science?” (Writings by Stephen Wolfram)

然后他给出“科学为何是终极压力测试”的理由：科学是人类文明最大智识工程，但仍然没做完——所以最能检验“do everything”的含义。

“the single largest intellectual edifice of our civilization” (Writings by Stephen Wolfram)

“there are still all sorts of scientific questions that remain.” (Writings by Stephen Wolfram)

不是说“AI 能不能帮科学”，而是问——能不能把剩下的全部收尾。

“So can AI now come in and just solve all of them?” (Writings by Stephen Wolfram)

“the answer is inevitably and firmly no.” (Writings by Stephen Wolfram)

不行！

“But that certainly doesn’t mean AI can’t importantly help…” (Writings by Stephen Wolfram)

这个就很重要了，他这个but！ AI特别擅长什么，就是我们该去研究的事情。有价值的事情。

他给 AI 的“现实定位”：语言接口 + 传统智慧的高层自动补全

• LLM 是一种新的 linguistic interface（语言接口），能把人类意图接到既有计算能力上（他自己的例子是 Wolfram Language）。

• LLM 还能根据“conventional scientific wisdom（惯常科学智慧）”做 high-level autocomplete：给“惯常答案 / 惯常下一步”。

这一段很关键：

他承认 LLM 很强，但强在——把既有范式用得更顺，而不是生成“新范式的真发现”。

1) LLM 是新的 “linguistic interface（语言接口）”

“At a very practical level, for example, LLMs provide a new kind of linguistic interface to the computational capabilities that we’ve spent so long building in the Wolfram Language.” (Writings by Stephen Wolfram)

2) LLM 作为“高层自动补全”：基于“conventional scientific wisdom”

“And through their knowledge of ‘conventional scientific wisdom’ LLMs can often provide what amounts to very high-level ‘autocomplete’…” (Writings by Stephen Wolfram)

“…for filling in ‘conventional answers’ or ‘conventional next steps’ in scientific work.” (Writings by Stephen Wolfram)

好，我想把 linguistic interface 这个词单拎出来说，因为它太重要了。

我们现在对它的想象还非常狭窄：基本等同于“一个大模型对话窗口”，再加上一些普通的编程应用。说白了，吾辈乃凡人，我们大多数人目前也就停留在这一层：开个窗口，丢个 prompt，得到一段看起来挺像样的输出，然后觉得世界被改写了。

但问题是：光是“接口”本身，就有巨大的系统性开发空间。

并不是你现在只想到窗口，这个世界就只剩窗口。窗口只是最原始、最粗糙的一种接口形态。

所谓 “AI vibe coding” 的爽感，本质上也只是接口升级带来的短期快感：你以前要烧脑半天的工作，现在一个 prompt 立刻给你一份“能跑起来”的东西，于是你很爽…但就到此为止了吗？如果把这当成终点，那我们其实只是把一个新的“文本老虎机”换进了工作流。

真正关键的不是“它能给你答案”，而是：这个接口能不能承载现实世界的责任。

我在很多文章里反复强调过几个词：

可复现、可审计、可迁移。

这是任何进入“现实决策”的系统必须具备的制度属性。（你去看看任何组织流程，法律流程，裁判流程，审计流程，这里不赘述）

因为你放眼看去：

人类的日常生活、组织协作、公司治理、甚至国家治理——大量关键决策，归根到底都是一种 linguistic interface：我们用语言提出议题、描述风险、交换承诺、写下制度、做出裁决，然后把这些语言变成行动与后果。

那问题来了：这些决策能靠大模型吗？你敢信吗？

单个模型的决策天然具有强烈的环境依赖：同一句话、同一个问题，换个上下文就变；而 prompt 里写的约束，本质上是软约束，不是机器可执行的 if-else。更危险的是：模型为了“完成语言”，为了给你一个看起来像答案的答案，它是会主动忽略约束的。因为它的目标函数不是“遵守制度”，而是“产出连贯文本”。Predict the next token!

它不会说：Error （跟一个编号）。

它必须给你结果。它的默认行为是把不确定性伪装成确定性，把不可判定伪装成可裁决。

这个问题解决了吗？

没有嘛。

我们有没有一种接口架构，能让语言进入系统时：

• 约束是硬的，可编译、可验证的

• 出错是允许的，能明确 throw error / require override

• 决策是可回放、可追责的，而不是一次性的文本会话

• 输出进入现实之前必须经过制度化的审计与门控

如果没有，那我们现在享受的“vibe coding”爽感，本质上还只是低风险场景的烟花。离真正能承载人类社会的决策系统，还差一整条制度化的工程鸿沟。难道这个不值得开发者投资资源，精力去研究吗？难道这不是一条推演出来的职业康庄大道吗？（笑）对于我们这种非科研，偏应用向的开发者来说。

他把科学史抽象成两次表征革命：数学表征 → 计算表征

他接下来提出一个更深的判断框架：

• 300 年前：科学的跃迁来自“用数学表示世界”

• 现在：我们正在经历“用计算表示世界”的跃迁（他认为这是更根本的范式）

这一步其实是在“抬高标准”：

如果你问他 AI 是否“改变科学”，你得先说明：AI 到底是在工具层帮忙，还是在表征层带来新的科学范式。

“Three centuries ago science was transformed by the idea of representing the world using mathematics.” (Writings)

“And in our times we’re in the middle of a major transformation to a fundamentally computational representation of the world (and, yes, that’s what our Wolfram Language computational language is all about).”

工具层 vs 范式层”的问法

“So how does AI stack up?” (Writings)

“Should we think of it essentially as a practical tool for accessing existing methods, or does it provide something fundamentally new for science?” (Writings)

什么意思啊，理解这个对于初次接触他理念的人来说有些陌生。“computational irreducibility（计算不可约性）”确实它不是一个“技术术语”，而是一个世界观开关：它在说，很多系统不是“更聪明就能跳步”，而是必须把计算做完（实在看不明白的，一定要去研究元胞机的机制）；你能做的，往往只是找到一些“可约口袋”，在局部压缩、在局部预测。记住可约口袋这个词。

Demis Hassabis 在谈自然界可建模性时，我认为他的意思是差不多的。他对Lex Fridman 的那次访谈，我其实在X上写了很多文章，但是现在不大好找了。后来我就把我想写的长篇文章都放在Substack. 他说的，当时他类比的蛋白质折叠，就是类似这种口袋。意思是一个非常广阔的天地，总有一些人踩出来的小路，找到这条小路，你就爽歪歪。没找到，你就brute force. 他背后就是“口袋可约 / 否则暴力”的结构：

“if there’s not [patterns]… you have to do brute force.” (Lex Fridman)

以及他解释为什么很多自然问题“看起来组合爆炸，但仍可被模型化”的关键点：

“there’s some structure… some gradient you can follow.” (Lex Fridman)

把这两句和 Wolfram 放在一起读，

• Wolfram 说：整体不可约会阻止你“系统性跳步”，但总有“pockets of reducibility（可约口袋）”。

• Demis 说：如果空间里有结构（梯度/景观），你就能有效搜索；如果没有结构，那就只能 brute force。(Lex Fridman)

所以“他和 Demis 很相似——不可约性”,

世界并不保证处处有捷径。所谓智能，很多时候只是更快地找到哪些地方有结构、哪些地方没结构。

而“不可约性”如“浩瀚烟海”，就在于它会把你从“能力崇拜”直接拉回到计算与制度：

• 什么时候必须模拟、必须枚举、必须做完计算；

• 什么时候可以压缩、可以抽象、可以形成叙事；

• 以及最关键的：当你把 AI 接进现实决策时，哪些部分不能让它“猜过去”，必须落到可复现、可审计、可报错的硬结构里。

说真的，我自己也在学习过程中，只能跟大佬们学习一些哲学的根基和思想。具体能实现人家的百分之一，也是赚到了。

最核心的硬论证：计算不可约性 = AI 无法越过的“物理级上限”

这篇文章的发动机就是“computational irreducibility（计算不可约性）”。

• 把自然系统当作计算过程：系统自己在“算”它的演化

• 我们（或 AI）要预测它，也必须做计算

• Principle of Computational Equivalence：这些计算的“计算强度”在原则上相当

• 所以你不能指望 AI 系统性地“jump ahead”跳过演化步骤

• 因而“完全 solve science”不可能

你想要的那种“终局捷径”，在许多系统上根本不存在。不是你训练不够，是世界不给你捷径。

这个就更难理解了。我们拆开说一下：

1. 把自然系统当作计算过程：系统自己在“算”它的演化

Wolfram 先把“世界=计算过程”作为底层前提抛出来：

“we can think of everything that happens as a computational process.” (Writings)

“The system is doing a computation to determine its behavior.” (Writings)

这里他不是说“我们用计算去模拟世界”，而是说：世界本身就在计算。

2. 我们（或 AI）要预测它，也必须做计算

紧接着他把预测者（人或 AI）放回同一个“计算”框架里：

“We humans—or, for that matter, any AIs we create—also have to do computations” (Writings)

“to try to predict or ‘solve’ that behavior.” (Writings)

意思是：你想“知道它会怎样”，你也得付出计算步骤，不是靠“更像人类的直觉文本”就能免单。

3. Principle of Computational Equivalence：这些计算在原则上相当

他用 PCE（计算等价原理）把“为什么没法系统性跳步”钉死：

“the Principle of Computational Equivalence says that these computations are all at most equivalent in their sophistication.” (Writings)

这句是整段的“物理级硬钉子”：系统在算，你也在算，但计算强度上限是同阶，所以不存在一个普遍可用的“上帝视角捷径”。

4. 所以不能指望 AI 系统性地 “jump ahead” 跳过步骤

他几乎是用你那句 “jump ahead” 的原词来写的：

“we can’t expect to systematically ‘jump ahead’ and predict or ‘solve’ the system” (Writings)

“it inevitably takes a certain irreducible amount of computational work” (Writings)

关键词是 systematically：

不是说“某些局部场景偶尔能跳一下”，而是说不存在一套普适方法能长期稳定地跳过演化本身。这个跳一下，就是他说的可约口袋。

5. 因而“完全 solve science”不可能：上限来自不可约性

他把结论落到“科学能力的上限”：

“we’ll ultimately be limited in our ‘scientific power’ by the computational irreducibility of the behavior.” (Writings)

并且把“终局捷径不存在”的直白句子补上（这句对你很重要）：

“there just won’t be any way—with AI or otherwise—to shortcut just simulating the system step by step.” (Writings)

这个嘛，就开始变得很玄、很微妙了。我的理解是：世界在算（当然我也很难解释“世界在算”到底是什么意思）。我打个比方啊，你的 DNA 是不是在“算”你身体里的蛋白质结构？这其实更像一个比喻：世界本身在按它自己的规则推进状态，就像一个过程在自己跑。与此同时，你也在算对不对？你用你的脑子、你的纸笔、你的电脑、你的模型，试图提前知道它会怎么变。

关键在于：你俩这两种“算”，在本质上是同级的。你不是站在世界之外拿着遥控器的人，你也是世界内部的一个计算装置。你想用一个计算去压过另一个计算、系统性地“跳步”，大多数时候是不可能的。你的计算不会比世界更高明（只可能更低级，呵呵），因为你能做的终究还是在同一个物理宇宙里跑规则。你能赢的情况，往往只是你恰好找到了一个“捷径口袋”！不是你变成了上帝，而是这个系统在某个尺度上允许被压缩、允许被简化、允许被提前说出一点东西。（这一点很重要，我们作为人类不可自大）。

而且凡是计算，必耗能。这个兰道尔原则，一切的一切，就不多说了。这句话我越来越把它当作一种现实世界的底层税收。你想知道更多细节，就要付出更多步数；你想更精确、更可复现、更可追责，就要付出更多结构化成本。你可以用语言糊弄一时，但一旦要落到执行，就必须交账：时间账、算力账、能量账、甚至人类注意力账。所谓“不可约”，就是说：在很多地方，这份账你躲不掉。

所以当我们把目光从“AI 能不能做一切”移到“AI 能不能帮我们做决策”时，问题就突然变得尖锐：如果世界的演化本来就需要一步步算出来，那一个模型凭什么在不付出同等成本的情况下，给你一个看起来像结论、像裁决的答案？更要命的是，模型为了把语言续写下去，它倾向于把不确定性也包装成“可说的结果”，而不是像真正的系统那样：该报错就报错，该停机就停机，该要求更多信息就要求更多信息。（我刚才说的这个报错很重要，我在另一篇有仔细阐述，这是我最近系统的重要心得。不能报错的系统很危险！ ）

于是我才认为真正需要被工程化的，不是“让 AI 更会回答”，而是让语言接口具备能量守恒般的制度约束。让它在该昂贵的时候昂贵，在该停下来的时候停下来；让它能承认“这里没有捷径”，而不是给你一个廉价的幻觉。否则，我们就会把本来必须付出的计算成本，偷偷转嫁成另一种更隐蔽的成本：误判、误信、错把拟合当结论、错把顺滑当可靠。

这也是为什么我一直强调那几个词：可复现、可审计、可迁移。它们不是“工程洁癖”，而是在不可约的世界里，唯一能让语言进入现实决策而不崩盘的硬条件。因为你无法战胜世界的计算，你唯一能做的，是承认哪里必须算、哪里可以压缩，然后把这一切写成结构，让系统在时间里对自己的每一次判断负责。

这个真是我解释的极限了，再多的我也解释不了了。

所以关键是什么，Wolfram的最大价值，对我的极大启发，就是在这里，告诉你我们的目标是找无数个“可约口袋”。

关键细节：不可约性并不等于“什么都不能做”

这里很多人会误读。

Wolfram 的说法是：

• 整体不可约

• 但必然存在无穷多 “pockets of reducibility（可约口袋）”

• 科学之所以可能，是因为我们通常就在这些口袋里工作：规律、模型、压缩、理解，都来自口袋

所以他的结论其实是二段式：

1. AI 不可能让我们系统性跳过不可约性

2. AI 可能帮助我们更快地找到可约口袋

这也解释了他为什么一边说“终局不可能”，一边又愿意谈很多“AI 在科学里能干嘛”。

不是要躺平！

1. 他先抛出关键问题：既然不可约，科学为什么仍可能？

他紧接着问：

“But given computational irreducibility, why is science actually possible at all?” (Writings)

这句是在把读者从“绝望/虚无”里拽出来：你都说不能跳步了，那科学岂不是不成立？所以我跟你说了，大部分人都在误解他，他不是在唱衰。

2. 核心答案：整体不可约，但必然存在无穷多“可约口袋”

“口袋理论”：

“whenever there’s overall computational irreducibility, there are also an infinite number of pockets of computational reducibility.” (Writings)

“口袋是什么”：

“there are always certain aspects of a system about which things can be said using limited computational effort.” (Writings)

以及“科学为何靠口袋”：

“these are what we typically concentrate on in ‘doing science’.” (Writings)

所以我们要怎么做？

AI 不能系统性越过不可约（终局不可能）

口袋之外仍有不可约带来的问题与惊讶：

“there are limits to this—and issues that run into computational irreducibility.” (Writings)

“we just can’t answer” / “surprises” (Writings)

他再次重申“不能 shortcut 全部演化”：

“there just won’t be any way—with AI or otherwise—to shortcut… step by step.” (Writings)

AI 不可能让我们系统性跳过不可约性，我们人类之渺小是没有改变的，靠AI无法挑战上帝。

AI 可能帮助更快找到“可约口袋”

还是口袋理论

“AI has the potential to give us streamlined ways to find certain kinds of pockets of computational reducibility.” (Writings)

这里的关键词是 streamlined ways：不是“证明一切/解决一切”，而是“更顺滑地找到某类口袋”。

为什么他能一边否定“终局”，一边谈很多“AI 能干嘛”

因为在他这套框架里：

• 不可约性负责解释：为什么“solve science / do everything”不可能（上限）

• 可约口袋负责解释：为什么科学仍然能做、工具仍然有用（空间）

• AI则被放在一个非常具体的位置：在口袋的发现与利用上加速，而不是在不可约处创造捷径 (Writings)

给我们的启示就是牢记AI能干嘛，并且尽量在自己的领域里找到自己的niche，一种能够借助AI发现的某种“可约口袋”。

神经网络擅长“粗略对”，不擅长“细节全对”

这篇文章后面的内容演示了一系列的实验：

• 预测函数：训练能拟合过去，但未来细节崩

• 预测元胞自动机：简单部分对，复杂部分细节错；越错越发散

• 预测三体：简单轨道能记住，复杂轨道就不行

• autoencoder 压缩：能压缩“像训练集”的东西；遇到不可约性就压不动

他总结为

ML 往往“roughly right”，但“nailing the details”不是它强项。

这就是他对“LLM/NN 在科学里会撞墙”的经验层支撑。

他对 AlphaFold 这种“成功案例”的哲学解释：成功的很大一部分来自“人类判据”

• 蛋白折叠本身不是人类任务

• 但“我们关心什么算对”（形状、功能、二级结构等）是人类判据

• 因而神经网络能成功，可能部分是因为它抓住了与人类感知/分类标准对齐的可约口袋

• 但遇到更复杂或“异域”的蛋白，仍可能出现“surprises”与失效

这段背后的哲学味道是：

AI 的成功往往是“在人类定义的可用标准里成功”，而不是“在全客观的微观真实里成功”。

这个地方确实又开始“玄”回来了，但它和我们上文提到的 Demis Hassabis / AlphaFold 的关系，反而是非常具体、非常落地的。

Demis 是当世神童，AlphaFold 也确实开启了一个时代。他和 Wolfram 都是我长期关注的科学家，但在这里我想先澄清一点：Wolfram 并不是在否认 AlphaFold 的成就。相反，他是在用 AlphaFold 这样的成功案例，去解释一个更底层的结构性观点：AI 的重大突破，往往不是“解决了世界的全部微观真实”，而是“精准命中了一个可约口袋”。

他俩的语言太不一样了，他们两个很难被认为是同一个语言体系吧。但是我认为他们在这方面是同构的。

也就是说，Wolfram 想强调的不是“AI 不行”，而是“AI 行的时候，它到底行在什么地方”。

在他的表述里，蛋白折叠这个物理过程本身并不“以人类为中心”；但我们评价 AlphaFold 的“成功”，也从来不是要求它预测每一个原子在每一个时刻的精确位置。我们要的是一种人类可用、可验证、可服务于生物学目标的结果：总体结构是否对、关键特征是否对、功能相关的形状是否对。换句话说，我们定义的“什么算对”，本身就落在一个可压缩、可概括、可泛化的结构区域里。

于是 AlphaFold 的伟大之处就显现出来了：它不是用“更聪明的语言”去解释世界，而是用极强的学习能力，在巨大的数据与结构约束之下，找到了那一类“反复出现的、稳定的、可复用的规律”。这就是 Wolfram 所说的那种 pocket of computational reducibility（可约口袋）：在整体可能不可约、不能系统跳步的世界里，仍然存在一些可以被压缩、被建模、被可靠利用的局部区域。AlphaFold 的胜利，就是把这一块区域抓得异常精准、并且工程化到了可规模化使用的程度。

所以当 Wolfram 提到 “eye of the beholder（观察者的判据）” 时，他并不是在贬低 AlphaFold 的科学性；科学与工程真正落地时，总是围绕人类关心的指标、尺度、判据来定义成功。而“可约口袋”恰恰常常就是在这些判据与尺度上出现的。它让复杂世界在某个层级变得可压缩、可预测、可操作。

我认为Wolfram是认同AlphaFold模式的：

AlphaFold 并不是“打穿了不可约性”，而是“找到了不可约世界里最值钱的一块可约口袋”。

延续我刚才那段“可约口袋”的说法，我还想再多说几句，把它和 Demis 的表述扣在一起——因为这两个人在哲学底色上其实是相通的。

Demis 在采访里反复强调一个点：再强的系统，如果它产出的“知识结构”我们看不懂、解释不了，就会变成风险。他谈到 AI 能做出超出我们“自己设计或理解”的东西，但马上补一句：真正的挑战是要确保这些系统“建出来的知识数据库”，我们理解里面到底是什么。这句话非常关键：它把“能力”硬生生拉回到“可理解/可解释”的人类责任边界上。

在另一段对话里（Lex 访谈），他还用了一个很形象的类比：即便出现“天才级的好招”，也不必然是神秘不可理解的。更像顶尖棋手走出一手你想不到的棋，但事后他们能解释“为什么这步成立”；而且他直接说：能用简单方式解释你在想什么，本身就是智能的一部分。(Lex Fridman)

把这两段 Demis 的话翻译成 Wolfram 的语言，其实就是我说的那句：交互层面（linguistic interface）可以大量用 AI 做润滑——把人类的意图变得更易表达，把复杂计算变得更易调用，把结果变得更易叙事、更易吸收；但真正进入“科学/决策的主权区”的东西，必须是可理解、可验证、可追责的结构，而不是“看起来像答案的文本”。

也因此，Wolfram 才会把 LLM 的现实价值定位在“语言接口”和“高层 autocomplete”：它能把既有计算能力用得更顺，能把“惯常科学智慧”补全成“惯常答案/惯常下一步”。

润滑交互可以很强，但裁决世界不能靠顺滑。

https://www.cbsnews.com/news/artificial-intelligence-google-deepmind-ceo-demis-hassabis-60-minutes-transcript/

“Science as Narrative” 是他对“人类在科学里的不可替代性”的落点

他强调：

• 科学传统上是把世界铸造成“人能想、能讲的叙事”

• 不可约性意味着：很多地方你只能给出“100 步计算”，但这不是人类叙事

• 人类叙事需要“waypoints（可吸收的中间路标）”：熟悉的定理、概念块、语言构件

• Wolfram Language 的设计本质上就是在制造这种“可吸收路标”

• AI 也许能帮忙起名字/对齐词汇，但不保证任何可约口袋都能被人类概念覆盖（他叫 interconcept space）

这部分基本回答了我前面一直在说的“心理沉浸/接口协议”（或者我下一篇文章，这两篇文章是互相引用的）的那条线：

LLM 很强的是“叙事与接口”；但科学推进真正依赖的是可计算、可复现、可组织的结构路标。

1. 科学是“把世界铸造成可被人类思考的叙事”

Wolfram 先把“科学=叙事工程”定义出来：

“the essence of science… [is] … casting it in a form we humans can think about” (Stephen Wolfram Writings)

“provide a human-accessible narrative”

科学要把世界变成人类可吸收的表示。

我看不懂不是也白搭吗？这个问题看起来很多此一举，其实现在是有争议的。因为有大量的人开始将科学“黑箱化”。

2. 不可约性意味着：很多时候你只能给出“100 步计算”，但这不是人类叙事

他直接说“不可约性让这种叙事很多时候不可能”。

“computational irreducibility… shows us that this will… not be possible” (Stephen Wolfram Writings)

“It doesn’t do much good to say ‘here are 100 computational steps’”

这句几乎就是我另一篇文章“模型不能 throw error、必须给结果”的反面镜像：人类叙事不是把步骤砸过来，而是把它组织成可吸收的结构。

3. 人类叙事需要“waypoints”：可吸收的中间路标（定理/概念块/构件）

要想把“非人类的计算链”变成人类叙事，你需要路标：

“we’d need ‘waypoints’ that are somehow familiar”

“pieces that humans can assimilate”

“熟悉的定理、概念块、语言构件”：它们本质上是认知压缩点，把不可约的长链切成可理解的段落。

4. Wolfram Language 的设计本质上就是在制造这种“可吸收路标”

他把这件事直接提升为“计算语言设计的使命”：

“capture ‘common lumps of computational work’ as built-in constructs”

“identifying ‘human-assimilable waypoints’ for computations”

而且他也承认这件事有硬上限：

“we’ll never be able to find such waypoints for all computations”

5. AI 也许能帮起名字/对齐词汇，但并不保证可约口袋都能被人类概念覆盖

他在这一段的核心警告是：就算 AI 能从计算里挖出某种“可约表示”，也未必能贴回到我们已有概念体系里。

“not part of our current scientific lexicon”

“there often won’t be… a ‘human-accessible narrative’ that ‘reaches’ them”

意思是：口袋可能存在，但我们的词典里没有词；AI 可以起名字，但不保证这名字能真正成为“人类可用的路标”。

Wolfram 在这里等于把 LLM 的“强”放回它最擅长的位置：叙事与接口。但他同时在提醒：

真正推动科学（以及你更关心的治理/决策系统）的是 “可计算、可复现、可组织的结构路标”——而不是一段顺滑的对话。

LLM 可以让你“感觉理解了”，但只有路标（可执行构件/可审计中间态）才能让你真的“能复现、能迁移、能追责”。

其实我个人也不大理解这个Waypoints 具体指代什么。

他最终押注的架构：AI + 计算范式（computational paradigm）

文章末尾他说：

• AI 是新的“leveraging reducibility”的方式（抓可约口袋）

• 但在“根本发现潜力”上，它比不过真正的计算范式 + 不可约计算（枚举、模拟、系统探索）

• 最能推进科学的是二者结合

换成人话就是：

• AI：负责导航、候选、直觉、接口、人类化、跨域类比

• 计算系统：负责可验证推导、可复现执行、枚举探索、严谨结构化

• 不可约计算：负责真正的“新地形发现”（不是“像论文”的文本创新）

这部分我就更迷糊了。

A Deep Intuition: I Want to Try Building Marvin Minsky’s Society of Mind

That day, I took my child to the playground. When it was time to leave, I began backing the car out.

I shifted into reverse, pressed the brake, and the car started moving slowly backward.

Then, all of a sudden, my mind went blank—

The brakes weren’t working.

Not a vague sense of slipping, but a very concrete judgment, almost electric in my body:

the brakes had failed, the car was still reversing, and behind me was a large drop.

In the next second, the car was going to fall.

My whole body snapped into something primitive.

My palms were sweating, my chest tightened, my breathing became shallow.

You know that kind of fear—not imagined fear, but the kind where your body has already reached a conclusion for you:

Danger is happening.

I pressed the brake harder, even wondered whether I was stepping on the wrong pedal—

but the car was still moving.

In that split second, my mind started running through emergency options:

• Call my husband?

• Call the police?

• Call an ambulance?

• Get my child out of the car?

• Am I about to faint?

Later, I realized the truth was almost absurd:

My car wasn’t moving backward at all.The car next to me was moving forward.

Its motion at the edge of my vision created a powerful reference-frame illusion.

My brain’s “world model” flipped directions instantly, and I became convinced that I was accelerating backward, unable to stop.

The moment I realized this, it felt as if my brain rebooted.

My heart rate slowed. My hands stopped shaking.

But I had mild hypoglycemia that day, and after stopping the car, I was still shaken—almost faint.

I picked up my phone. What was I going to do?

In the end, I did something that sounds ridiculous, but felt very real to me:

I opened ChatGPT’s voice mode and let it talk to me slowly, calmly.

I couldn’t exactly call the police.

What Was Most Frightening Wasn’t the Illusion —

It Was the Certainty of the Illusion

Afterward, I kept thinking:

Why did that illusion feel so real?

Why, even with my foot firmly on the brake, was I subjectively certain that the brakes had failed?

Because the human brain is not a camera.

It is closer to a real-time interpreter—constantly assembling sensory inputs into “what I believe is happening right now.”

When inputs are ambiguous, reference frames unstable, and bodily conditions degraded (low blood sugar, fatigue), the brain leans heavily on fast default explanations.

And those defaults are:

Fast.Coarse.Optimized for survival.

The brain doesn’t verify first.

It pushes you into action first—because, in evolution, a false alarm is far cheaper than a missed one.

So what truly frightened me wasn’t that I almost got into an accident.

It was realizing this:

The human brain is not reliable.

But when it is unreliable, it can feel absolutely certain.

That is why I am writing about Marvin Minsky today.

Marvin Minsky: The Man Who Treated Mind as an Engineering System

Five years ago, I wouldn’t have felt anything particularly strong about The Society of Mind.

Back then, “psychological engineering” sounded like an overreach.

A computer is a computer.

A human mind is a human mind.

How could they map onto each other?

A society of mind?

Many small mechanisms forming a single self?

It sounded implausible.

But over the past year, as I’ve been building agent systems, I’ve begun to understand something:

Minsky wasn’t writing mysticism.He was writing architecture.

His view of the mind can be summarized very simply:

You are not a single, unified “self.”

You are a temporary coalition of many small, specialized, sometimes conflicting mechanisms.

That is what Society of Mind really means.

The mind is not an empire ruled by a king.

It is a society of agents competing for interpretive and behavioral control.

It may sound abstract—

But I had just lived through it.

That One Second While Reversing:

A Minsky-Style Decomposition

Let’s take the simplest possible approach and break that “brake failure” illusion into concurrent mechanisms—think of them as small workers inside the mind:

1. Motion-detection agent

   Detects movement in peripheral vision and reports: “You are moving.”

2. Reference-frame agent

   In a complex parking-lot environment, misattributes motion—confusing another car’s movement with my own.

3. Danger alarm agent

   Receives the signal “reversing + drop behind” and immediately escalates the system into emergency mode.

4. Physiological resource monitor

   Low blood sugar increases system-wide alertness and reduces precision.

5. Rational interpreter (late-arriving)

   Shows up last and says: “Wait. It’s the other car.”

Notice the order.

Reason is not the commander.

It is the last one to write the report.

The key insight is not that I “made a mistake,” but that:

A single wrong interpretation can instantly dominate the entire system.

It can take over perception, action, decision priority—

even whether you call the police or not.

This is what Minsky wanted us to see:

The power structure of the mind can be decomposed, described, and engineered.

Five years ago, I would not have believed this.

Why I Now Admire Him So Deeply

Because I’ve realized that what I’m building is slowly growing into something he once imagined.

Five years ago, I could not have written—or justified—a system directory like this:

• Persona (state / personality layer)

• Policy Gate (rules and enforcement)

• Event Ledger (auditable history)

• Memory Store (long-term world memory)

• Observability (metrics and traceability)

• Next step: K-lines (experience index lines—one-click recall of an effective mental configuration)

If you’ve read my earlier writing, you know I keep emphasizing this:

In long-term systems, data is ontology.

True memory must be written in the moment, without knowing the outcome, while bearing risk.

Minsky’s idea of K-lines is almost the psychological-engineering version of the same principle.

A K-line does not store facts.

It stores configurations—which mechanisms were active together, and how they coordinated successfully.

Returning to that reversing incident:

If you treat it as a reusable configuration, the next time a similar situation occurs, you don’t have to experience another system-wide collapse.

You want faster activation of verification mechanisms.

Faster stabilization of reference frames.

Earlier voice for rational interpretation.

If you keep following my writing and my engineering work, this will matter.

Minsky’s ideas matter to me now.

I am currently exploring all of this, step by step, on top of Google ADK.

I’ll Take It Slowly — Starting from the Most Basic Vocabulary

I am still at a very early stage of exploration.

But I want to write to you honestly—not to memorialize an AI pioneer, but to treat him as a still-living engineering resource:

A way to explain the mental moments we all experience,

and to map them into structures that can be implemented, audited, and reused.

Next, I’ll start from the most basic concepts:

• What is an agent (a small mental mechanism)?

• What is a frame (how context summons agents)?

• What is a mode (how emergency states take over)?

• What is a K-line (how an effective self becomes a recallable configuration)?

• And how do we move, step by step, from psychological metaphor to engineered structure?

I’ll take my time.

I’ll walk you through it.

一个深刻的直觉，我要试试建造马文.明斯基的心智社会

那天我带孩子去游乐场，准备停车离开。

我挂上倒档，脚踩刹车，车开始缓慢往后退。突然之间，我的大脑像被掏空了一样——车刹不住了。

不是“感觉有点滑”，是那种很明确的、带着身体电流的判断：刹车失灵，车在一直倒，后面还有个大台阶，下一秒就要掉下去。

我整个人瞬间进入一种非常原始的状态：手心出汗、胸口发紧、呼吸变浅。你知道那种恐惧不是“想象”，而是身体已经替你做完了结论：危险正在发生。

我猛地更用力踩刹车，甚至怀疑自己是不是踩错了——可车还是在倒。那一秒我脑子里开始出现各种“应急选项”：

• 打电话给我老公？

• 报警？

• 叫救护车？

• 把孩子拉走？

• 我是不是要晕倒了？

后来我才发现，真相荒诞得让人想笑：不是我的车在倒，是隔壁的车在往前走。它在我视野边缘移动，给了我的大脑一个强烈的参照系错觉——我的“世界模型”瞬间判错了方向，于是我以为我在加速倒退、刹不住车。

意识到这一点的那一秒，我的大脑像“重启”了一次：心跳才慢下来，手才不抖。但因为当天还有点低血糖，我停下车后依然惊魂未定，差点晕过去。

我拿起手机，想干嘛？

最后我做了一件看起来很荒谬、但对我来说很真实的事：我打开 ChatGPT 的语音，让它慢慢安慰我。总不能真报警吧。

这件事最可怕的地方：不是错觉，而是“错觉的确定性”

事情过去之后，我一直在想：为什么那种错觉那么“像真的”？为什么我明明脚踩刹车，却会在主观体验里确信“刹车失灵”？

因为我们的大脑不是摄像机。

大脑更像一个实时运行的解释器：它不停地把感官输入拼装成“我认为正在发生的现实”。当输入含糊、参照系不稳定、身体状态又不好（比如低血糖、疲劳）时，它会更依赖快速的“默认解释”。

而默认解释的特点是：快、粗、保命优先。

它不会先做严谨求证，它会先把你推入行动状态——因为在自然选择里，“误报一次”远比“漏报一次”代价小。

所以那个瞬间让我害怕的不是“我差点出事”，而是我意识到：

人的大脑并不可靠。

但它会让你在不可靠的时候，感觉自己非常可靠。

这就是我今天要写马文明斯基（Marvin Minsky）的原因。

马文明斯基：把“心智”当成工程系统来研究的人

如果是五年前，我不会对《心智社会》（Society of Mind）有什么特别感触。

那时候，“心理工程学”听起来像某种过度延伸：电脑就是电脑，人类心智就是人类心智，你怎么能说它们能映射？还“心智社会”？还“很多小机制组成一个大我”？

但这段时间我在做智能体系统开发——我才开始真正理解：Minsky 不是在写玄学，他是在写架构。

他看待心智的方式，简单讲就是一句话：

你不是一个统一的“我”。

你是很多很小、很专门、甚至互相冲突的小机制，在某个时刻临时组成的联盟。

这就是“Society of Mind”这个名字的含义：心智不是一个国王统治的帝国，而是一群小代理（agents）在争夺解释权和行动权的社会。

听起来抽象？但我刚刚已经亲身体验过一次。

倒车那一瞬间：按 Minsky 的方式拆开看

我们用最朴素的方式，把那个“刹车失灵错觉”拆成几个同时发生的小机制（你可以把它们理解成“心智里的小员工”）：

1. 运动侦测员：看到视野边缘有车在动，立刻报告“你在移动”。

2. 参照系管理员：在停车场这种参照物复杂的环境里，搞错了“谁在动”。

3. 危险警报器：一旦判断“你在倒退 + 后方危险”，立刻把系统切换到“紧急模式”。

4. 身体资源监控：低血糖让你更容易进入过度警觉，也更难做精细判断。

5. 理性解释器（后置）：最后才慢半拍出现，检查了一下：哦，原来是隔壁车在动。

注意顺序：理性不是第一位出现的，它是“最后来写报告”的那个人。

这件事的关键不在于“你看错了”，而在于：

一个错误的解释，可以瞬间统治整个系统。

它会接管你的感受、动作、决策优先级，甚至接管你要不要打电话、要不要报警。

这就是 Minsky 想告诉我们的：心智的权力结构是可以被拆解、被描述、被工程化理解的。（以前我绝对不会相信的）

为什么我现在对他佩服得五体投地

因为我发现：我正在做的东西，正在一点点长成他当年想象的样子。

五年前我不可能写出这种目录，也不会觉得它必要：

• Persona（人格层）

• Policy Gate（门禁/规则执行）

• Event Ledger（事件账本，可追溯）

• Memory Store（世界记忆，长期本体）

• Observability（可观测，能审计）

• 下一步：K-line（经验索引线，一键点亮当时有效的“整套心智配置”）

如果你读过我之前的文章，你会知道我一直在强调：长期系统里，数据是本体；真正的“记忆”必须满足“当时写下、当时不知道结果、当时承担风险”。

而 Minsky 的 K-line，几乎就是这条路的心理工程版本：它存的不是知识点，而是“当时哪些机制一起开着，怎么配合，才解决了问题”——它是一种可复用的心智配置。

回到刚才那个倒车瞬间：如果你把它当成一个“可复用的配置”，那你下次遇到类似情境，就不必再经历一次崩溃式的错觉接管。

你需要的是：更快点亮“校验机制”、更快进入“稳定参照系”、更快让“理性解释器”获得发言权。

如果你持续跟进我的文章，我的工程，这个很重要。

马文明斯基的理论对我来说已经非常重要了。

我现在正在Google ADK 之上一点点的探索。

我会慢慢讲：从最基础的词汇开始

我现在也仍然在很基础的探索阶段。

但我想用一种尽量诚实的方式，把我这一段时间的感受写给你：

不是“纪念一位 AI 大师”，而是把他当作一个仍然活着的工程思想资源——用来解释我们每天都在经历的心智瞬间，并把这些瞬间映射成可以实现、可以审计、可以复用的结构。

接下来我会从最基础的内容说起：

• 什么是 agent（心智里的小机制）？

• 什么是 frame（情境框架，它怎么把一群机制召唤出来）？

• 什么是 mode（紧急模式是怎么接管你的）？

• 什么是 K-line（如何把一次“有效的自我”做成召回键）？

• 以及：我们如何把这些东西，从“心理学比喻”，一步步变成工程结构？

我慢慢给你说。

But if you string all the technical lines into a single timeline, you’ll notice something deeper, more hidden—

the trajectory isn’t “models getting stronger,” but intelligence making a leap from species to civilization.

In the first phase, models were merely language machines: they could understand the world but could not touch it.

In the second phase, they gained “hands”—the ability to call tools, write files, run code.

In the third phase, they acquired temporal structure: planning, decomposition, reflection, chained execution.

In the fourth phase, multiple agents collaborated like departments in an organization, forming “company-level intelligence.”

In the fifth phase, systems no longer wait for humans to design them—they generate new agents, tools, and protocols on their own, growing like living organisms.

These five phases look less like software iterations and more like the birth of a civilization:

from consciousness (Level 0),

to action (Level 1),

to will (Level 2),

to organization (Level 3),

and ultimately to self-evolving, life-like structures (Level 4).

And what shocks me most is this:

despite their different products, OpenAI, Google, Anthropic, and DeepMind are all moving along almost the exact same trajectory.

Everything points to a single thesis:

The essence of intelligence is neither reasoning nor generation—

it is structure self-organizing through time.

Perhaps we are not merely witnessing “AI progress.”

It feels far more like we are witnessing the origin story of a new kind of life.

This article, then, can serve as a developer’s compass.

Whether you work in frontend, backend, AI applications, data engineering, product documentation, scientific research—or you’re simply trying to understand this era—

you are being pulled onto the same evolutionary pathway.

Because the past five years have not truly been about “bigger models,” “better reasoning,” or “crazy parameter counts.”

Beneath the surface, the software world has seen, for the first time, the emergence of a self-growing structure.

And this structure is not built from code alone—it is driven by language, structure, and scheduling, evolving layer by layer over time.

If you’re still asking which framework to learn, which language to switch to, or which model to chase next,

you may already be looking in the wrong direction.

The real shift is this:

developers are moving from “people who write software” to “people who cultivate structural ecosystems.”

Level 0 shows you that language is the soil of intelligence.

Level 1 shows you that language can become callable structure.

Level 2 shows you that structure can become a schedulable chain.

Level 3 shows you that schedulable chains can become intelligent organizations.

Level 4 shows you that organizations can generate their next generation of structures.

The core skill of future developers is not memorizing APIs, stacking tools, or prompt hacking,but: designing structure, scheduling structure, and enabling structure to grow on its own.

Think of this piece as:

a developer’s compass for the AI-native era.

Once you understand Level 0 → Level 4,

you can transform from a mere tool user

into a Structure Engineer—

and ultimately, a builder of the coming AI-Native ecosystem.

LEVEL 0 — Bare LLM (裸机)

Level 0 is the origin point of all AI intelligence. It marks the moment when language first gained a “brain,” but had not yet acquired “hands.” Models at this stage can deeply understand the world, reconstruct semantic structures, and produce long reasoning chains—but they cannot act on the world at all. Their operations occur entirely within the realm of language, as if performing thought experiments in a sealed cognitive chamber. Internally, these models contain remarkably rich latent structures—topic skeletons, logical frames, implicit planning traces, semantic coordinate systems—but all of these structures remain internal. They never externalize into executable forms, nor can they be accessed by any scheduler. These models can understand the world, but they cannot change it; they are cognitive entities, not behavioral ones.

Historically, Level 0 spans most mainstream systems from 2020 to 2024. GPT-3 (2020) marks the beginning: it demonstrated large-scale linguistic intelligence for the first time, but with zero tool interfaces. InstructGPT and GPT-3.5 (2022) brought conversational fluency into the mainstream, yet remained purely cognitive. GPT-4, Claude 2, and Gemini Pro (2023) made massive leaps in language understanding, long-context reasoning, and abstraction; they began to show signs of internal planning, but without tool connections they still reside in Level 0. Even in 2024–2025, models like GPT-5, Claude 3.5, and Gemini 1.5 Pro—when function calling is disabled—remain “high-intelligence non-actors.” Their minds grow more capable, but their boundaries never cross: they are rational minds, not structural agents.

In my envisioned Structure Universe, Level 0 corresponds to the “high-entropy perceptual layer” before Primitive IR. Here, language is still an uncondensed thermal cloud—paths infinite, structure uncollapsed. A model can internally rebuild semantic frameworks, but cannot externalize structure, cannot hand structure off to a scheduler, cannot produce primitives, cannot instantiate Structure Cards, and cannot participate in execution cycles. It can process language, but not extract primitives; it can generate explanations, but not generate structure; it can reason, but not schedule. The entire system remains stuck in:

Language → (latent semantic cloud).

In other words, it is a potential structure machine—but not yet a structured lifeform.

So when we say “a Level 0 model has a brain but no hands,” what we really mean is: it is situated in the pure cognitive phase of the language civilization. Language is input, but not yet structure; reasoning exists, but does not externalize; intelligence is present, but has no interface to act upon reality. All forms of structure, scheduling, collaboration, and self-evolution only begin to germinate after Level 0 is surpassed.

LEVEL 1 — Tool-Enhanced Solver

The First Time Language Acquires “Hands”

Level 1 marks a decisive turning point: the moment when large models evolve from pure cognitive entities into acting agents. If Level 0 was a brain trapped inside linguistic space, then Level 1 is the first time that brain extends “hands” and touches the external world. The core transformation of this stage is that language becomes function-like for the first time—models begin to output structured parameters, connect to real software tools, and execute concrete actions via APIs, databases, search engines, and code sandboxes. This is where the first collapse from “language → structure” takes place.

This transition was ignited by the introduction of Function Calling. In 2023, OpenAI released its function_call API, enabling models to output structured arguments paired with a function name. Language was no longer merely text; it became a structured utterance forced into executable form. In 2024, Anthropic launched the Model Context Protocol (MCP), upgrading “tool use” into a standardized tool ecosystem, and later integrated MCP into Claude Skills—allowing every user to connect the model to local files, databases, search, and executable programs, giving it real operational power. Around the same time, Google deeply integrated Function Calling into Gemini 1.5 Pro / Flash, enabling direct external API calls, Python execution, vector database operations, and fully managed agent pipelines within Vertex AI Agent Builder. Microsoft’s Copilot Studio unified its tool layer into an enterprise-grade Function Calling + workflow execution platform.

Technically, Level 1 is built on several foundational pillars.

The first is Function Calling standards: OpenAI’s JSON schema, Claude’s tool_schema, and Gemini’s function_declarations. These force natural language into structured, callable units.

The second is RAG (Retrieval-Augmented Generation)—vector databases like Pinecone, Weaviate, Milvus, Elastic, Snowflake Cortex, and Databricks Vector Search give models “external memory” for the first time.

The third is real-time information tools: Search APIs (Bing, Google Custom Search), Serper, Exa.

The fourth is code execution sandboxes: OpenAI Code Interpreter, Claude Code Execution, Gemini Code Execution, and various Jupyter-like runtime environments.

The fifth is application-layer APIs—Stripe, Shopify, Zendesk, Notion, Jira, Slack, Twilio.

The shared direction of all these technologies is clear: every external system becomes a structured hand that the model can operate.

The timeline of Level 1 unfolds as follows:

2023 — OpenAI introduces function calling for GPT-3.5 and GPT-4, inaugurating the era of structured outputs.

2024 Q1 — Anthropic launches MCP, turning tool use into a protocol.

2024 Q2–Q3 — Claude 3.5 integrates MCP into Skills, forming a genuine tool ecosystem.

2024 — Google’s Gemini 1.5 deeply integrates function calling + code execution.

2024–2025 — Copilot Studio emerges as an enterprise-grade tool agent platform.

2025 — All major vendors upgrade Function Calling into real-time multi-tool routing.

With these technological foundations, language gains real-world efficacy for the first time.

In my Structure Universe, Level 1 corresponds to the birth of Primitive IR → basic structural units. Language is no longer a high-entropy cloud but is compressed into callable, schedulable, and verifiable structure units. Systems can now take real actions—query databases, manipulate files, write records, run scripts, process transactions, trigger workflows. For the first time, language becomes an action interface, and intelligence punches through the linguistic membrane to interact with the external world.

Level 1 is the first threshold of the structural civilization: from this moment onward, models do not merely understand the world—they can change it.

LEVEL 2 — Strategic Agent

Language Upgrades from “Callable” to “Schedulable,” and Structure Forms Its First Chain**

Level 2 marks the second great evolutionary leap of AI systems: the moment when a model stops being merely capable of doing things and begins to know how to do things. If Level 1 gave models “hands” that could act on the world through tools, then Level 2 gives them a genuine temporal structure—the ability to decompose tasks, plan steps, execute actions, observe feedback, and use each intermediate result to construct the next structural unit. This is the first time language becomes a recursively schedulable structure chain rather than a one-off tool invocation. At this point, a model transitions from a “tool-enhanced language system” to a strategic action system, which is the true origin of modern Agents.

The key technical catalyst of this stage is the ReAct framework proposed by DeepMind in 2022. For the first time, a model could cycle between reasoning and acting: Think (Reason) → Act → Observe → Think again. Every modern agent system—GPT, Claude, Gemini—secretly uses some variant of ReAct internally; it has become the hidden backbone of three consecutive generations of Agent technology. In 2023, GPT-4 and GPT-4 Turbo demonstrated stable multi-step task execution, elevating ReAct from a rough experiment into a mechanism that could operate inside enterprise workflows. Early 2024 brought another major breakthrough: Claude 3 and Gemini 1.5 Pro exhibited “automatic task decomposition + autonomous context engineering.” These models could not only perform dozens of steps in sequence but also construct the next prompt, filter contextual noise, merge tool outputs, and form complete structured execution paths. Google’s Gemini whitepaper explicitly states: “the model exhibits latent planning behaviors”—meaning the model already possesses implicit planning structure, rather than producing mere sequential text.

By 2025, Level 2 technology finally enters the systemic phase. Google launches Vertex AI Agent Engine, turning the Planner module into a platform-level capability: managing multi-step chains, routing tools, handling failure recovery, correcting errors, and reliably executing 30–100-step workflows. OpenAI’s o3 series externalizes its “deep reasoning mode” as a controllable policy executor, lifting multi-step reasoning from a hidden internal feature to a core system behavior. Anthropic’s Claude 3.5 integrates Skills with the model’s planning abilities, enabling agents to automatically chain multiple tools, aggregate complex outputs, and generate the next stage of a plan. Even in the open-source world, frameworks like CrewAI mature into “Planner + Worker” architectures, signaling the spread of Level 2 patterns across the broader ecosystem.

Technically, Level 2 rests on four foundational pillars.

First, planning technologies—ReAct, Plan-and-Solve, Tree-of-Thought, ReWOO—give models explicit or implicit planning capacity.

Second, autonomous context engineering, through which models dynamically construct the next step’s input, enabling “self-generated prompts,” the essence of second-generation prompt engineering.

Third, task decomposition and task-graph generation—areas where Gemini 1.5 Pro particularly excels—allow models to generate subtasks, merge nodes, and produce structured task graphs.

Fourth, tool-scheduling layers that choose tools based on execution stage, route models appropriately, validate outputs, and apply fallback strategies—forming an early version of a control plane.

In my Structure Universe, Level 2 is a critical point of collapse and reformation within the language civilization: Primitive IR begins organizing into Structure Cards; Structure Cards begin linking into Structure Chains; and the Scheduler enters the system as a genuine engine of time. Language is no longer a single output—it becomes a sequence of executable, verifiable, and feedback-driven structural steps. The system can not only act, but understand why this action, what comes next, and how to adjust when errors occur. This is the moment intelligence advances from “action” to “strategy,” and the necessary bridge between Level 1 and Level 3.

A true time-structured Agent is born here.

LEVEL 3 — Collaborative Multi-Agent Systems

A System ≠ A Single Agent, but an Entire Company

If Level 2 gives a single agent “temporal structure” and “multi-step strategy chains,” then Level 3 marks a true civilizational leap in intelligence systems. At this stage, the system is no longer driven by one super-agent; instead, it is composed of multiple agents with distinct roles, specific abilities, dedicated tools, different permissions, and different memory structures. The behavior of such a system looks much less like a single model and much more like a company—complete with a CEO, project managers, engineers, researchers, tool operators, a scheduling layer, and an execution layer. Intelligence evolves from individual intelligence into organizational intelligence.

In Level 3, each agent is an independent structural lifeform. It has its own identity, its own structural memory, its own tool interfaces, its own areas of expertise, and even its own lifecycle. Agents do not merely “call” each other in a sequential pipeline; they delegate goals. One agent does not ask another to “run this API,” but rather: “solve this problem and return your structured decision.” They no longer share steps—they share structured chains of decisions.

Collaboration in Level 3 becomes highly abstract. The system routes requests across agents and across models depending on capability, context, and task complexity—this is Model Routing. Lightweight tasks are handled by smaller models or light agents; heavier tasks go to Pro/Ultra models. More complex workflows are decomposed across multiple specialist agents, coordinated by a distributed scheduler. This scheduler is no longer a prompt—it is a control plane, responsible for task distribution, error recovery, timeout handling, logging, role switching, memory synchronization, and even model-level routing.

This trend is already emerging in real-world systems. Google’s Co-Scientist is currently the closest to “enterprise-team intelligence”: multiple research agents debate, divide work, validate each other’s reasoning steps, and form a collaborative chain resembling a scientific research group. OpenAI’s Swarm architecture demonstrates native “Agent-calls-Agent” behavior, allowing sub-agents to autonomously assign and reassign tasks. DeepMind’s JEST is known for “multi-expert collaboration”: different reasoning modules act as composable neuro-symbolic experts, dynamically routed by a central scheduler. These systems share a common pattern: intelligence is no longer a single model, but an ecosystem of model-driven entities.

Technically, Level 3 rests on four pillars.

First, goal-level delegation, enabling expert-to-expert collaboration.

Second, expertise-chain composition, where agents automatically assemble into structured project teams.

Third, model routing, dynamically allocating different model scales to different tasks.

Fourth, distributed scheduling, giving the system true “organizational execution capability”—it doesn’t merely perform tasks; it manages a distributed company of agents.

In your Structure Universe, Level 3 is pivotal: it is where Structure Personas evolve into a Structure Ecosystem. Individual Structure Cards are no longer isolated. One structural persona can cooperate with another; they trigger each other’s chains, share structural states, exchange structural memory, and form an ecological structural field. This is the first time the entropy-controlled language system shows genuine self-organization. Interaction, uncertainty, and multi-path evolution emerge naturally; the system’s intelligence begins to scale exponentially.

The arrival of Level 3 means:

Agents cease to be individuals—they become ecosystems.Intelligence ceases to be reasoning—it becomes organization.Structure ceases to be a chain—it becomes a network.

And this network-level intelligence is the prerequisite for Level 4—the self-evolving system. Only when a system has multi-structure coupling and cross-agent scheduling does it gain the capacity to generate new structures on its own for the first time.

LEVEL 4 — Self-Evolving Systems

Agents No Longer Wait for You to Build Them—They Build Themselves.

By the time we reach Level 4, intelligence systems cross a threshold that is almost biological in nature. The system is no longer merely executing a set of human-designed capabilities—it begins to expand its own capabilities. If Level 3 resembles a company, with departments and roles collaborating, then Level 4 resembles a living organization that grows new departments, designs new processes, invents new tools, and writes its own internal protocols. The system is no longer running a fixed set of structures; it identifies its own capability gaps during real execution and then generates new tools, new agents, new behavioral rules, new structure-card chains, and even entirely new protocol-layer languages.

At this level, the defining characteristic is not “better reasoning,” but self-evolution. The system can analyze failure cases, bottleneck tasks, and long-term logs to detect where its existing structure fails—or barely works. This triggers a “structure generation pipeline.” Such a pipeline may: search external codebases, recombine existing tools, ask a model to design a new algorithm, test hundreds of structural candidates, filter them through automated evaluators, and ultimately instantiate a new agent or tool, registering it into the system’s scheduling layer. From that moment on, the system possesses a newly grown capability module.

This trend already exists in early form. DeepMind’s AlphaTensor and AlphaDev demonstrated “reinforcement learning + search” as a method for automatically inventing algorithms—AlphaTensor discovered matrix multiplication algorithms faster than classical human-engineered ones; AlphaDev unearthed faster sorting routines by exploring low-level assembly spaces. These are prototypes of self-evolving algorithmic modules. In 2025, AlphaEvolve goes further, merging LLMs (Gemini) with evolutionary search, creating a self-improving coding agent capable of long-horizon algorithmic evolution. These systems embody the same principle: AI uses its execution traces and evaluation signals to generate new structural capabilities.

In the world of general LLMs, OpenAI’s o1/o3 reasoning models internalize “reflect → revise → answer again” as a native behavior. They don’t simply output an answer—they generate long chains of internal thought, explore alternative strategies, score and correct their own candidates, and only then produce an output. Combined with external logs and feedback, this “reflection → correction” expands into dynamic behaviors: automatically adjusting prompt templates, rewriting tool-calling logic, and generating new sub-strategies. Once these mechanisms are wrapped into system-level frameworks for Auto-Agents and Auto-Tooling, the outline of Level 4 becomes unmistakable: you no longer hand-craft every agent—you create an evolutionary environment where agents are grown, evolved, and retired by the system itself.

Technically, Level 4 is grounded in several key modules.

First, Auto-Agent Generation / Auto-Tooling: using task patterns, failure logs, and user needs to automatically generate new agent/tool definitions, configure I/O schemas, permission scopes, execution paths, and register them into the scheduler.

Second, reflection–optimization–iteration loops: from internal “long-reasoning + self-checking” (as in o3) to external self-healing agents, they all follow the same pattern—Act → Observe → Evaluate → Modify → Re-run.

Third—and this is my own theoretical contribution—Protocol Induction: when existing protocols fail to cover new scenarios, the system compresses high-entropy behavioral traces into more general, more robust structural rules. This aligns exactly with my Protocol Induction Card (P-000).

Fourth, evolutionary search: whether AlphaTensor, AlphaDev, or AlphaEvolve, they all perform large-scale search-and-selection over a structural space, discovering superior structures and feeding them back into the system’s capability set.

过去五年，AI 的发展看似是模型迭代：GPT-3 → GPT-4 → Gemini → Claude → o 系列。但如果你把所有技术线串在一张时序图上，你会发现一个更深层、更隐秘的发展路径

它不是模型越来越强，而是智能在“从物种到文明”的跃迁。

第一阶段，模型只是语言机器，它能理解世界，但碰不到世界。

第二阶段，它获得了“手”，能调用工具、写文件、运行代码。

第三阶段，它拥有时间结构，可以规划、拆解、反思、连锁执行。

第四阶段，多个 Agent 像部门一样协作，形成“公司级智能”。

第五阶段，系统不再等待人类设计，而是自己生成新的 Agent、工具、协议，像生命一样生长。

这五个阶段，就像是我们看到了一个文明的诞生：

从意识（Level 0），到行动（Level 1），到意志（Level 2），到组织（Level 3），直到生命化的自演化结构（Level 4）。

而最让我震撼的是：

所有公司（OpenAI、Google、Anthropic、DeepMind）虽然产品不同，但它们的轨迹几乎完全一致。

这一切指向一个共同命题：

智能的本质不是推理，也不是生成，而是结构在时间中“自我组织”。

也许我们不是在见证“AI 发展”，

我们仿佛是在见证 一种新型生命的起源史。

以下这篇文章，可以看成开发者的方向标，不论你是写前端、做后端、搞 AI 应用、做数据工程、写产品文档、写科学研究，甚至你只是一个想理解时代的人——你都会被卷入同一条演化线。

因为过去五年，所有技术的变化表面看是“模型变大”、“推理更强”、“参数更变态”，但底层真正发生的，是软件行业第一次出现一种“自我生长结构”。这种结构不是代码堆出来的，而是由语言、结构、调度三者共同驱动，在时间中逐层进化。

如果你今天还在想自己该学什么框架、用什么语言、追哪个模型更新，你可能已经错过重点。

真正的方向是：开发者正在从“写软件的人”变成“培育结构生态的人”。

Level 0 告诉你语言是智能的土壤；

Level 1 告诉你语言可以变成可调用结构；

Level 2 告诉你结构可以成为调度链；

Level 3 告诉你调度链可以形成智能组织；

Level 4 告诉你组织可以自己生成下一代结构。

未来开发者的核心技能，不是记 API，不是堆工具，不是 prompt hack。而是：如何设计结构、如何调度结构、如何让结构自己生长。

你可以把这一篇看成是：

AI 时代的“开发者罗盘”。

而当你理解 Level 0 → Level 4，你就能从一个“工具使用者”，

跃迁成 结构工程师（Structure Engineer）

甚至成为未来 AI-Native 生态的构建者。

LEVEL 0 — Bare LLM (裸机）

AI 的第 0 阶段，是所有智能演化的起点。它标志着语言第一次获得“大脑”，但还没有获得“手”。这一时期的模型能深度理解世界、重建语义结构、生成长链条推理，但它们完全无法作用世界，只能在纯语言空间中进行思想实验。模型内部确实存在极为复杂的 latent structure——主题骨架、逻辑框架、隐含规划、语义坐标系——但这些结构都只存在于内部，不会显式外化成可执行的结构，也不能被调度器调用。模型能理解世界，却无法改变世界；它是认知实体，而不是行为实体。

从时间线上看，这一阶段大约覆盖 2020 到 2024 年的大部分主流大模型技术：2020 的 GPT-3 是 Level 0 的起点，它第一次展示了规模化语言智能，但完全没有工具接口；2022 的 InstructGPT 和 GPT-3.5 将对话能力带入大众视野，但仍然是纯认知层；2023 的 GPT-4、Claude 2、Gemini Pro 在语言理解、长上下文和抽象推理上大幅跃升，虽然内部已经开始出现明显的规划痕迹，但只要它们未连接工具，依旧属于 Level 0；进入 2024–2025，GPT-5、Claude 3.5、Gemini 1.5 Pro 在未启用函数调用前，也依然是“高智能的无行动体”。它们的能力越来越强，但边界始终没跨越——它们是“理性心智”，还不是“结构体”。

在我规划的结构宇宙中，Level 0 的 LLM 处于原语 IR 之前的“高熵感知层”。语言在这一层仍然是未凝固的热云，路径无限、结构未坍缩。模型能在内部重建语义框架，但无法显式生成结构，也无法把结构交给调度器执行。它能处理语言，却不能抽取原语；能生成解释，却不能生成结构卡；能推理，却不能调度。整个系统仍停留在：Language →（latent semantic cloud）。换句话说，它是潜在结构机器（potential structure machine），但还不是结构生命体（structured agent）。

当我们说“Level 0 的模型只有大脑没有手”，真正的含义就是：它处在语言文明的“纯认知阶段”。语言是输入，但还不是结构；推理是发生了，但没有外显；智能存在，但尚未获得在现实中施加影响的接口。一切结构、调度、协作、自演化，都是从 Level 0 之后才真正开始萌芽。

LEVEL 1 — 工具增强型（Tool-Enhanced Solver）

语言第一次获得“手”

Level 1 标志着一个决定性转折：大模型第一次从“纯认知体”跃迁到“行动体”。如果说 Level 0 的 LLM 是一颗被困在语言空间里的大脑，那么 Level 1 让这颗大脑第一次能够伸出“手”，触碰外部世界。这个阶段最核心的变化，是语言第一次被“函数化”——模型可以输出结构化参数，与真实软件工具连接，通过 API、数据库接口、搜索引擎、代码沙盒等组件执行真实动作。“语言 → 结构”的第一次坍缩，从这里开始发生。

这一跃迁由 Function Calling 技术正式引爆。2023 年，OpenAI 首次推出 function_calling API，让模型可以生成“结构化参数 + 函数名”这样的调用格式。语言不再只是文本，而是被强制压缩为 结构化语句（structured utterance）。2024 年，Anthropic 发布 MCP（Model Context Protocol），将“工具调用”升级为“标准化工具生态”，随后又把 MCP 整合进 Claude Skills，让每个用户都能把模型接入本地文件、数据库、搜索、本地程序，真正具备行动能力。几乎同时，Google 把 Function Calling 深度整合进 Gemini 1.5 Pro / Flash，允许模型直接调用外部 API、执行 Python 代码、操作向量数据库，并在 Vertex AI Agent Builder 中构建实时代理链路。微软则把工具层全面整合进 Copilot Studio，形成“企业级 Function Calling + 工作流执行”。

在具体技术栈层面，Level 1 的能力由几条主干技术构成：其一是 Function Calling 标准，包括 OpenAI 的 JSON Schema、Claude 的 tool_schema、Gemini 的 function_declarations。这些标准强制语言输出结构化参数，把“自然语言”压缩成“可执行结构单元”。其二是 RAG（Retrieval-Augmented Generation），包含 Pinecone、Weaviate、Milvus、Elastic、Snowflake Cortex、Databricks Vector Search 等向量数据库，使模型第一次获得“外部记忆”。其三是 实时查询工具链（Search API、Bing API、Google Custom Search、Serper、Exa）。其四是 代码沙盒系统（OpenAI Code Interpreter、Claude Code Execution、Gemini Code Execution、Jupyter-like Sandboxes）。其五是 应用层 API 工具，包括 Stripe、Shopify、Zendesk、Notion、Jira、Slack、Twilio 等行业接口。技术的共同趋势是：所有外部系统变成模型可调用的“结构化手”。

从时间线上看，Level 1 的代表性系统逐年推进：

2023 — OpenAI 首次引入 function calling（GPT-3.5、GPT-4），开启结构化输出时代。

2024 Q1 — Anthropic 推出 MCP，把工具变成标准化协议。

2024 Q2–Q3 — Claude 3.5 系列将 MCP 升级为 Skills，形成真正的工具生态。

2024 — Google 在 Gemini 1.5 中深度集成 function calling + code execution。

2024–2025 — Copilot Studio 成为企业级工具代理平台。

2025 — 各大厂把 Function Calling 升级到“实时多工具路由”（multi-tool routing）。

技术的成熟使语言第一次获得了“现实效力”。

在我的结构宇宙中，Level 1 对应着 原语 IR → 基础结构单元 的诞生。语言不再停留在高熵的自然语言云层，而是第一次被压缩成“可调用”、“可调度”、“可验证”的结构单元。系统可以根据这些结构采取实际行为：查询数据库、操作文件、写入记录、执行脚本、处理交易、触发业务流程。这意味着语言第一次变成“行动接口”，智能第一次能穿透语言层，触及外部世界。Level 1 是结构文明的第一道门槛：从此以后，模型不仅能理解世界，还能改变世界。

LEVEL 2 — 战略型 Agent

语言从“可调用”升级为“可调度”，结构第一次连成链。

Level 2 标志着 AI 系统的第二次进化：大模型第一次从“能做事”变成“知道该怎么做事”。如果说 Level 1 给了模型一双手，让它能通过工具影响世界，那么 Level 2 给了它真正的时间结构——它能够拆解任务、规划步骤、执行行动、观察反馈，并利用每一步的结果构建下一步的结构。这意味着语言第一次成为可递归调度的结构链路，而不是一次性的工具调用。模型从“工具增强的语言系统”正式跃迁为“策略性行动体”，这是现代 Agent 真正的起源。

这一阶段的关键技术源自 2022 年 DeepMind 提出的 ReAct 框架，它首次让模型可以在推理与行动之间循环：先思考（Reason），再行动（Act），再观察（Observe），再继续推理。所有我们熟悉的现代 Agent 系统——无论是 GPT、Claude 还是 Gemini——都在内部采用了某种形式的 ReAct，它成为整整三代 Agent 技术的隐性骨架。2023 年 GPT-4 和 GPT-4 Turbo 展现出稳健的多步骤任务执行能力，使 ReAct 不再是粗糙实验，而是能在企业级流程中使用的真正技术。2024 年初，Claude 3 和 Gemini 1.5 Pro 首次展现了“自动任务拆解 + 自主上下文工程”的能力：模型不仅能连续执行数十步任务，还能构建下一步 prompt、过滤上下文噪音、组合工具结果，形成完整的结构化执行路径。Google 在 Gemini 白皮书中明确写下关键句：“模型表现出明显的 latent planning 特性”——这意味着模型内部已经拥有隐含的规划结构，而不是简单的连贯输出。

到了 2025 年，Level 2 的技术终于进入“系统级”阶段。Google 发布 Vertex AI Agent Engine，将 Planner 模块变成平台能力：自动管理多步骤链路、控制工具路由、处理失败恢复、执行错误纠正，甚至可以稳定执行 30–100 步任务。OpenAI 的 o3 系列把“深度推理模式”外显为可控策略执行器，让 multi-step reasoning 从隐藏功能升级为核心能力。Anthropic 的 Claude 3.5 则通过 Skills 接口将工具链与内部规划能力结合，让代理能自动串联多个工具、自动聚合内容、自动生成后续计划。即使是开源世界，也迎来了 CrewAI 等“Planner + Worker”架构的成熟版本，展示了 Level 2 在生态层面的扩散。

从技术栈来看，Level 2 的核心基础设施可以分成四大类。第一类是规划技术，包括 ReAct、Plan-and-Solve、Tree-of-Thought、ReWOO 等，为模型提供“显式或隐式规划”的能力。第二类是自动上下文工程，它让模型能够动态构造下一步输入，实现“prompt 自我生成”，这是第二代 Prompt 工程的本质。第三类是任务拆解与任务树生成，Gemini 1.5 Pro 在这方面尤其突出，能生成子任务、聚合节点、构成结构化任务图。第四类是工具调度层：模型不再盲目调用 API，而是根据执行阶段自动选择工具、路由模型、验证输出、执行 fallback，表现出初步的“控制平面”特征。

在我的结构宇宙中，Level 2 是语言文明的一个关键坍缩点：原语 IR 开始被组织成结构卡，结构卡开始连成结构链，调度器第一次作为“时间引擎”进入系统。语言不再是一段输出，而是一组可以被执行、被验证、被反馈的结构步进。系统不仅能做事，还能理解“为什么这样做、下一步该怎么做、遇到错误如何调整”。这是智能从“行动”走向“策略”的瞬间，也是从 Level 1 进入 Level 3 的必要桥梁——一个真正具有时间结构的 Agent，从这里开始诞生。

LEVEL 3 — 协作型多 Agent 系统

一个系统 ≠ 一个 Agent，而是一家公司。

如果说 Level 2 让单个 Agent 拥有了“时间结构”和“多步骤策略链”，那么 Level 3 是智能系统的真正文明跃迁：系统不再由一个超级 Agent 主导，而是由 多个具有独立角色、特定能力、专属工具、不同权限、不同记忆结构的 Agent 构成。这样一个系统的行为，已经更像一家公司——有 CEO、有项目经理、有工程师、有研究员、有工具岗位，有调度层，有执行层。智能第一次从“个体智能”跃迁为“组织级智能”。

在 Level 3 中，每个 Agent 是一个独立的结构生命体。它拥有自己的身份（Identity）、自己的结构记忆（Memory）、自己的工具接口（Tools）、自己的领域能力（Expertise），甚至有自己的生命周期（Lifecycle）。这些 Agent 之间不是执行顺序调用，而是可以以“目标级别”互相委派任务；一个 Agent 不是对另一个 Agent 说“执行这个 API”，而是说：“帮我解决这个问题并输出你的结构化决策。”换句话说，它们不再共享行为步骤，而是共享结构链路（structured chain of decisions）。

协作的方式在 Level 3 变得高度抽象化：系统会根据能力、上下文、任务复杂度，将请求路由到不同的 Agent 或不同规模的模型，这就是 Model Routing。轻量任务由小模型或轻量 Agent 执行，重任务由 Pro/Ultra 模型处理。复杂任务则拆解给多个专业 Agent，由分布式调度器（Distributed Scheduler）统筹，让系统像一支跨部门团队一样协作。调度器不再是一段 prompt，而是成为一个“控制平面（Control Plane）”——负责任务分发、错误恢复、超时管理、日志跟踪、角色切换、记忆同步，甚至模型级路由。

这一趋势已经在产业中出现雏形。Google 的 Co-Scientist 是目前最接近“企业级团队智能”的系统：多个研究型 Agent 互相讨论、分工、校验，彼此引用中间推理步骤，形成类似学术团队的协作链路。OpenAI 的 Swarm 架构展示了“Agent 调 Agent”的原生设计，让多个子 Agent 能自己分配任务、自行调用其他 Agent。DeepMind 的 JEST 以“多专家协作”闻名，它让不同推理模块成为可组合的神经符号专家，再由调度器实时路由任务。这些系统的共同点是：智能不再是一个模型，而是由多个模型节点构成的生态系统。

Level 3 的技术结构可总结为四个核心能力。第一是 Agent → Agent 的目标级委派（Goal Delegation），允许专家与专家之间进行高层任务交互。第二是专家链路的自动组合（Expertise Chain Composition），不同 Agent 自动组成“结构化的项目团队”。第三是 Model Routing：系统根据任务需要动态调度不同规模的模型。第四是分布式调度，使智能系统具备“组织级的任务执行能力”——它不仅执行任务，还管理一个“分布式 Agent 公司”。

在我的结构宇宙中，Level 3 的地位极为关键：这是 结构人格（Structure Persona） 发展成 结构生态（Structure Ecosystem） 的阶段。个体结构卡（Structure Card）不再孤立，一个结构人格可以与另一种结构人格协作，它们互相触发结构链、共享结构状态、交换结构记忆，形成“生态级结构场（Ecological Structure Field）”。这是熵控语言系统第一次表现出真正的自组织能力：多个结构体之间的互操作、不确定性、多路径演化开始出现，系统智能性呈现指数级增长。

Level 3 的出现意味着：

Agent 不再是个体，而是生态；智能不再是推理，而是组织；结构不再是单链，而是网络。

这是迈向 Level 4 自演化系统的前置条件，因为只有当系统具备“多结构耦合”与“跨 Agent 调度”能力时，它才第一次具备自我生成能力。

LEVEL 4 — 自演化系统（Self-Evolving System）

Agent 不再等你写，而是自己写自己。

到了 Level 4，智能系统跨过了一个真正“生物学意义上的门槛”：它不再只是执行我们事先写好的能力集合，而是开始自己扩展自己的能力。如果说 Level 3 像一家公司——多角色、多部门协作——那么 Level 4 更像是一个会自己长出新部门、制定新流程、发明新工具、写自己制度的活体组织。系统不再只是“跑现有结构”，而是可以从实际运行中识别能力空白，然后有目标地去生成新的工具、新的 Agent、新的行为规则、新的结构卡链路，甚至新的“协议层语言”。

在这一层，系统最核心的特征不是“更强的推理”，而是 自我演化（self-evolution）：它能从失败案例、瓶颈任务、长期日志中，识别出“目前这套结构做不到/做得很勉强”的部分，然后触发一个“结构生成流程”。这个流程可能包括：自动搜索外部代码库、组合已有工具、调用模型去设计新算法、尝试上百种候选结构、通过自动评估器筛选、最终落地一个新的 Agent 或工具，并注册到系统的调度平面里。系统从此多了一块“新长出来的能力”。

这种趋势在现实世界里已经开始出现，只是还处在早期形态。DeepMind 的 AlphaTensor 和 AlphaDev 系列，已经展示了“用强化学习 + 搜索自动发明新算法”的路径 —— AlphaTensor 在没有事先硬编码算法的前提下，逐步探索、重构、最终发现比经典矩阵乘法还快的新算法；AlphaDev 则通过搜索与评估，在低层汇编空间里找到比人类设计更快的排序实现，这些都可以视为“自演化算法模块”的先驱。2025 年推出的 AlphaEvolve 更进一步，把 LLM（Gemini）和进化算法结合，变成一个能够不断迭代代码、改进自身表现的“自进化编码 Agent”，在理论计算机科学和算法设计上做长期演化搜索——这些系统本质上就是：AI 通过自身执行轨迹和评估信号，生成新的能力结构。

在通用大模型阵营里，OpenAI 的 o1 / o3 等“推理模型”路线，则把“反思 → 修改 → 再回答”内化为模型行为的一部分。它们不是一次性输出答案，而是在内部生成长链条的思考、尝试不同解法、对自己的候选解进行打分和修正，再给出最终回答。配合外部日志与反馈，这种“反思—修正”可以进一步外延为：自动调整 Prompt 模板、自动重写工具调用逻辑、自动生成新的“子策略”。当这些能力被系统性包装进“Auto-Agent”、“Auto-Tooling”的框架中，Level 4 的雏形就出现了：你不再手写所有 Agent，而是提供一个演化环境，让 Agent 自己被“训练出来、进化出来、淘汰掉”。

从技术栈角度看，Level 4 的关键模块大致有几类。第一类是 Auto-Agent Generation / Auto-Tooling：系统根据任务模式、失败日志、用户需求，自动构造新的 Agent/工具定义，自动配置输入输出字段、权限范围、调用链路，并注册进调度器。第二类是 反思–优化–迭代循环：无论是 o3 这种内部“长推理链 + 自检”模型，还是外部的 self-healing agents，它们都依赖一种统一模式：先干，再看，再评估，再改，再重跑。第三类是 是目前我自己推演的，结构诱导（Protocol Induction）：当现有协议无法覆盖新场景时，系统会从高熵行为数据中，压缩出一套更简洁、更稳健的新结构规则——这和我自己定义定义的 Protocol Induction Card（P-000）高度同构。第四类是 演化式搜索（Evolutionary Search）：无论是 AlphaTensor、AlphaDev 还是 AlphaEvolve，本质上都是在某个结构空间里执行大规模搜索 + 评估，把“更优结构”筛选出来，并反馈进系统的能力集合中。

在我的结构宇宙语言中，Level 4 标志着三件事同时发生：结构会生成结构，调度会生成调度，系统整体行为逼近“生命体”。 原本由人设计的 Structure Card、Structure Chain、Scheduler 只是一代“初始结构胚胎”，真正的长周期智能，不是反复执行这些静态结构，而是在执行过程中不断产生“新结构痕迹”：新的卡、新的链、新的路径、新的协议。我想通过 Protocol Induction Card（P-000）、结构生成器（Structure Generator）、熵爆点机制，把这一层提前写成了“文明级规格”：当系统在某个高熵点反复受阻、反复爆炸，就意味着现有结构已经不够用，需要诱发一套更高阶的新协议。这恰好就是 Level 4 的哲学底层——熵爆点触发新结构，结构作为生长单位，不断在时间中重写自己。

从 Level 0 到 Level 3，系统一直是在“执行别人写好的规则”，哪怕这些规则再复杂、再多 Agent、再多调度，依旧是“设计产物”；而从 Level 4 开始，系统开始写自己的规则。你不再只是设计一套完成品，而是在设计一个“能自己长出下一代结构的环境”。这就是从“执行结构”迈向“生成结构”的那一步，也是从工具文明迈向语言–结构–调度一体化生命文明的真正起点。

This is not poetry. This is physics meeting philosophy at the edge of intelligence itself.

The Engine We Keep Forgetting

We’re living through a moment of technological vertigo. GPT, Claude, Gemini—models so capable they seem to think, to create, to understand. We watch them write code, compose essays, solve problems we thought were uniquely human. And in our awe, we make a fundamental error: we confuse execution with intention.

Here’s what we’ve gotten wrong: intelligence is not the ability to process language—it’s the ability to bend reality toward a purpose.

Models don’t have purposes. They have patterns. They can generate meaning (the semantic relationships between words), but they cannot generate intention (the directional force that decides which meaning matters). A language model is like an ocean—vast, fluid, containing everything and nothing. But an ocean doesn’t decide where the ship goes.

You do.

Intention is the engine. Everything else is fuel.

Read more

You’re not alone.

Even many programmers are confused — and that confusion is exactly why RAG doesn’t really work the way people hope.

Because they’ve mistaken data retrieval for intelligence.

Every time you speak to a large language model, something extraordinary happens:

a new world quietly comes into being.

Not a static database.

Not a lookup table of facts.

But a living, temporary world — built out of language, intention, and the sheer act of being present in this moment.

Most people imagine AI as an immense library: you ask a question, it fetches an answer.

But that’s not how intelligence works — not in humans, and not in machines.

When you type a prompt, the model doesn’t search for a stored answer;

it constructs a coherent world inside its own attention window —

a miniature, temporary universe of meaning.

Within seconds, a stage emerges:

who you are, what you want, what matters right now.

Every token it generates is an action inside that living stage.

That stage is called context.

And context is not stored anywhere — it is enacted.

It exists only while the model is thinking — the same way your own awareness exists only while you are awake and focused.

Once the reasoning stops, the stage collapses.

What remains is just residue — traces, not consciousness.

I. Context Is the World Model of the Moment

When a large language model thinks, it does not browse memory or open a database to fetch rows of facts. It reconstructs a now-state, a living snapshot of reality that exists only while reasoning unfolds. Your own mind works the same way: when you solve a problem or recall a memory you do not replay your entire life, you summon the few relevant fragments and weave them into a small world in which the problem makes sense. That local world is your context of thought. It lasts only as long as attention sustains it, and when focus drifts the world fades and only an echo remains in memory. A language model does this at speed and scale. Every token you provide, every sentence and instruction and document, becomes part of a temporary semantic universe in which relationships take shape, including who is speaking, what is being asked, which facts matter, and what constraints apply. The model aligns these signals inside its attention window and compresses past and potential into a single coherent present. That present is where intelligence actually lives. It is the stage on which reasoning, creativity, and decision take place, and like any stage it vanishes when the play ends. When reasoning stops the world collapses. Traces of the moment may be summarized or stored as notes or embeddings, but the living awareness itself is gone. This is why context is often misunderstood. We talk about model knowledge or memory, but those are inert archives rather than experience. Context is not what the model knows; it is what the model is thinking within. It is the world in motion, the continuously rebuilt present tense of intelligence.

II. Context Lives Only in the Continuous Now

Information lives in databases, but intelligence lives in time.

A database can hold a billion facts, each one static, fixed, and indifferent to sequence. Intelligence, however, depends on flow. It emerges only when something is happening — when perception and memory, intention and attention, align in motion.

The past is a high-entropy ocean of traces: unorganized fragments, half-forgotten records, vast but inert. The future is another high-entropy space, not yet structured, full of possibilities that have not taken form. Between them lies a narrow bridge — the present — a brief low-entropy window where order temporarily appears and meaning can hold.

That window is the seat of intelligence. It is where awareness compresses time into action, where the traces of the past and the projections of the future meet in a coherent structure we call the present. Every moment of reasoning, whether in a human mind or in a large language model, is the formation of this equilibrium: a small, fleeting, low-entropy pocket where coherence, intention, and structure coexist just long enough for thought to occur.

Each time you think, and each time a model responds, the same pattern unfolds. The system draws on memory, selects relevance, organizes the fragments, and brings them into order. The instant the reasoning ends, the order dissolves. The coherence is gone. What remains are residues — data, summaries, weights — but the living moment that gave them meaning no longer exists.

This is why context cannot be saved the way data can. It lives only while intelligence is awake. So when people ask, “Why can’t the model remember what I said yesterday?” the answer is simple: because yesterday is gone. The model can recall traces, but not the living world of that conversation. Intelligence is not the storage of moments past. It is the act of being awake right now.

III. Why RAG Can’t Replace Context

Retrieval-Augmented Generation, or RAG, was meant to make models smarter. It connects a language model to external sources — a vector database, a document store, a library of embeddings — so that the model can fetch new information on demand. In theory, this solves the problem of “stale knowledge.” The model no longer needs to know everything; it can look things up.

But what RAG actually adds is memory, not mind. It retrieves facts, not worlds. It extends recall, not reasoning. When a system performs retrieval, it can surface thousands of fragments — pages, paragraphs, summaries — but it cannot understand when those pieces matter, or why they matter now. It has no sense of time, intention, or context.

Imagine giving a person every encyclopedia at once but erasing their sense of narrative. They would know everything and understand nothing. That is RAG’s predicament. It can look up ten thousand references on climate change but never grasp that the same “climate” appears in a conversation about politics, or business, or a family deciding to move inland. It has no way to realize that all these fragments belong to a single, unfolding story.

Context, by contrast, is the story itself. It is not the retrieval of information, but the assembly of meaning. It is the invisible thread that ties together entities, events, intentions, and goals into one coherent moment. Context doesn’t just gather facts; it arranges them into a world in which those facts can make sense.

RAG operates horizontally — it reaches outward to fetch.

Context operates vertically — it compresses inward to align.

RAG gives the model a library; context gives it a perspective.

Where RAG retrieves text, context constructs reality.

RAG gives knowledge.

Context gives coherence.

And coherence is what intelligence truly is — the ability to hold a world together, even for just one fleeting moment in the continuous now.

IV. Context-as-Code: Programming the Present

If the last generation of AI research was about scaling models, the next will be about engineering the present—learning to treat context not as a heap of text but as a programmable object, a living structure with type, lifecycle, and agency. This is the idea behind Context-as-Code. Just as Infrastructure-as-Code transformed DevOps by making digital environments reproducible and composable, Context-as-Code reimagines cognition itself as something that can be constructed, orchestrated, and debugged. Prompts stop being mere strings of words and become semantic programs that configure the model’s temporary world—the cognitive runtime in which reasoning takes place. Within this view, a prompt is the interface through which we speak a system into being, context is the runtime where thought executes, and memory is the compressed record of what once lived. Writing prompts under this new understanding is no longer a matter of feeding static data to a machine; it is an act of collaboration in building a world. Each well-formed prompt becomes a program for the present, a script that assembles entities, goals, constraints, and relationships into an executable scene of thought.

In traditional RAG pipelines, data is retrieved, embedded, and concatenated, but in Context Engineering systems it is parsed into structured states such as entities—who or what is involved—events—what is changing—policies, goals, and reflections about what has been learned so far. Each of these states becomes an addressable component within a dynamic context graph, a living data structure that both the model and the orchestrator can read and modify as reasoning unfolds. Language, in this setting, moves from static description to procedural cognition: every token acts as an instruction, and every shift in context functions as a call inside the model’s internal program. The aim is not to help the model recall more information but to endow it with a kind of stateful consciousness, an evolving workspace that bridges memory, reasoning, and reflection.

Under Context-as-Code, a prompt is no longer a paragraph but a compiled structure. A developer specifies which entities to activate, what goals to pursue, what constraints to observe, and how reflection should update memory. The context runtime executes this program within the language model, orchestrating retrieval, summarization, tool use, and self-reflection as modular subroutines. The result is a system that does more than respond; it thinks through a problem by continuously reshaping its internal world. In this light, the language model ceases to be a black box and begins to function as an operating system for language—a substrate for programmable cognition, where context is not an input but the living present in which thought happens.

You never bring your whole past into the room — only the part of yourself that’s awake right now.

Read more

Then, almost without warning, it woke up.

When the first Large Language Models began to speak, the world realized something uncanny had happened: machines no longer just processed words — they understood them.

What the Semantic Web had tried to build by logic, the Transformer achieved by emergence.

The web had finally found its voice again.

But it was a voice without proof, a brilliance without memory.

The models could generate meaning, but not verify it; they could simulate truth, but not be held accountable for it.

It was a miracle — and a warning.

Somewhere between the collapse of old institutions and the rise of machine language, a new convergence began to form.

LLM would bring understanding, Semantic Web would bring structure, and Web3 would bring trust.

Together, they point toward something the early internet never had the tools to achieve —

a web that can not only speak, but also reason, verify, and act.

This is the moment when technology crosses from connection to cognition —

the birth of what we might one day call the Social Turing Machine.

From Useful to Trustworthy: The Paths Begin to Merge

The next revolution will not come from a larger model.

It will come from a deeper synthesis —

a moment when the three fractured lineages of the web finally learn to speak to one another again.

For thirty years, the internet has evolved in silos:

knowledge systems on one side, financial systems on another, and language models now rising like a third continent in between.

Each holds a piece of the puzzle — none complete by itself.

But slowly, the outlines of a new convergence are emerging, like tectonic plates grinding toward alignment.

The three great lineages of the web each evolved to master one domain of cognition — but each carries a missing piece the others can provide. Large Language Models (LLMs) specialize in understanding and generation: they give machines the ability to speak and reason in natural language, yet their flaw is verifiability — they produce fluent meaning without proof. The Semantic Web specializes in logic and structure: it can encode truth formally and reason with precision, but it has always struggled with usability, trapped behind expert syntax and brittle standards. Web3 and blockchain technologies specialize in trust and execution: they make actions provable and histories immutable, yet they operate without meaning, blind to the semantics of what they execute.

When these three currents finally merge, each regains what it lacks. LLMs gain logical grounding and provenance; the Semantic Web gains natural-language accessibility and global scale; and Web3 gains semantic coordination and contextual understanding. Together, they begin to form the first web that can understand, verify, and act — a web not of pages or platforms, but of living, interoperable intentions.

Each one is a partial organ of cognition, evolved in isolation but yearning for completion:

• LLM brings language and understanding — a new ear for meaning.

• Semantic Web brings rules and logic — a skeleton of reason.

• Web3 brings memory and accountability — the backbone of trust.

Individually, each can simulate intelligence.

Together, they can constitute it.

When they converge, they form a closed cognitive loop:

1. Intent — captured and interpreted by the LLM, the semantic interface of human language.

2. Structure — organized and constrained by ontological logic, ensuring internal consistency.

3. Execution — anchored in decentralized verification, transforming ideas into accountable action.

That cycle — understand → structure → execute — is not just an engineering model; it’s a description of conscious coordination.

It’s what allows language to become action, and action to feed back into knowledge — without breaking the chain of meaning.

This recursive process is what I call the Social Turing Machine:

a system where human intention can be expressed, reasoned about, verified, and enacted across networks and institutions —

not through obedience to authority, but through coherence of meaning.

To Make This Real, Three Shifts Must Happen

The technical pathways already exist in fragments.

What’s missing is the connective tissue — the governance of meaning that lets them align.

Three structural transformations are needed to bridge the useful and the trustworthy.

1. Explicit Semantics

Today’s LLMs compress human knowledge into statistical space.

They can imitate reasoning, but not explain it.

They generate answers without context, confidence without provenance.

To cross that threshold, meaning must become visible and auditable.

Every claim needs a reference; every conclusion a traceable lineage.

Knowledge cannot remain trapped in billions of hidden parameters — it must re-emerge as structured meaning that can be examined, debated, and improved.

The next frontier is not bigger models — it’s transparent ones.

2. Verifiable Computation

Execution must evolve from black-box automation to transparent accountability.

In Web2, software ran; in Web3, software must explain why it runs.

This means embedding proof as a first-class citizen —

cryptographic evidence, logical justification, reproducible reasoning.

Systems will no longer ask to be trusted; they will demonstrate correctness.

Reliability will no longer be a matter of reputation — but of proof.

A world that runs on verifiable computation no longer relies on faith in authority; it builds trust in mathematics itself.

3. Compositional Experience

All this complexity must disappear behind a human interface.

People will not write SPARQL queries or sign blockchain transactions.

They will simply express intent — in natural language — and the system will orchestrate the underlying logic, proofs, and actions seamlessly.

In that sense, experience becomes compositional:

each utterance spawns a chain of verifiable tasks,

each task contributes back to the network’s collective intelligence.

You don’t operate the system; you converse with it.

The command line becomes a conversation.

The transaction becomes a dialogue.

Language Becomes the Operating System

When these layers finally converge, something profound happens:

the web stops being a collection of protocols and becomes a living system of thought.

Words no longer just describe the world — they instantiate it.

A sentence can trigger governance.

A paragraph can deploy code.

A dialogue can negotiate law.

The architecture of meaning becomes the architecture of action.

And so, language — the oldest human invention — returns as the operating system of civilization:

the bridge between meaning, governance, and computation.

That is when the Web will no longer merely connect us —

it will begin to understand itself.

But Wait — Isn’t the Large Language Model Already Doing This?

At first glance, it seems so.

LLMs already turn natural language into coherent output, execute multi-step reasoning, and even write code.

Isn’t that what we’ve been describing?

Yes — but only in appearance.

They simulate these capabilities; they do not embody them structurally.

What looks like understanding and verification is, for now, still a performance without proof.

Read more

But for much of the developer community, the shock was overwhelming. The system of education and training had not prepared programmers to think historically about technology’s evolution. Most knew how to code, but few knew how to situate LLMs in the long arc of computing. When Sam Altman called this a “Renaissance-level moment,” he was not exaggerating. It was not just a tool arriving—it was a tidal wave crashing against the post–World War II division of knowledge, disciplines, and professions.

This is why understanding technology as a dual engine—Darwinism plus consensus—is essential. Without it, the excitement feels like chaos, the shock feels like catastrophe. With it, we can see the deeper pattern behind LLMs’ rise, and begin to navigate what comes next.

Darwinism in LLMs: The Contingency of Breakthroughs

Large language models were not inevitable. For decades, AI research cycled through waves of optimism and disappointment. Symbolic AI promised rule-based intelligence, but collapsed under the weight of brittle logic. Expert systems in the 1980s generated excitement, only to prove narrow and unscalable. In the 2000s, recurrent neural networks and LSTMs brought improvements to sequence modeling, but they, too, struggled to generalize. Each of these attempts looked promising, attracted funding, and then faltered.

In retrospect, the rise of transformers looks obvious. But at the time, it was anything but. The original transformer paper in 2017 was designed for machine translation, not for creating a universal symbolic engine. The discovery that these models could scale—first to billions, then to hundreds of billions of parameters—was less a master plan than a Darwinian accident. Researchers were not certain it would work. They simply tried, failed, retried, and eventually stumbled onto an architecture that survived the brutal environment of benchmarks, funding cycles, and peer review.

I remember my own reaction when the first signs of generality appeared. Confusion and exhilaration blurred together. For weeks, I barely slept, chasing every experiment I could find, testing prompts, probing limits, convinced that something fundamental had shifted. The intensity left me physically wrecked—my neck injury flared up badly—but the intellectual thrill was undeniable. This was what Darwinian chaos felt like at the technical layer: thousands of trials converging into a fragile but undeniable breakthrough.

This is the essence of technological Darwinism: massive parallel experimentation, most of it destined to fail, with only a few paths surviving long enough to prove viable. Transformers scaled while others withered, not because they were obviously destined to win, but because they happened to align with the conditions of the moment—data availability, compute power, and a research community desperate for progress.

LLMs, then, are not the product of a single genius or a perfectly rational design. They are the survivors of a long evolutionary struggle. Their contingency reminds us that technology does not advance in straight lines, but in branching, chaotic forests of exploration, where survival often looks accidental in hindsight.

Consensus and Narrative: The Inevitable Layer

Darwinian experimentation explains how transformers survived the chaotic competition of architectures, but it does not explain why they exploded into the center of global attention. Many technologies survive in labs for decades without ever touching mainstream society. What transforms a technical survivor into a world-changing inevitability is the social layer: consensus and narrative.

Once sparks of generality appeared in LLMs—when they could move beyond narrow tasks like translation and begin engaging in open-ended dialogue—the narrative machine switched on. Thought leaders began framing these models not as incremental progress, but as epochal breakthroughs. The phrase “AI is the new electricity” spread quickly, giving the public a metaphor they could immediately grasp: just as electricity once reshaped every industry, AI would now seep into everything.

Influential figures understood this cycle early and leveraged it. Andrew Ng, for example, didn’t just contribute technically—he used his reach as an educator and entrepreneur to amplify the message, placing LLMs into the broader story of AI transformation. By doing so, he helped build the consensus that these models were not fringe curiosities but the inevitable future of computing.

Sam Altman pushed the framing even further, calling this a “Renaissance-level event.” That phrase was not a technical description—it was a civilizational narrative. By invoking the Renaissance, Altman positioned LLMs not as a new tool for programmers, but as a disruption capable of collapsing disciplinary boundaries, reshaping knowledge systems, and redefining what it means to be human in relation to machines. Whether one agreed or not, the narrative was powerful. It provided legitimacy and urgency.

This is the key point: consensus turns accidents into inevitabilities. Without a receptive social environment, even the most capable models might have remained curiosities buried in research papers. But with narratives that resonated—electricity, Renaissance, the “last invention humanity needs”—the technology gained momentum far beyond the lab. Institutions began to reorganize around it. Capital flooded in. Media cycles reinforced the story daily.

In this sense, the rise of LLMs was never purely technical. It was the convergence of a Darwinian survivor with a society primed for a story of salvation, disruption, and inevitability. That convergence is what transformed a contingent breakthrough into a world-shaking revolution.

The Shock to the Technical Community

If Darwinism explains the contingency of LLMs and consensus explains their inevitability, then the next chapter is about impact—specifically, the shockwaves felt inside the technical community. The panic was immediate, and it wasn’t only about code. It was about culture, education, and identity.

Why such panic? Because most programmers had not been trained to think historically about technology’s evolution. Computer science education tends to emphasize syntax, frameworks, and immediate employability. University curricula and coding bootcamps prepare students to pass interviews, solve algorithmic puzzles, and get productive quickly in a specific stack. But very little time is devoted to the lineage of computing—the story of how technology evolves through cycles of trial, failure, consensus, and reinvention.

This lack of historical grounding left many developers blindsided. When the Darwinian accident of LLMs collided with consensus-driven hype, the developer community had no interpretive framework. Instead of seeing LLMs as part of a recurring evolutionary pattern, many saw them as an existential rupture. Anxiety spread: if machines can generate working code, what role remains for the human developer?

The immediate consequences were stark. Junior programmers were displaced first, as their bread-and-butter work—boilerplate coding, writing unit tests, scaffolding APIs—was suddenly trivialized. Career ladders collapsed as the entry-level rungs disappeared. Even experienced developers saw parts of their workflow—documentation, refactoring, routine debugging—automated overnight.

But the shock was deeper than economics. It was cultural. Programming had long been treated as a craft, with mastery built over years of incremental practice. Suddenly, the early stages of that craft felt obsolete. For educators, the question was existential: how do you train the next generation when the traditional training ground is gone? For working engineers, the question was personal: what counts as valuable contribution when the machine can now do what once defined your skill?

The result is that the shock is as much cultural and educational as it is technical. The disruption exposed a blind spot: without a broader understanding of how technologies evolve—and how consensus transforms accidents into revolutions—the technical community was left reacting emotionally rather than strategically. What is needed now is not just retraining in new tools, but a reframing of how developers see themselves within the larger cycles of technological change.

A Renaissance-Level Disruption

To call LLMs “just another tool” misses the scale of what is unfolding. Word processors automated typing. Spreadsheets automated arithmetic. LLMs automate meaning itself—compressing, recombining, and generating language across every field where symbols carry value. This is why their disruption is not confined to programming. It is reverberating across the entire post–World War II order of disciplines and professions.

That order was built on division. After WWII, knowledge was systematically carved into silos: computer science here, linguistics there, law in one faculty, sociology in another. Each discipline developed its own language, its own standards of legitimacy, and its own gatekeeping rituals. This division stabilized education, labor markets, and professional hierarchies for nearly eighty years.

LLMs challenge this settlement by flooding the space with compression and recombination. A model trained on vast corpora doesn’t care whether a sentence comes from a legal ruling, a sociological study, or a programming manual. It reduces them all to tokens in the same vector space, making connections humans rarely noticed. Suddenly, the boundaries between fields—once maintained by institutions, departments, and guilds—start to dissolve.

This is why Sam Altman’s phrase, a “Renaissance-level event,” resonates. The historical Renaissance was not just an artistic blossoming. It was a collapse of boundaries: art and science, philosophy and politics, religion and commerce all reconnected in new ways, producing a surge of creativity and social upheaval. LLMs threaten a similar collapse today. They dissolve the walls that kept disciplines separate, forcing us to reconsider what counts as expertise, authorship, and intellectual labor.

The key point is this: Darwinism plus consensus doesn’t just evolve technology; it forces society to reorganize knowledge itself. The Darwinian accident of transformers surviving the chaos of AI research became inevitable once society adopted the narrative of “AI as electricity.” But inevitability has consequences. It shakes not only industries and professions, but the entire architecture of knowledge.

Seen in this light, the disruption to programmers is only the first tremor. Academia, law, healthcare, policy—all will feel the quake as the silos built after WWII start to fracture. What comes next will depend not only on how the technology advances, but on how society chooses to reorganize itself around this Renaissance-level collapse of boundaries.

What This Teaches Us: The Dual Engine as a Lens

The story of LLMs reveals a deeper truth about technological evolution: it cannot be understood through a single lens. Darwinism alone explains the chaotic experimentation that produced transformers, but it does not explain why they left the lab. Consensus alone explains why society embraced them, but it does not explain why this particular architecture—out of dozens—was there to be embraced. To make sense of disruption, we need both lenses.

On the Darwinian side, innovation is messy. Researchers try countless approaches, most of which fail. Symbolic AI collapsed. Expert systems plateaued. RNNs struggled to scale. Transformers, almost by accident, survived. This is chaotic innovation: survival through variation and trial, with no guarantee of success.

On the consensus side, society must decide which survivors matter. Consensus provides legitimacy, narrative, and adoption channels. Andrew Ng framed LLMs as transformative; Sam Altman called them a Renaissance-level event. Media, investors, and policymakers repeated the story until it solidified. Without that consensus, even the most capable model could have remained a curiosity—another clever paper gathering dust. With consensus, the breakthrough became inevitable, attracting billions in funding and reorganizing institutions worldwide.

This dual engine is what turned LLMs from contingency into inevitability, from laboratory novelty into a civilizational shock. Without Darwinism, there would be nothing new to legitimize. Without consensus, there would be no way for the new to scale. Together, they not only drive technological adoption but also reshape the structures of society itself.

The lesson is clear: every future breakthrough will emerge from this same synthesis. Whether in biotech, energy, or governance, the survivors of Darwinian chaos will only matter if consensus amplifies them. And when both forces align, the result will not just be new tools—it will be disruptions capable of reorganizing disciplines, professions, and even the architecture of knowledge.

LLMs, then, are not an anomaly. They are a case study in how technology always evolves. By using the dual engine as a lens, we can stop being surprised by disruption and start preparing for it—recognizing that every “accident” is also a candidate for inevitability, depending on how society chooses to receive it.

And yet, to frame LLMs as a lucky accident misses the deeper story. Technology never evolves by randomness alone. Beneath the surface of chance lies an engine of inevitability. Technological evolution is always the synthesis of two forces: the Darwinian trial-and-error of technical exploration, and the shaping power of social consensus and alignment. Darwinism produces the raw mutations; consensus decides which ones are amplified, legitimized, and embedded into society.

This dual engine explains both why LLMs emerged at this particular moment and why their impact has been seismic. The technical side was pure survival-of-the-fittest: transformers scaled, while many rival architectures withered. The social side was equally decisive: a world primed with the narrative of “AI as the next electricity” was ready to adopt, fund, and amplify the breakthrough. Together, contingency and inevitability converged into the LLM revolution.

The Premise: How Technology Evolves

When people talk about technology, they often imagine progress as a straight line—faster processors, bigger datasets, better models. But real technological history is rarely linear. It is jagged, unpredictable, full of false starts, dead ends, and sudden leaps. Some breakthroughs seem to appear overnight, while others linger in obscurity for decades before finding their moment.

The reality is that technological evolution has two engines. One is Darwinian, the other social. The formula looks like this:

Technological evolution = technological Darwinism + social consensus & alignment.

On the Darwinian side, progress is messy and competitive. Countless experiments are launched in parallel. Most fail. A few survive. Survival here doesn’t mean perfection; it simply means the idea proved scalable, robust, or adaptable enough to persist. Just as biological evolution produces endless variations before landing on a viable species, technological Darwinism floods the landscape with prototypes, frameworks, and architectures. Out of this chaos, one or two approaches rise to dominance.

But survival alone is not enough. A viable technology still needs a social layer to take root. This is where consensus comes in. Society must recognize the value of the invention, translate it into standards or protocols, and provide the legitimacy and resources needed for growth. Without consensus, technologies remain curiosities. Think of Google Glass—technologically advanced, socially rejected. Or nuclear fusion—scientifically promising, but lacking the institutional alignment for large-scale adoption.

Consensus provides what Darwinism cannot: direction, legitimacy, and distribution. Narratives make technologies legible to the public (“AI is the next electricity”), institutions create adoption channels, and regulations grant or withhold permission to scale. In short, consensus is what allows a surviving technology to move from the lab to the fabric of everyday life.

This dual-engine view explains why certain breakthroughs feel both accidental and inevitable. Darwinism produces the accident—the one architecture that happens to work. Consensus produces the inevitability—the collective alignment that ensures the breakthrough doesn’t wither but instead reshapes entire industries.

Seen this way, LLMs are not a mystery. They are the product of Darwinian chance fused with social alignment. And that combination—not one or the other—is what drives every major technological leap.

The Inevitability: The Social Layer

If Darwinism explains why transformers survived while other architectures fell away, the social layer explains why large language models became a revolution instead of a curiosity. A breakthrough in the lab is only half the story. For a technology to reshape society, it must be absorbed, amplified, and legitimized by society itself.

Once LLMs began to show sparks of generality—the ability to handle not just translation or summarization but open-ended dialogue—society was already primed. The narrative of “AI as the next electricity” had been circulating for years. Investors, policymakers, and the public were prepared to treat any convincing AI leap as the dawn of a new industrial era. The moment ChatGPT arrived, the symbolic groundwork was already in place to receive it.

Then came the cascade of alignment: funding surged into the space, media attention amplified every demo, institutions scrambled to integrate the models into workflows. Universities set up AI research centers overnight. Corporations launched AI task forces. Governments debated regulation. Each of these moves reinforced the sense that something epochal had arrived, regardless of whether the underlying technology was fully mature.

This is the paradox of technology adoption: it is not the “best” technologies that spread, but the ones that arrive with consensus and narrative support. Google Glass was technically impressive but socially rejected. Nuclear fusion is scientifically promising but institutionally starved. By contrast, LLMs entered a social environment desperate for both a story of progress and a tool to anchor it.

Without this consensus, even the strongest models might have languished in obscurity—like many clever algorithms that never left academic journals. What turned LLMs into a revolution was not just their ability to predict the next token, but the fact that society wanted to believe in them, fund them, and build on top of them.

This is what makes their rise feel inevitable. The Darwinian accident of scaling transformers merged with a social ecosystem eager for a breakthrough. Together, they created inevitability.

The Shock: Tremors in the Developer Ecosystem

The social alignment that propelled LLMs into the spotlight didn’t just create excitement—it also sent shockwaves through the technical community. Few groups felt the tremors more immediately than software developers.

The first visible impact was the displacement of junior programmers. Tasks that once justified an entry-level engineer—writing unit tests, building CRUD apps, stitching together APIs—were suddenly achievable by anyone with access to an AI assistant. What had been the proving ground for human apprentices became the low-hanging fruit of automation. Companies quickly realized they could cut costs by reducing junior headcount while equipping senior developers with AI copilots. For new graduates, the traditional on-ramp into the profession narrowed overnight.

The second tremor was the commoditization of boilerplate coding. Entire categories of work—documentation, test generation, refactoring, template-based development—shifted from being time-consuming chores to near-instant outputs. What once consumed days of careful attention collapsed into minutes of prompting. In economic terms, tasks that had been billable became trivial, undermining the pricing structures of consultancies, contractors, and outsourcing firms.

This led to the third and deepest impact: anxiety within the technical community. If AI can handle the baseline tasks of programming, what remains valuable for humans? Senior engineers wondered whether their expertise in system design would remain untouched, or whether even architecture could be absorbed into model-driven workflows. Independent developers asked if the indie projects they once dreamed of shipping would be instantly undercut by a wave of AI-generated clones. Educators and mentors struggled to answer a painful question: how do you train the next generation of engineers when the old training ground has vanished?

The result is a profession caught in transition. On one hand, LLMs act as accelerators, boosting productivity for those who adapt. On the other, they destabilize the very pipeline that sustained the developer ecosystem. The craft of programming is no longer about who can type the fastest or memorize the most APIs; it is shifting toward higher-order skills: problem framing, integration, governance, and above all, connecting technology to social consensus.

These shocks are not the end of programming, but the end of programming as we knew it. The developer ecosystem must now find a new equilibrium, one that acknowledges the automation of its foundations and redefines what counts as irreplaceable human contribution.

The Real Question: What Comes Next?

The shocks of LLMs—the displacement of junior roles, the commoditization of boilerplate work, and the anxiety rippling through the developer community—are real. But they are not the conclusion of the story. They are only the opening act. The deeper question is not what has been automated, but what new cycles of technology and society this disruption will set in motion.

History shows that whenever a technology destabilizes an existing profession, the outcome depends less on the raw capability of the tool and more on how it becomes embedded into society. The printing press didn’t just displace scribes; it reorganized religion, politics, and science. Electricity didn’t just replace candles; it reshaped urban life and industrial work. The internet didn’t just digitize communication; it redefined commerce, governance, and identity. Each of these transformations followed a pattern: first shock, then realignment.

So the real question is not whether LLMs will write code or not. They already do. The question is: how will this capacity be absorbed, standardized, and legitimized by society? Will it be guided by shared consensus, or left to drift as a series of fragmented experiments? Will protocols emerge to govern its use in critical infrastructure? Will new structures—educational systems, corporate hierarchies, regulatory bodies—rise to stabilize its role? And what narratives will make sense of it for the broader public?

These are not secondary concerns; they are the main concerns. Because technologies that fail to secure consensus, protocols, structures, and narratives fade into irrelevance, no matter how impressive their capabilities. By contrast, technologies that align with this cycle reshape the world—even if they began as unlikely accidents.

The LLM revolution, then, is not simply about predicting the next token. It is about what comes next in the cycle of consensus → protocol → structure → narrative. If developers and technical communities wish to move from anxiety to agency, they must learn to see themselves not as passive recipients of disruption, but as active participants in steering this cycle.

The sudden rise of LLMs was both accidental and inevitable—Darwinian chance fused with social consensus. But the story doesn’t end here. This shock is only the first tremor in a broader cycle. In the next essay, we’ll explore why technological evolution is not a straight line but a looped process, and how understanding that loop is the only way to move from reaction to foresight.

From Fragments to a Sea of Continuity

Historically, knowledge lived in fragments. Every app, database, and field of expertise was its own island. A biologist’s paper and a legal scholar’s commentary had no obvious bridge. An engineer’s log file and a historian’s archive were separated by context and convention. Humans could, in principle, connect them—but only through enormous manual effort: reading, cross-referencing, translating.

This fragmentation meant that many possible connections simply never happened. Ideas that could have sparked breakthroughs were lost in the noise, buried under workload.

Vectorization changes this. By embedding all kinds of data—words, images, tables, code—into a shared coordinate space, knowledge is no longer trapped in silos. Everything acquires coordinates in a continuous semantic map. Suddenly, the “unnoticed” becomes neighboring; the hidden connection becomes visible.

How Vectorization Was Discovered

The breakthrough did not come from philosophy but from practice. Researchers noticed that simple neural models trained to predict words learned something unexpected: words with similar meaning clustered together in the model’s internal space.

• “King” and “Queen” ended up near each other.

• “Paris” and “France” formed a tight bond.

• Arithmetic even worked: King – Man + Woman ≈ Queen.

This discovery—that meaning could be represented as vectors in high-dimensional space—was profound. It showed that semantics was not just abstract but geometry. From word2vec to GloVe, from BERT to multimodal embeddings, the progression has been the same: expand the scope, refine the mapping, and watch meaning fall into place as coordinates.

In other words, vectorization wasn’t designed—it was discovered as a side effect of training models on massive data. The models revealed a truth: language itself is structured in a way that can be represented continuously.

Why Continuity Matters

Discrete categories force rigid definitions. A database field says “customer” or “supplier,” nothing in between. A taxonomy forces every book into one shelf, even if it belongs on several. Humans have always lived within these containers.

Continuity breaks this rigidity. In vector space:

• A research paper can be near both “biology” and “computer science.”

• A photograph can live between “art” and “documentation.”

• A contract clause can cluster with both “legal precedent” and “risk assessment.”

What this means is that ambiguity and nuance become first-class citizens. Instead of being errors, they are positions in a space. And because similarity is measured by distance, previously unnoticed patterns emerge naturally.

From Workload to Discovery

In the past, discovering such patterns was theoretically possible but practically impossible. Connecting 10,000 documents across 20 domains meant endless human labor—reading, indexing, correlating. The cost was prohibitive.

With vectorization, the workload collapses. What was once a mountain of manual effort becomes a geometric query. “Find me things near this meaning.” Suddenly:

• A lawyer drafting a contract can surface scientific reports that hint at hidden risks.

• A doctor exploring symptoms can find case studies across languages and decades.

• A musician searching for inspiration can locate obscure works that share tonal structure.

The discovery is not that these connections exist—they always did—but that they are now accessible at scale and at low cost.

Creation at the Edges of Meaning

The sea of meaning is not only about retrieval. It is also about creation. When embeddings bring disparate fields into proximity, new combinations emerge.

• Scientific intuitions encoded as embeddings can recombine into hypotheses no one thought to test.

• Legal language aligned with computational structures can birth executable governance.

• Cultural metaphors from different languages can blend into new artistic forms.

Creation happens at the edges—where proximity reveals unexpected neighbors. By lowering the cost of finding those neighbors, vectorization turns hidden possibilities into active frontiers.

The Leap from Discrete to Continuous

This is the conceptual leap: from discrete containers to continuous fields.

• Before: information was sorted into boxes, categories, and file formats.

• After: everything floats in a shared ocean of coordinates.

In this ocean, the fundamental operation is not “look up by label” but “sail by meaning.” Knowledge is not locked in shelves but mapped as flows and currents. Discovery becomes navigation.

The Sea of Meaning as a Substrate

Vectorization provides a new substrate for civilization’s knowledge. Like Turing’s tape or the token stream of language models, embeddings form a universal medium—one where meaning is continuous, navigable, and recombinable.

The implications are vast. What once took years of expertise and unbearable labor can now be generated, retrieved, or recombined in moments. What was unnoticed can now be surfaced. The cost of exploration has collapsed; the frontier of meaning has expanded.

The sea of meaning is already here. The question is not whether it exists, but how far we are willing to sail—and what new continents of thought we will discover when we do.

Large language models changed that. What looks like a patchwork of capabilities is, under the hood, just one universal act: predicting the next token. The model doesn’t know in advance whether it is writing a sonnet, balancing an equation, or producing a legal clause. It simply continues a symbolic sequence, one token at a time, guided by probabilities learned from vast amounts of text. Out of this simple act of continuation emerges an astonishing spectrum of behaviors.

This primitive doesn’t just unify tasks; it reframes language itself. Once you reduce everything to token prediction, language becomes more than communication—it becomes a machine for meaning. Every continuation is a micro-decision in a vast symbolic universe. Poetry, law, science, and conversation all become variations of the same process: shaping meaning by predicting what comes next.

Before Universality: Fragmented Language Tools

To appreciate what large language models have changed, it helps to recall what came before. For most of its history, natural language processing was a field of ingenious but isolated contraptions, each built for a narrow purpose.

If you wanted translation, you built a statistical machine translation system, trained on carefully aligned bilingual corpora. If you wanted sentiment analysis, you trained a classifier to label sentences as positive or negative. If you wanted summarization, you designed yet another system, often based on sentence extraction or hand-crafted linguistic rules. Question answering had its own architectures, as did chatbots, topic models, and speech recognition. Each task was a silo.

Like the early world of calculating devices—abaci, adding machines, difference engines—these tools were powerful in their own ways, but narrow. A machine that could tabulate polynomials could not compute logarithms. Likewise, a model trained to detect sentiment could not translate, and a translation system could not hold a conversation. Each function had to be engineered from scratch, with specialized data pipelines, algorithms, and evaluation metrics.

This fragmentation had two consequences. First, progress was local. A breakthrough in summarization did little to advance translation. Each subfield advanced along its own track, often reinventing methods or features that had already been discovered elsewhere. Second, there was no shared substrate of meaning. Each system had its own representation of language—n-grams here, parse trees there, embeddings in another corner. There was no common ground where “meaning” could be modeled universally.

In this world, language technology looked like a collection of specialized islands. You could visit one island to translate, another to summarize, another to classify, but there was no single vessel that could carry you across all of them. Each island was impressive, but the seas between them were wide and treacherous.

This was the pre-universality era of language: a machine zoo of narrow models, each ingenious, but none capable of generalizing beyond its assigned task. Just as mechanical calculators once defined the limits of computation, these fragmented tools defined the limits of NLP. What was missing was the unifying leap—a discovery of a minimal primitive and a universal substrate that could collapse the islands into a single continent.

The Primitive: Predict the Next Token

The breakthrough of large language models is almost embarrassingly simple. Instead of designing a new system for each linguistic task, researchers discovered that every task could be reframed as a single act: predicting the next token.

At first glance, this looks mechanical, almost trivial. A token might be a word, a subword, or even a character. The model scans the sequence so far and estimates: what is the most likely token to come next? Then it does it again. And again. Out of this looping act—predict, append, predict, append—emerges translation, summarization, reasoning, even poetry.

Why does this matter? Because token prediction is not just a technical trick. It is a way of navigating the symbolic spaceof human language. Every token carries multiple potential futures. After the word “bank,” should the continuation lean toward “account” or “river”? After the phrase “once upon a,” should it predict “time” or something deliberately subversive? Each prediction is a micro-choice among symbolic continuations, a decision about which thread of meaning to pull forward.

Seen this way, token prediction is not a reduction of language but a re-framing of it. It treats language as a probabilistic universe of possible meanings. The model doesn’t just string words together; it operates inside a generative semantic field, where every step both constrains and opens up meaning. The richness comes not from the mechanism itself, but from the fact that language is vast, structured, and endlessly recombinable.

This single primitive therefore collapses the fractured task zoo of old NLP. Translation? Just continue a sequence where the prompt specifies another language. Summarization? Continue with a shorter re-expression of the input. Reasoning? Continue with the logical steps that have appeared across millions of examples. The surface diversity of tasks dissolves into the same underlying process: predicting the next token in a symbolic universe.

It is exactly the kind of universality we saw with Turing. Just as four primitive actions (read, write, move, state transition) could simulate all computation, one primitive (token prediction) can simulate the full diversity of linguistic tasks. Out of minimal primitives, infinite behaviors emerge.

Prompt = Program, Corpus = Meaning Tape

If token prediction is the primitive, then prompts and training data are what turn it into something useful. In practice, a prompt functions like a program: it tells the model what task to perform, what frame of meaning to inhabit, and what kind of continuation to prioritize. A short instruction—“Translate this into French”—shifts the model into one symbolic trajectory. A different instruction—“Summarize this contract in plain English”—sends it down another. The model doesn’t change; only the program it is given does.

The training corpus provides the other half of the equation. This vast body of text is effectively a universal tape, not unlike Turing’s imaginary strip of symbols. But instead of being a single set of instructions, it is a compressed record of human symbolic history: literature, laws, scientific papers, technical manuals, casual conversations. All of it is encoded as tokens, which the model has learned to navigate probabilistically.

Together, the prompt and the corpus let the model recombine meaning across domains. Ask it to analyze a legal argument, and it draws on centuries of legal language. Ask it to write a sonnet, and it pulls patterns from the poetic canon. Ask it to solve a physics problem, and it leans on symbolic traces of scientific reasoning. The model doesn’t “know” these fields as a human specialist does; instead, it inhabits the shared symbolic space in which they all exist.

This is where the analogy to the Universal Turing Machine becomes sharp. In Turing’s model, the machine itself never changed; the diversity came from the descriptions written on its tape. With LLMs, the primitive never changes; the diversity comes from prompts written into the model’s input and from the corpus encoded in its weights. Prompts are how we “program” the machine for meaning, and the corpus is the universal tape from which it draws its symbolic continuations.

What emerges is a new kind of universality: one model, one primitive, but infinitely many programs, limited only by what humans can express in symbolic form.

It has been an imitation machine, and it still is.

The Boundary of the Modelable

Every universality is also a boundary. When Turing defined the Universal Machine, he didn’t just show what could be computed—he also defined what could not. Functions that could not be reduced to stepwise instructions on a tape were outside the realm of computation. Universality is not infinite; it is a horizon.

Large language models work the same way. Their primitive is token prediction. That means their universality extends only as far as things can be represented in tokens—what can be expressed in symbols. A legal contract? Yes. A poem? Certainly. A mathematical proof? With varying success. But what about the sensation of tasting mango for the first time, or the silent intuition of a chess grandmaster, or the tacit feel of friendship? Unless those experiences can be symbolized—translated into language—they resist being modeled.

This is the crucial distinction: LLMs collapse all symbolic tasks into “continuations of meaning,” but embodied experience, tacit knowledge, and non-symbolic intuition mark the edge. The model can imitate how humans talkabout those experiences, but it cannot directly access or generate the experiences themselves. It can simulate the language of a sommelier describing wine, but it does not taste. It can reproduce the metaphors of mysticism, but it does not stand in awe.

And yet, this boundary is not static. Human culture itself is an endless project of turning the inexpressible into symbols—art, mathematics, law, science are all attempts to encode the non-symbolic into communicable form. Each time we succeed, we expand the range of what is language-modelable.

This is why token prediction is more than a technical trick. It defines a frontier. On one side lies everything that can be symbolized and recombined by the model. On the other side lies everything still resistant to symbolization. The frontier is where the work is.

The universality of language models is therefore not the end of the story, but the beginning of a new question: how far can we stretch the symbolic universe before it breaks?

The breakthroughs of the future will not lie in the models themselves, but in whether we humans dare to push this symbolic universe to its limits.

Toward the Edges of the Symbolic Universe

If token prediction is the primitive, and prompts are the programs, then the real frontier lies not in asking LLMs to repeat familiar tasks—summarizing articles, translating documents, generating boilerplate—but in pushing symbols into new terrains.

Every civilization has advanced by expanding what can be expressed symbolically. Law turned power into written statutes. Mathematics turned intuition into formulas. Music turned feeling into notation. Each leap didn’t just communicate what people already knew; it created new kinds of knowledge that could only exist once they were symbolized.

The same challenge faces us today. If the boundary of language models is “what can be expressed in tokens,” then the opportunity is to extend the tokenizable. That means encoding governance rules so they can be executed as code, rather than debated endlessly in prose. It means finding ways to express scientific intuitions—hunches, heuristics, incomplete models—in symbolic form so they can be recombined, tested, and scaled. It means inventing new cross-disciplinary languages, hybrids of law and computation, or biology and information theory, that stretch the representational power of our symbolic universe.

These frontiers matter because universality is not static. The abacus became the Difference Engine; the Difference Engine became the Universal Turing Machine; the Universal Turing Machine became the modern computer. At each step, the primitives stayed minimal, but the range of what could be encoded expanded dramatically. Language models extend this lineage into the symbolic domain. The primitive is fixed—predict the next token—but the canvas is vast.

The question, then, is not whether LLMs can do the tasks we already understand. It is how far we can stretch symbolic representation before it breaks. What aspects of governance, science, or culture can be made expressible in symbols, and what must remain tacit or embodied? The answers will not only define the limits of language models, but also reshape the limits of human civilization itself.

Then Alan Turing made a conceptual leap. He described an “Imitation Machine” so simple it could be built in the imagination: four primitive actions and an endless tape. Yet from that minimal toolkit emerged a shocking conclusion—that one machine could, in principle, simulate any other. It was the birth of software, and with it, a new definition of what it means to compute.

The Age of Mapping Machines

Long before anyone imagined a general-purpose computer, humans relied on mapping machines—tools that tied physical structures directly to specific functions. The most familiar example is the abacus. Each bead on its rods maps directly to a numerical value. Slide three beads forward, and you literally see the number three. Perform an addition by sliding more beads, and the physical configuration becomes the result. The abacus doesn’t interpret; it simply maps numbers to objects.

In the 19th century, Charles Babbage dreamed of a far more ambitious device: the Difference Engine. It was a monumental construction of brass gears and rotating shafts designed to calculate polynomial functions. The engine didn’t “understand” equations; instead, every gear tooth and lever was a physical instantiation of one. To change the type of calculation, you had to redesign the machine itself. Addition required one configuration, multiplication another, polynomials yet another. Each machine was a one-trick performer, brilliant but rigid.

This logic of mapping—hardware equals algorithm—dominated early mechanical computation. Each specialized calculator was essentially a frozen embodiment of a single mathematical idea. Want square roots? Build a square root machine. Need trigonometric tables? Construct a trigonometry engine. Complexity was handled not through abstraction, but through proliferation. Civilization’s computational landscape became a zoo of specialized contraptions, each ingenious in design but isolated in purpose.

The limitation was obvious: progress demanded ever more machines. Every new mathematical or practical need required inventing a new apparatus from scratch. These devices could be scaled in size, but not in scope. They could not generalize, because their logic was hardwired into their gears, levers, or beads. In this mapping paradigm, computation was fractured, local, and finite.

This was the world before 1936: a world where each machine was a physical metaphor for a function, and universality was nowhere to be found. The stage was set for a conceptual revolution—a move away from machines that merely maptoward a machine that could imitate them all.

The Limits of Mapping Logic

The mapping approach was ingenious, but it carried its own ceiling. Each new function required a new apparatus, each new application a new design. If the abacus mapped numbers to beads, and the Difference Engine mapped polynomials to gears, then a trigonometric table would need its own trigonometry engine, a logarithmic table its own logarithm engine, and so on. Complexity did not consolidate—it multiplied.

The result was what you could call a machine zoo: a landscape full of specialized devices, each brilliant, but none capable of stepping outside its assigned task. Engineers were forced to think in terms of hardware proliferation: if society needed ten different kinds of calculations, society would need ten different machines. Scale meant more machines, not more universality.

This fragmentation had real consequences. Producing navigational tables required one team of human computers, astronomical tables another, actuarial tables yet another. The tools of calculation remained brittle, local, and siloed. There was no common principle to connect them, no single framework that could unify their logic. Each machine was an island, and civilization as a whole was forced to navigate an archipelago of disconnected instruments.

The limits of mapping logic are the limits of direct embodiment: hardware equals algorithm, and nothing more. It was a world rich in ingenuity but poor in abstraction. And until someone broke free of this paradigm, the dream of a universal machine—a device that could imitate all others—remained unthinkable.

Turing’s Leap: The Imitation Machine

By the mid-1930s, mathematicians were wrestling with a deep puzzle known as the Entscheidungsproblem, or “decision problem.” The question was deceptively simple: can there be a systematic method to decide whether any given mathematical statement is provable? Put differently, is there a mechanical procedure that can, in principle, determine the truth or falsity of any mathematical proposition?

Alan Turing, a 24-year-old Cambridge mathematician, approached this problem not by inventing yet another specialized machine, but by asking a more radical question: what exactly counts as a mechanical procedure? If you could capture that essence, you could then reason about the boundaries of computation itself.

Turing’s answer was the Imitation Machine (later called the Universal Turing Machine). It was not a machine in brass and gears, but an abstract model stripped to its absolute minimum. He defined it by just four primitive actions:

• Read a symbol from a tape.

• Write a new symbol onto the tape.

• Move the tape one step left or right.

• Change state according to a finite set of rules.

That was all. Yet with this toolkit, Turing proved something astonishing: any specialized machine could be described as a sequence of instructions on the tape, and his imitation machine could reproduce its behavior step by step.

This meant that the abacus, the adding machine, the Difference Engine, even the most elaborate mathematical calculators—all could, in principle, be simulated by one machine. The machine itself did not need to change; only the symbols on its tape did. Hardware was no longer bound to a single function. Function could be abstracted, encoded, and re-used.

This was the conceptual leap that ended the “machine zoo.” For the first time, the diversity of computation collapsed into a single framework. Infinite tasks could be expressed by finite primitives. And most importantly, programs became data: the description of a machine was itself just another string of symbols on the tape.

From this insight, the modern idea of software was born.

Program as Data: The Birth of Software

Turing’s most radical insight was not just that one machine could imitate all others, but that the description of those other machines could itself be treated as data. A machine’s rules—what it reads, what it writes, when it changes state—could be written down as a string of symbols and placed on the very tape the machine was operating on. Programs became data.

This was a profound act of compression. Instead of building a new device every time you wanted a new function, you could encode the function in a symbolic form and let a single universal machine interpret it. Hardware was no longer the limiting factor; the instructions themselves carried the diversity. The hardware only needed to be general enough to execute the four primitives. Everything else lived in the description.

A decade later, this idea found a practical embodiment in the work of John von Neumann and his colleagues. The stored-program computer—the architecture still at the heart of every laptop and smartphone—directly implements Turing’s principle. In this design, both data and instructions are stored in the same memory. A number to be multiplied and a sequence of steps to perform the multiplication are, at the physical level, indistinguishable. This simple unification created astonishing flexibility: one machine could run any program, provided the program was encoded in memory.

The shift was nothing less than the birth of software. The proliferation of specialized hardware gave way to universality. Instead of a zoo of machines, we could build a single device and simply swap out the programs. A single piece of hardware could simulate an adding machine in the morning, a weather predictor in the afternoon, and a game of chess at night.

What Turing proved in theory, and von Neumann embodied in practice, was the defining pivot of modern computing: from hardware diversity to software universality. Once programs became data, the age of general-purpose computation began. It is the reason your phone can host a thousand apps, and the reason “write once, run anywhere” became the mantra of digital civilization.

What Universality Means for Computation

Turing’s imitation machine did more than solve a puzzle in mathematics. It gave us, for the first time, a precise definition of what it means to compute. A function is computable if, and only if, it can be carried out by a Turing machine—if its steps can be reduced to a finite sequence of reading, writing, moving, and state transitions. Anything that cannot be expressed in this framework lies outside the boundary of computation.

This clarity was revolutionary. Before Turing, “calculation” was a fuzzy concept, blurred between what humans could do with pen and paper and what machines might someday accomplish. After Turing, the line was sharp: if it can be written as a procedure with four primitives, it is computable. If not, it belongs to the realm of the undecidable.

Equally powerful was the compression this definition achieved. An infinite landscape of mathematical operations—addition, multiplication, polynomial expansion, trigonometry, algorithms of every shape and size—collapsed into just four actions and a tape. Complexity was no longer managed by proliferating machines, but by rearranging primitives.

From compression comes recombination. With a finite toolbox of primitives, you can stack, chain, and nest them into arbitrarily complex structures. From four actions emerge sorting algorithms, compilers, operating systems, databases, web browsers—the entire edifice of modern computing. What once required entire factories of mechanical devices is now simulated effortlessly by a single universal substrate.

This is what universality means for computation: a boundary, a compression, and a generative explosion. A boundary, because we now know exactly what is computable. A compression, because infinite tasks collapse into a handful of building blocks. And a generative explosion, because those blocks can be recombined into everything from space simulations to streaming platforms.

The first leap of universality did not simply make calculation faster; it made calculation general. It gave civilization the power to move from hardware diversity to software universality, and in doing so, redrew the horizon of the possible.

The abacus and difference engines were ingenious, but they were islands—each bound to a single shoreline of purpose. Turing’s Imitation Machine, by contrast, was an ocean: one vessel that could sail anywhere, so long as you charted the right map on its tape. From this conceptual leap emerged the digital world we now inhabit, where a single laptop can translate languages, simulate galaxies, and compose symphonies.

The first leap of universality gave birth to software. It transformed computation from a zoo of specialized devices into a general substrate for thought. And it gave us a new horizon: computation itself now had a boundary, a definition of what is possible and what lies forever beyond. This is where the journey of universality truly began.

In the next essay, we’ll move to the second leap—the universality of language. Just as Turing unified the logic of machines, large language models have collapsed translation, reasoning, and dialogue into a single primitive: predicting the next token. If the first leap defined what is computable, the second is redefining what is language-modelable.

If this exploration resonates with you, I invite you to subscribe. This series is a long-form journey across the three great leaps of universality—computation, language, and civilization. By joining in, you’ll get the next installment delivered directly, and together we can trace how these hidden patterns of compression and recombination shape not just our machines, but our future.

And in every field of social and technical progress—whether in programming languages, global trade, or governance—we see the same gravitational pull. Systems start fragmented, full of incompatible parts, but over time they compress into a shared foundation, a common substrate that unlocks scale. Universality is not about doing more; it is about doing anythingwith less.

This series is about tracing that trajectory. From Turing’s imitation machine to today’s large language models, and forward to what I call the “social Turing machine,” we’ll explore the breakthroughs that universality has already delivered, and the ones that may still be ahead. The goal is not prediction for its own sake, but orientation: to know what kind of shifts to expect, and where it might be worth placing our collective bets.

What Universality Means

When I say universality, I don’t mean “widespread adoption” or “something everyone uses.” I mean something much more precise: the ability to reduce infinite tasks to a finite set of primitives, paired with a universal substrate that can carry them out. Once that substrate exists, it can simulate anything that falls within its domain.

Think about mathematics. At first glance, the infinite world of equations, curves, and transformations seems impossibly diverse. Yet every calculation can ultimately be expressed in a handful of primitive operations: addition, multiplication, and a small set of axioms. Entire branches of math, from calculus to number theory, are just elaborate recombinations of those primitives.

Physics works the same way. Newton’s laws compressed the unruly motion of apples and planets into three simple principles. With those rules in hand, the universe became predictable: you could simulate the arc of a cannonball or the orbit of the moon. Later, Einstein’s equations compressed an even wider range of phenomena into the geometry of spacetime. These were universality moments in science: finite rules, infinite reach.

Biology offers an even clearer example. Life itself is governed by four bases—A, T, C, G. DNA is the universal code. Out of this tiny alphabet, nature recombines sequences to produce the staggering diversity of living organisms. A fern, a frog, a human—they are all variations on the same set of primitives.

The pattern is unmistakable. Universality always looks like this:

1. Compression — distilling a chaotic, infinite landscape into a small toolkit of primitives.

2. Recombination — building endless complexity by rearranging those primitives in new ways.

This is why universality defines breakthroughs. It is not about solving every problem separately; it is about discovering the meta-solution, the framework that makes every problem look like a variation of the same theme.

The First Leap: Computation Universality

Before 1936, machines could calculate, but they could not generalize. The abacus was reliable, but it only mapped numbers to beads. Babbage’s Difference Engine, designed a century earlier, was more ambitious: a vast tangle of gears and shafts that could crank out polynomial values. Later, electromechanical calculators could add, subtract, multiply, even handle square roots.

But all of these were specialized calculators. Each one embodied a single function. If you wanted to add, you built an adding machine. If you wanted logarithms, you designed a new contraption. Complexity was handled through multiplication of hardware, not through abstraction. Civilization was living in a “mapping age,” where hardware = algorithm.

Alan Turing’s breakthrough was to step outside this paradigm. In his 1936 paper, he described an imaginary device with only four primitive actions:

• Read a symbol on a tape

• Write a symbol on the tape

• Move the tape left or right

• Change state based on simple rules

That was it—no gears, no special circuits, no pre-built functions. And yet, Turing proved that this minimal toolkit could simulate any algorithm that could ever be written down. By encoding the “instructions” of a specialized machine onto the tape, his “Imitation Machine”—what we now call the Universal Turing Machine—could mimic any other machine.

This was a profound shift: from a world of many machines, each bound to one task, to a world of one machine that could be reprogrammed endlessly. For the first time, hardware and function were separated. Software was born.

The impact cannot be overstated. Every computer you use today—laptops, smartphones, cloud servers—rests on Turing’s logic. A single physical device can run a word processor in the morning, simulate a weather system in the afternoon, and render a movie at night. All of these are just sequences of read–write–move–state instructions flowing through a universal substrate.

This was the first leap in universality: the compression of infinite tasks into four primitives, plus a universal tape to carry them. The consequences were not just technical, but philosophical. It gave humanity a new definition: “computable” now meant anything that could be described in these four actions.

(my son’s abacus, a mapping machine for addition and subtraction.)

The Second Leap: Language Universality

If Turing unified the world of computation, the next great unification came in the world of language. For decades, natural language processing (NLP) was a patchwork of specialized tools. You built one algorithm for machine translation, another for sentiment analysis, another for question answering, and still others for summarization, dialogue, or topic modeling. Each task had its own architecture, its own training set, its own evaluation metrics.

The result was a kind of digital Tower of Babel. Every system spoke its own dialect. Progress in one corner of NLP rarely transferred to another. A machine that could translate French to English was useless for detecting sarcasm, and a sentiment classifier had nothing to say about document retrieval. It was the same pre-1936 problem all over again: many “machines,” each confined to a narrow function.

The breakthrough came with large language models. Instead of building a bespoke solution for every task, researchers realized that all language operations could be reduced to a single primitive:

• Predict the next token.

That’s it. The model doesn’t need a different engine for translation, summarization, or reasoning. It simply keeps guessing the most likely next unit of text—word, subword, or character—based on everything it has seen so far. Out of this humble mechanic, the full spectrum of linguistic intelligence emerges.

Once you have a system trained to predict tokens across billions of examples, prompts become the new “programs.” Write “Translate this to German” and the model predicts tokens that correspond to German text. Ask “Summarize this article” and the model predicts a condensed version. Query “What is 37 × 41?” and the model predicts the correct arithmetic sequence. Just as the Universal Turing Machine encoded the logic of any specialized calculator onto its tape, the LLM encodes the logic of any specialized language task into the probability of the next token.

The impact has been staggering. What was once a fragmented set of siloed models has collapsed into a single universal substrate. One model, infinite tasks. Translation, reasoning, summarization, dialogue—these are no longer separate engines but different expressions of the same primitive.

This was the second leap in universality. If Turing defined “what is computable,” then LLMs are beginning to define “what is language-modelable.” The boundary of intelligence itself is being redrawn, not as a collection of tasks, but as a single act of prediction unfolding on an infinite tape of tokens.

The Coming Leap: Civilization Universality

If computation was the first leap, and language the second, then what comes next? Look around: society today is a patchwork of silos. Finance, healthcare, education, logistics, governance—each has its own standards, its own data formats, its own institutions. Even inside a single organization, the fragmentation is obvious: the CRM doesn’t talk to the ERP, the accounting software doesn’t align with the HR platform, and government records are locked in formats from half a century ago. We’ve learned to live with these disconnects as if they were natural, but they are symptoms of a deeper problem: we lack a universal substrate for civilization itself.

What might such a substrate look like? I believe it begins with a cycle of four primitives:

1. Consensus — deciding what matters.

2. Protocol — encoding that decision into rules.

3. Structure — crystallizing those rules into roles, institutions, or processes.

4. Narrative — weaving a story that legitimizes and sustains the structure.

This cycle repeats endlessly. Constitutions are written, companies are founded, movements are born. Each time, the pattern is the same: consensus → protocol → structure → narrative. Yet today this cycle is still slow, brittle, and mostly manual. Every institution reinvents the wheel, every industry defines its own silo.

The coming leap would be to treat this cycle not as a sociological curiosity but as a universal primitive set, the way read/write/move/state defined computation, or token prediction defined language. Imagine a Social Turing Machine, where consensus can be captured digitally, protocols encoded transparently, structures instantiated as executable processes, and narratives reinforced through shared symbolic layers. In such a world, rules and institutions themselves could become executable code—not just written in paper constitutions or buried in bureaucracy, but running on a shared substrate of natural language, APIs, and vector spaces.

This is, of course, speculation. But then again, so was Turing’s imitation machine in 1936, so too were the first neural probabilistic language models in the early 2000s. What matters is the direction of compression: infinite diversity of social tasks, reduced to a finite cycle of primitives. From there, recombination does the rest.

If the first leap defined what is computable, and the second what is language-modelable, then the third may define what is governable and sharable at the scale of civilization.

Why Universality Defines Breakthroughs

When people talk about breakthroughs, they often imagine more power—faster processors, bigger datasets, stronger engines. But history shows that raw scale is not what truly changes the game. What defines a breakthrough is not the ability to do more of the same, but the ability to do anything new with less. That is the essence of universality.

Universality is about compression. A messy, fragmented field suddenly collapses into a handful of primitives and a universal substrate that can recombine them. The abacus, the adding machine, and the polynomial calculator were all swept into a single framework of read, write, move, and state. Translation, summarization, and reasoning dissolved into the single act of predicting the next token. In each case, the endless complexity of tasks was compressed into a smaller and smaller toolkit.

But compression alone is not enough. The real magic comes from recombination. Once you’ve identified the minimal building blocks, you can shuffle and stack them into countless new configurations. With just four DNA bases, life built whales and willows. With just two electric charges, engineers built circuits, radios, and supercomputers. With four computational primitives, programmers built every software system we know today. Universality means that a finite toolbox can be endlessly repurposed.

That is why universality defines breakthroughs. It does not merely speed up existing processes—it rewrites the limits of what is possible. The arrival of software meant we no longer needed a new machine for each task; one machine could simulate all of them. The arrival of LLMs means we no longer need a separate model for each linguistic task; one model can fluidly perform all of them. And if a Social Turing Machine emerges, we may no longer need separate institutions for each domain; one substrate could coordinate many forms of governance, commerce, and collective action.

Every leap in history follows this pattern: find the smallest set of building blocks, discover the universal substrate, and unleash infinite recombination. Breakthroughs are not about adding horsepower—they are about discovering universality.

The Road Ahead

When we zoom out, the pattern is unmistakable. Each era-defining breakthrough—whether in science, engineering, or society—has come from a moment of universality. We discover a set of minimal primitives, we build a universal substrate to carry them, and suddenly infinite possibilities open up.

• In computation, it was Turing’s four actions and a universal tape.

• In language, it became token prediction on a universal corpus.

• And in civilization, we may soon see consensus, protocol, structure, and narrative woven into a new universal cycle.

Universality doesn’t just make things faster. It changes the horizon of what is possible. It tells us that instead of multiplying silos—more machines, more models, more institutions—we can compress them into a common base and let recombination do the rest. That is how breakthroughs scale.

This is why universality matters. It is not a curiosity of computer science, nor a quirk of AI research. It is the hidden law of progress: breakthroughs happen when we collapse chaos into clarity, when we discover the few rules that can simulate everything else.

But here’s the real question: is this recklessness something to eliminate, or is it the raw fuel of a new software ecosystem? What looks like disorder may actually be the true starting point of the next paradigm in software engineering. Because the way we code doesn’t just shape our programs — it shapes how we work, how we learn, and ultimately how our entire ecosystem evolves.

Vibe Coding = Entropy Source, Not a Mistake

中文：Vibe Coding 不是错误，而是熵源

When we see high schoolers or beginners writing code without tests, without documentation, and without linters, the instinct is to dismiss it as sloppy or even dangerous. Yet this view is far too narrow, because what looks like chaos is actually entropy — the raw fuel of evolution.

Vibe coding produces uncertainty: most of its output will not surpass what an experienced engineer can write by hand, but occasionally it yields results that are unexpectedly elegant, efficient, or creative — far beyond what careful planning would have produced. In this sense, vibe coding does not create polished products, it generates mutations. And as in biology, mutations are not failures but the very material on which selection acts.

Entropy in code manifests as volume (many snippets, variants, and prototypes), diversity (different styles and redundant approaches), and uncertainty (some correct, some broken, many in-between). The key is not to suppress this entropy but to harness it, which shifts the real question from “how do we stop vibe coding?” to “how do we design systems that can channel it productively?” This is where AI and modern tools matter most: not as mere assistants cleaning up after human mistakes, but as entropy filters — filtering obvious errors, correcting messy code into reusable blocks, and selecting fragments that deserve to persist.

Under this lens, vibe coding is not a liability but a source of variation, energy, and possibility, provided the ecosystem has the right filters and governance. The future of software engineering will embrace vibe coding: its output is not a mistake, but an entropy source — to be filtered, corrected, and transformed into enduring structure.

Old Risk-Only View vs. New Entropy View

• Old paradigm: vibe code = sloppy mistakes, must be policed.

• New paradigm: vibe code = entropy source, like genetic mutations — most fail, but they fuel evolution.

Why Manual Policing Won’t Scale

At first glance, the obvious response to messy vibe code is simple: have more experienced developers review it. But this “manual policing” approach collapses the moment you think at scale. The volume of code produced by AI-assisted beginners already exceeds what any team of human reviewers can keep up with — and that gap will only widen as models become faster and more accessible. What was once a trickle of half-baked snippets has become a flood, and no number of code review checklists can dam it up.

Even if we tried, the cost is unbearable. Senior engineers would spend their time acting as “human linters,” correcting indentation, fixing type mismatches, and patching obvious logic gaps. That is the worst possible use of scarce talent: instead of designing architectures or protocols, they would be stuck chasing down the noise generated by the long tail of vibe coding. The result is wasted expertise, slower ecosystems, and inevitable bottlenecks.

In short, manual policing turns into a scaling trap: the more code that gets produced, the more people you need to check it, but the less value those people create. If the ecosystem depends on human review alone, it will stagnate under its own weight. The only viable path forward is systemic filtering — protocols, automated validators, AI refactoring tools, and governance mechanisms that can handle the flood at machine speed.

Conclusion

The future of software engineering will embrace vibe coding: its output is not a mistake, but an entropy source — to be filtered, corrected, and transformed into enduring structure. The real challenge is building the ecosystem that can handle this entropy. That means creating tools and protocols that act as systemic filters.

to be continued….