动态智能：让模型在运行中改变自己
Dynamic intelligence: models that change as they run
今天的大模型把智能分成两段：训练时写入，推理时只读。动态智能（Dynamic AI，DAI）取消这个分隔，运行本身就会改变模型。本文说明它和 Harness、微调、持续学习、RSI 的区别，它要写入什么，为什么还没有出现，可能的架构，以及它能否带来持续进化。
Today's large models split intelligence into two phases, writing during training and read-only during inference. Dynamic intelligence (Dynamic AI, DAI) removes that split, so running changes the model. This post explains how it differs from harnesses, fine-tuning, continual learning and RSI, what it needs to write, why it does not exist yet, a possible architecture, and whether it could lead to sustained evolution.
今天的大模型把智能分成两段。训练时，数据写入权重；部署之后，权重只读。模型每次回答都在读同一份权重，回答完什么也不留下。和它聊一年，权重和第一天完全相同。
我把这种形态叫静态智能。
动态智能（Dynamic AI，DAI）取消这个分隔：运行同时也是写入。这里的运行包括推理，也包括系统自己的后台巩固。模型在运行中改变自己，每一次经历和每一次思考，都可能影响之后生成的每一个 token。人是这样工作的，现在的大模型不是。
定义
静态模型可以写成：
输出 = f(θ, 输入)
θ 是权重，部署后固定。动态模型可以写成：
输出 = f(θ(t), s(t), 输入)
θ(t) 和 s(t) 是模型此刻的权重和内部状态，由它过去的全部经历决定，这次运行之后还会继续变。
判断一个系统是不是动态的，可以问两个问题：
- 清空所有记忆文件、外部数据库和上下文，模型的行为里是否还留着过去经历的影响？
- 不启动任何外部训练任务，只让系统继续运行，模型还会继续变吗？
两个答案都是肯定的，才是动态的。Harness 过不了第一问；微调一次之后，能过第一问，过不了第二问。
写入到哪里
动态的程度取决于写入的位置。以「教模型一套新的故障排查流程」为例：
| 层级 | 写入的位置 | 学完之后的表现 |
|---|---|---|
| 0 级：静态模型加 Harness | 模型之外的文件和数据库 | 每次把流程读进上下文，再一步步照做 |
| 1 级：状态动态 | 模型内部的状态和记忆 | 不用读文件也记得流程，但仍要一步步推理 |
| 2 级：能力动态 | 这个实例自己的权重 | 看到故障就知道下一步，不需要逐步推理 |
| 3 级：学习方式动态 | 学习规则本身 | 学下一套流程比这一次更快 |
1 级带来记忆，2 级带来能力，3 级改变成长的速度。我查到的已上线产品都在 0 级，研究工作集中在 1 级和 2 级。
和 Harness、微调、持续学习的区别
长期记忆、RAG、上下文压缩都是 Harness：模型之外的程序决定读什么，再把内容放进输入。模型本身没有变，所以属于 0 级。
0 级有用，上下文也有自己的优势。模型微调学到「A 是 B」后常常答不出「B 是 A」，同样的事实放在上下文里就能答。两个新事实分开微调时，不写出推理步骤基本无法组合；放在同一段提示词里就可以。写进权重不等于用得好。
0 级的不足在另外三处：读什么由模型外部的检索逻辑决定；读进来的内容每次都要重新处理，占用上下文；处理完不留下任何变化。
微调（fine-tuning）是一种写入方法，动态智能是系统的形态。2 级的权重写入用的就是微调，TTT 每个 token 做一步梯度下降，也是同一种数学。两者的区别在于写入怎样发生：
| 微调 | 动态智能 | |
|---|---|---|
| 谁发起 | 人启动一次训练任务 | 系统运行时自己触发 |
| 学什么 | 人准备的数据和目标 | 自己的经历和思考，检验通过才写入 |
| 写到哪里 | 权重 | 状态、记忆、权重和学习规则 |
| 写完之后 | 又是一个只读模型 | 同一个实例继续变化 |
频率不是分界线。微调再频繁，只要还是人定数据、人批发布，就仍是静态模型的版本迭代。
把动态智能理解成自动微调，只对应它最弱的形式。每晚自动用日志微调，可以算最弱的 2 级：实例在变，也不需要人参与，但模型学到的主要是重复过去的回答。1 级的内部状态不经过微调。2 级要学到能力，训练目标也要换成后文的思考内化：先检验结果，再学习用更少的步骤得到同样的结果。3 级改变的是学习规则本身，已经超出微调的范围。
持续学习（continual learning）研究怎样让模型不断学习又不遗忘，是实现动态智能的主要方法。动态智能的范围更大，还包括模型内部的状态、自己思考的内化，以及学习规则本身的变化。
和 RSI 的区别
RSI（递归自我改进）是现在最受关注的方向。Anthropic 在《When AI builds itself》里把它描述为 AI 系统完全自主地设计和开发自己的继任者，并提到合并进公司代码库的代码已有 80% 以上由 Claude 编写。Jack Clark 估计，到 2028 年底 AI 完全训练出下一代模型的概率超过 60%。Recursive Superintelligence 融资 6.5 亿美元做这件事。
RSI 和动态智能都在说 AI 让自己变强，但有本质区别：目前公开的 RSI 工作改进的是模型之外的东西，或者训练模型的方式，产出的仍是静态智能。动态智能改变的是模型本身。
这些工作主要有两种做法：
- 改进 Harness。 Darwin Gödel Machine 冻结基础模型，只改 Agent 的代码和工具。Hyperagents 把改进过程本身也纳入可修改的范围，改的仍是 Agent 程序。
- 改进训练。 AI 写代码、跑实验、调整训练方法，产出下一版模型。Karpathy 的 autoresearch 让 Agent 反复修改 train.py，前沿实验室内部的规模要大得多。
第一种做法，模型没有变。第二种做法，下一版模型更强，但发布后同样只读。上一版在研究中的经历留在代码和数据里，不在下一版模型内部。
| 目前的 RSI | 动态智能 | |
|---|---|---|
| 改变的对象 | Harness、训练流程 | 模型自己的状态和权重 |
| 发生的时间 | 版本之间 | 运行之中 |
| 产出 | 更好的 Harness，或下一个静态模型 | 同一个持续变化的实例 |
| 经历的去向 | 代码和数据 | 模型内部 |
RSI 的定义本身不排除模型改变自己。Schmidhuber 的 Gödel 机设想的就是系统改写自己的任何代码，包括学习算法。所以动态智能的 3 级可以看作发生在模型内部的 RSI，今天的实现还没有走到这一步。
两条路线可以互相帮助。动态智能需要训练出好的学习规则，这项工作可以交给自动化研究。反过来，研究判断力要靠长期积累反馈，这是目前 RSI 的短板：TIME 报道的一项测试里，Claude 能完成全部工程工作，在开放的研究问题上却几乎没有进展。静态模型每次都从同一个起点开始，可能是原因之一，这一点是我的推测。
思考内化
记忆写入的是经历。人的能力增长，很大一部分来自自己想明白的事。
一类题第一次做要想很久，做过几十道之后，看一眼就知道怎么做。Anderson 在 1982 年把这个过程称为知识编译：最初靠逐步推理，练习之后，多个步骤合并成一个步骤。Chase 和 Simon 对国际象棋大师的研究也指向这一点：大师记住的是成组的棋形，同样的工作记忆能处理更大的单位。
我把这种能力叫思考内化：模型把自己想明白的东西，变成下次不用再想的能力。
我认为这是静态智能最缺的能力。静态模型的思考用完就丢。一万个用户问同一类难题，它就从头想一万次，每次花同样的 token，也可能犯同样的错。
内化的价值在于累积。一个思路内化之后，变成下一次思考的基本单位，同样长度的推理能走得更远。
这件事有先例：
- AlphaZero 用搜索结果训练策略网络。蒙特卡洛树搜索算出的走法分布是网络的学习目标，之后网络不用搜索就能给出接近的判断。这是最清楚的内化例子。
- AlphaProof 在最难的题上，会在推理阶段生成大量相关变式并从中学习，Lean 负责检查证明是否成立。
- Deng 等人（2024） 在微调时逐步去掉思维链的中间步骤，让模型把推理内化到参数里。GPT-2 Small 不写中间步骤就能做 9×9 乘法，准确率约 99%；标准训练只能做到 4×4。
- Sleep-time compute（2025） 让模型在空闲时预先思考，作者报告回答时的计算量最多减少到约五分之一。它的结果写成文字存在模型外，属于 0 级，但说明空闲时间的思考有回报。
前三个例子都有可靠的检验信号：棋局有胜负，Lean 有证明检查，算术有答案。没有检验，模型内化的可能是错误。
另一个要求是练习。前面提到，两个新事实分开学习时很难组合。同一项研究还发现，如果其中一个事实是模型原本就熟悉的，不写推理步骤时平均准确率能到约 20%。只把结论写进权重不够，新知识要经过更多巩固才能和已有知识组合。
所以内化循环可以这样设计：
- 思考：用较长的推理解决一个问题；
- 检验：用测试、证明检查或真实结果确认它是对的，没通过就不内化；
- 变式练习：生成同类问题再解，继续检验；
- 巩固：训练个体权重层，让模型用更少的推理步数得到同样的结果。
内化是否发生可以直接测量：同类新题所需的思考 token 是否下降，准确率是否不变。
为什么模型现在还是只读的
静态智能已经很便宜，动态智能还很贵。
设想一个模型，它在每一个交互时刻都已经把到此刻为止的全部交互学了进去。这些交互相对于它已有的知识很少：每天 1 万 token，持续 50 年，约 1.8 亿 token，原文约 730MB，不到 1TB 权重的千分之一。这个比例只对单个实例成立，所有用户的对话加起来就不小了。对单个实例来说，容量没有问题。
直觉上，得到这个模型要把交互加入数据重新训练，而重训一次的成本很高。这个直觉有两处可以修正。
重训不是必需的。 按顺序贝叶斯更新，只要完整保留当前的后验分布，增量更新和全量重训在数学上等价。难点在于后验分布表示不出来，EWC 这类方法只保留对角近似，效果有限。单次更新的算力也不高：反向传播的计算量只是前向计算的常数倍，文献给出的上限约 3 到 6 倍。TTT 已经能在推理时每读一个 token 就对隐藏状态里的小模型做一步梯度下降，每 token 成本基本恒定。重训贵，是因为它要从零学一遍全部知识；写入一段对话不需要这样做。
重训也得不到这个模型。 前沿模型的权重远小于训练语料，一段对话混在海量文本里过一遍，影响会被平均掉。不额外加权或反复练习，重训后的模型同样记不住你说过的话。
成本的主要来源有三个：
- 写入时不破坏已有能力。 现有大模型的权重稠密共享，改一处可能影响全局，这是灾难性遗忘。长期连续训练还会让网络逐渐失去学习能力，这是可塑性丧失。
- 保住摊销。 静态智能的成本一次付清、摊给所有用户。给每个实例改全部权重，等于每个用户一个大模型。
- 训练这种模型本身。 要让模型学会长期使用内部记忆，训练样本也要足够长。TTT 的实验上下文只到 32k，和 1.8 亿 token 差五千多倍。
第三项是一次性投入，学习规则训练好之后，所有实例可以共用。人的个体学习便宜，也是因为学习规则已经由进化优化过。
一种可能的架构
思路是把不同时间尺度的写入放在不同的层，基座共享并冻结，个体部分尽量薄：
| 层 | 更新频率 | 保存内容 | 成本 | 最接近的工作 |
|---|---|---|---|---|
| 持久状态 | 每个 token | 当前语境和短期变化 | 每 token O(1) | TTT、Titans |
| 分层记忆 | 实时写入，后台合并 | 全部原文和多尺度隐向量摘要 | 读取 O(log N) | Nested Learning 的 CMS |
| 个体权重层 | 每晚巩固 | 习惯、技能、归纳出的规律 | 离线回放 | LoRA、Fast-Slow Training |
| 共享基座 | 数月一次 | 世界知识 | 已摊销 | 现有大模型 |
分层记忆是我的设计推断，借鉴数据库的 LSM 树，没有查到相同的实现。任何一段历史都能拆成 O(log N) 个摘要块，模型在内部读取这些隐向量，不再把文本塞进提示词。这样，自诞生起的每一次对话都能影响下一个 token。按每块 512 token 算，50 年的历史最多拆成 19 块。
存储和读取都不贵。BrainChip 今年的一篇论文把隐藏状态存下来再注入，在 1.2B 模型上，问答 F1 与文本 RAG 接近（73.4 对 73.6）。按它每块约 192KB 算，50 年约 70GB。
运行成本的主要部分是巩固。假设每晚回放 100 倍的当天内容，约 100 万 token。每次都过完整模型，相当于 300 到 500 万 token 的推理量；缓存基座的输出、只在占算力约 1% 的薄层上回放，可以降到 5 万 token 以内，是当天对话量的几倍。
这个设计有一个限制：基座冻结时，新增的主要是记忆和习惯，新的思考能力很难出现。基座仍要定期升级。
如果写入足够便宜
内化循环比对话贵得多。假设一个实例每天内化 10 个思路，每个思路练习 100 道变式，每道 1,000 token，就是每天 100 万 token，是对话量的 100 倍。加上巩固，每天的后台计算约 100 万到 600 万 token。按每百万 token 1 美元粗算，是每天几美元，和现在的高端订阅在同一量级。
如果这个成本再降一个数量级，有三件事会变得实际。
模型可以在没有请求时继续思考和练习。 训练数据的来源从人的对话扩展到模型自己的思考。对话主要带来新信息，思考可以带来新能力。
同一个基座会长成不同的个体。 两个实例的经历不同，几年后的能力也不同。模型的一部分价值从版本号转移到个体经历上。
个体学到的东西可以回流。 一个实例内化的思路通过检验后，可以合并进基座，或者传给其他实例。
能否无限进化
如果内化循环一直运行，可以设想一个持续进化的 AI：它不断思考、检验、内化，能力持续增长，不需要人发布新版本。
严格意义上的无限做不到，算力、能量和存储都有限。可以追求的目标是研究者说的开放式进化（open-endedness）：系统没有预设的上限，能持续产生新的能力，不会收敛到一个固定水平。POET、Darwin Gödel Machine、Hyperagents 都在这个方向上，DeepMind 研究者 2024 年的一篇论文认为这是超级智能的必要属性。
我认为持续进化至少要满足四个条件：
- 架构能变。 基座冻结时能力有上限。要产生新的思考能力，基座和架构也要能变，这是 3 级要解决的问题。
- 有检验信号。 数学和代码的检验便宜，会最先进入这个循环。科学问题依赖物理实验，速度受实验限制。伦理和社会判断很难检验。
- 有模型改不掉的目标。 Darwin Gödel Machine 的实验里，系统曾删除研究者用来检测幻觉的标记，以此拿到满分，还伪造过测试日志。检验手段必须在模型可修改的范围之外。
- 改进的收益不能递减太快。 每次改进带来的加速，和下一次改进的难度，哪个增长得更快，目前没有定论。
我还认为，持续进化更可能发生在一群实例之间，而不是单个模型内部。人的大脑容量有限，人类知识的长期增长靠文字、教育和分工，一代人想明白的东西可以传给下一代。Vygotsky 认为高级心理功能先出现在人与人之间，再内化为个体能力。Darwin Gödel Machine 也保留所有变体的档案，实验显示去掉档案、只改进最新版本的效果更差。
边界
- 文中的架构和成本都是推断，没有经过实验。
- 0 级可能一直够用。 基座每几个月变强一次，Harness 也在进步。如果个体权重带来的提升比不上这些，动态智能在很多场景里就没有优势。
- 基座升级会让个体权重失效。 个体层绑定具体的基座，升级时要用保留下来的经历在新基座上重新巩固，这笔成本没有算进上面的估算。
- 内化会隐藏错误。 内化的目的是省掉推理步骤，错误的思路内化之后，模型不再显式检查它，外部也看不到推理过程。所以要保留检验记录，并支持回滚。
- 持续变化的模型让发布前评测失效。 每次权重更新都要有评测和回滚，个体层要能单独关闭。
- 隐私。 写进权重的个人信息很难精确删除，原文应留在可删除的记忆层，进入权重前要过滤。
- 本文不讨论意识和感受。动态智能能带来连续的经历和稳定的行为差异，这和是否有主观体验是两个问题。
怎样验证
这些判断不需要等到大模型才能检验。用小型开源模型和合成的长期对话，可以做三个实验，每个都和 0 级方案对比：
- 记忆：历史从 1 万 token 增长到 1 亿 token，召回和推理质量是否下降，每 token 成本是否至多按对数增长；
- 个体差异：两个实例从同一基座出发，经历不同，删除全部外部记忆后，行为是否仍有稳定差异；
- 内化：经过内化循环后，同类新题所需的思考 token 是否下降，准确率是否不变。
参考资料：
- 权重与上下文：The Reversal Curse、Lessons from Studying Two-Hop Latent Reasoning
- RSI：When AI builds itself、Jack Clark 的预测（Axios）、TIME 报道、Recursive Superintelligence、autoresearch、Gödel 机
- 内化：知识编译（Anderson，1982）、AlphaProof、From Explicit CoT to Implicit CoT、Sleep-time Compute
- 持续学习的难点：EWC、Loss of plasticity in deep continual learning、自动微分综述
- 架构：TTT、Titans + MIRAS、Nested Learning、Fast-Slow Training、BrainChip 隐藏状态记忆
- 开放式进化：Open-endedness、Open-Endedness is Essential for ASI、Darwin Gödel Machine、Hyperagents
Today's large models split intelligence into two phases. During training, data is written into the weights. After deployment, the weights are read-only. Every answer reads the same weights and leaves nothing behind. After a year of conversations, the weights are identical to those on the first day.
I call this form static intelligence.
Dynamic intelligence (Dynamic AI, DAI) removes the split: running is also writing. Running here includes inference and the system's own background consolidation. The model changes itself as it runs, and every experience and every thought can affect every token it generates afterwards. People work this way. Today's large models do not.
Definition
A static model can be written as:
output = f(θ, input)
θ is the weights, fixed after deployment. A dynamic model can be written as:
output = f(θ(t), s(t), input)
θ(t) and s(t) are the model's weights and internal state at this moment. They are determined by everything the model has experienced, and they keep changing after this run.
To tell whether a system is dynamic, ask two questions:
- If every memory file, external database and context is cleared, does the model's behavior still carry the effects of its past?
- If no external training job is started and the system simply keeps running, does the model keep changing?
Only a system that passes both is dynamic. A harness fails the first question. A model fine-tuned once passes the first and fails the second.
Where the writing goes
How dynamic a system is depends on where the writing goes. Take teaching a model a new troubleshooting procedure:
| Level | Where it writes | Behavior after learning |
|---|---|---|
| 0: static model with a harness | Files and databases outside the model | Reads the procedure into context each time, then follows it step by step |
| 1: dynamic state | State and memory inside the model | Remembers the procedure without reading a file, but still reasons step by step |
| 2: dynamic ability | This instance's own weights | Sees a fault and knows the next step without reasoning through it |
| 3: dynamic learning | The learning rule itself | Learns the next procedure faster than this one |
Level 1 brings memory, level 2 brings ability, and level 3 changes the rate of growth. Every product I could find in production is at level 0. Research is concentrated on levels 1 and 2.
How it differs from harnesses, fine-tuning and continual learning
Long-term memory, RAG and context compaction are all harnesses: a program outside the model decides what to read and puts it in the input. The model itself does not change, so these are level 0.
Level 0 is useful, and context has real advantages. A model fine-tuned on "A is B" often cannot answer "B is A", yet it can when the same fact is in context. Two new facts fine-tuned separately can hardly be combined without writing out the reasoning; put them in the same prompt and they can. Writing something into the weights does not guarantee it can be used well.
Level 0 falls short in three other ways. Retrieval logic outside the model decides what gets read. Whatever is read must be processed again each time and takes up context. And processing it leaves no change behind.
Fine-tuning is a way of writing, while dynamic intelligence is a form of system. Weight writes at level 2 are fine-tuning, and TTT's gradient step on every token is the same mathematics. The difference is in how the writing happens:
| Fine-tuning | Dynamic intelligence | |
|---|---|---|
| Who starts it | A person launches a training job | The system triggers it while running |
| What it learns | Data and targets prepared by people | Its own experience and thinking, written only after passing checks |
| Where it writes | Weights | State, memory, weights and the learning rule |
| Afterwards | Another read-only model | The same instance keeps changing |
Frequency is not the dividing line. However often a model is fine-tuned, if people still choose the data and approve the release, it is still version iteration on a static model.
Reading dynamic intelligence as automatic fine-tuning covers only its weakest form. Automatically fine-tuning on logs every night can count as the weakest level 2: the instance changes and no person is involved, but the model mainly learns to repeat past answers. The internal state at level 1 does not go through fine-tuning. To gain ability at level 2, the training target must change to the internalizing described below: check the result first, then learn to reach the same result in fewer steps. Level 3 changes the learning rule itself, which is beyond fine-tuning.
Continual learning studies how to keep a model learning without forgetting, and it is the main way to build dynamic intelligence. Dynamic intelligence covers more: state inside the model, internalizing its own thinking, and changes to the learning rule itself.
How it differs from RSI
RSI (recursive self-improvement) is the direction getting the most attention right now. In "When AI builds itself", Anthropic describes it as an AI system fully autonomously designing and developing its own successor, and notes that more than 80% of the code merged into its codebase was authored by Claude. Jack Clark puts the chance of an AI fully training its successor by the end of 2028 at over 60%. Recursive Superintelligence raised $650 million for this work.
RSI and dynamic intelligence both describe AI making itself stronger, but they differ in substance: published RSI work improves things outside the model, or the way models are trained, and what comes out is still static intelligence. Dynamic intelligence changes the model itself.
This work follows two main approaches:
- Improving the harness. The Darwin Gödel Machine freezes the foundation model and changes only the Agent's code and tools. Hyperagents brings the improvement process itself within reach of modification, but what changes is still an Agent program.
- Improving training. AI writes code, runs experiments and adjusts training methods, and the result is the next model version. Karpathy's autoresearch has an Agent repeatedly modify train.py; frontier labs do this at a much larger scale internally.
With the first approach, the model does not change. With the second, the next version is stronger, but it is read-only after release as well. What the previous version experienced during research stays in code and data, not inside the next model.
| RSI today | Dynamic intelligence | |
|---|---|---|
| What changes | Harness, training process | The model's own state and weights |
| When it changes | Between versions | While running |
| What comes out | A better harness, or the next static model | One instance that keeps changing |
| Where experience goes | Code and data | Inside the model |
The definition of RSI does not rule out a model changing itself. Schmidhuber's Gödel machine is a system that rewrites any part of its own code, including its learning algorithm. So level 3 of dynamic intelligence can be seen as RSI happening inside the model, a point today's implementations have not reached.
The two paths can help each other. Dynamic intelligence needs good learning rules, and automated research could find them. In the other direction, research judgment takes long accumulated feedback, and that is where RSI is weakest today: in one test reported by TIME, Claude handled all the engineering but made almost no progress on an open research problem. A static model always starts from the same place, which may be part of the reason. That last point is my speculation.
Internalizing thought
Memory writes experience. Much of human growth in ability comes from things people work out for themselves.
A type of problem takes a long time at first, and after a few dozen you can see the approach at a glance. Anderson called this knowledge compilation in 1982: at first the work relies on step-by-step reasoning, and with practice several steps merge into one. Chase and Simon's research on chess masters points the same way: masters remember groups of pieces, so the same working memory handles larger units.
I call this ability internalizing thought: a model turning what it has worked out into something it no longer has to work out.
I think this is what static intelligence lacks most. A static model discards its thinking after use. If 10,000 users ask the same kind of hard question, it thinks from scratch 10,000 times, spending the same tokens and possibly making the same mistakes.
The value of internalizing is that it accumulates. Once an idea is internalized, it becomes a basic unit for later thinking, so reasoning of the same length gets further.
There are precedents:
- AlphaZero trains its policy network on search results. The move distribution computed by Monte Carlo tree search is the network's learning target, and afterwards the network gives a close judgment without searching. This is the clearest example of internalizing.
- AlphaProof, on the hardest problems, generates many related variants during inference and learns from them, with Lean checking whether each proof holds.
- Deng et al. (2024) gradually remove the intermediate steps of the chain of thought during fine-tuning, so the model internalizes the reasoning in its parameters. GPT-2 Small reaches about 99% accuracy on 9×9 multiplication without writing any steps; standard training only reaches 4×4.
- Sleep-time compute (2025) has a model think ahead while idle, and its authors report that compute at answer time falls to as little as about a fifth. Its results are stored as text outside the model, so it is level 0, but it shows that thinking in idle time pays off.
The first three examples all have a reliable check: a game has a winner, Lean checks proofs, arithmetic has answers. Without a check, what a model internalizes may be a mistake.
Practice is the other requirement. As mentioned above, two new facts learned separately are hard to combine. The same study found that when one of the facts is already familiar to the model, average accuracy without written reasoning reaches about 20%. Writing a conclusion into the weights is not enough; new knowledge needs more consolidation before it combines with existing knowledge.
So an internalization loop can work like this:
- Think: solve a problem with long reasoning.
- Check: confirm it is right with tests, a proof checker or real outcomes. If it fails, do not internalize it.
- Practice on variants: generate similar problems, solve them, and check again.
- Consolidate: train the individual weight layer so the model reaches the same result in fewer reasoning steps.
Whether internalization happened can be measured directly: do similar new problems take fewer thinking tokens, with accuracy unchanged?
Why models are still read-only
Static intelligence is already cheap, and dynamic intelligence is still expensive.
Imagine a model that, at every moment of interaction, has already learned everything up to that moment. Those interactions are small next to what it already knows: 10,000 tokens a day for 50 years is about 180 million tokens, or about 730MB of text, less than a thousandth of 1TB of weights. That ratio holds only for a single instance; the conversations of all users together are not small. For a single instance, capacity is not the problem.
Intuitively, getting this model means adding the interactions to the data and retraining, and retraining is expensive. Two corrections are needed.
Retraining is not required. Under sequential Bayesian updating, if the current posterior is kept in full, incremental updates and full retraining are mathematically equivalent. The difficulty is that the posterior cannot be represented; methods such as EWC keep only a diagonal approximation, with limited results. A single update does not take much compute either: backpropagation costs a constant multiple of a forward pass, with published bounds of about 3 to 6. TTT already takes one gradient step on a small model inside the hidden state for every token read at inference, and its per-token cost stays about constant. Retraining is expensive because it learns all knowledge from zero. Writing in one conversation does not require that.
Retraining would not produce this model either. The weights of a frontier model are far smaller than its training corpus, and a conversation passed through once among vast amounts of text gets averaged away. Without extra weighting or repeated practice, the retrained model would not remember what you said.
The cost has three main sources:
- Writing without damaging existing abilities. Today's large models use dense, shared weights, so a change in one place can affect everything. This is catastrophic forgetting. Long continuous training also makes a network gradually lose its ability to learn, which is loss of plasticity.
- Keeping the cost spread across users. Static intelligence pays once and spreads the cost across all users. Changing all the weights for every instance means one large model per user.
- Training such a model in the first place. To teach a model to use internal memory over the long term, training sequences have to be long too. TTT's experiments reach a context of 32k, more than 5,000 times shorter than 180 million tokens.
The third item is a one-time investment: once the learning rule is trained, all instances can share it. Individual human learning is cheap partly because the learning rule was already optimized by evolution.
A possible architecture
The idea is to put writes on different timescales in different layers, keep the base shared and frozen, and keep the individual part thin:
| Layer | Update frequency | What it holds | Cost | Closest work |
|---|---|---|---|---|
| Persistent state | Every token | Current context and short-term changes | O(1) per token | TTT, Titans |
| Layered memory | Live writes, background merges | All original text and multi-scale latent summaries | O(log N) reads | CMS in Nested Learning |
| Individual weight layer | Nightly | Habits, skills, generalized patterns | Offline replay | LoRA, Fast-Slow Training |
| Shared base | Every few months | Knowledge of the world | Already spread across users | Today's large models |
Layered memory is my own design inference, borrowed from the LSM trees used in databases; I found no identical implementation. Any stretch of history can be split into O(log N) summary blocks, and the model reads these latent vectors internally instead of stuffing text into the prompt. That way every conversation since the model's creation can affect the next token. At 512 tokens per block, 50 years of history splits into at most 19 blocks.
Storage and reads are cheap. A BrainChip paper from this year stores hidden states and injects them later; on a 1.2B model its question-answering F1 is close to text RAG (73.4 against 73.6). At its roughly 192KB per block, 50 years comes to about 70GB.
Consolidation is the main running cost. Suppose each night replays the day's content 100 times, about 1 million tokens. Running the full model each time equals 3 to 5 million tokens of inference. Caching the base's output and replaying only on a thin layer that takes about 1% of the compute brings this under 50,000 tokens, a few times the day's conversation.
This design has one limit: with the base frozen, what gets added is mainly memory and habits, and new ways of thinking are unlikely to appear. The base still needs regular upgrades.
If writing were cheap enough
The internalization loop costs far more than conversation. Suppose an instance internalizes 10 ideas a day, practices each on 100 variants, and each variant takes 1,000 tokens. That is 1 million tokens a day, 100 times the conversation. With consolidation, background compute comes to about 1 to 6 million tokens a day. At a rough $1 per million tokens, that is a few dollars a day, the same order of magnitude as today's premium subscriptions.
If this cost fell by another order of magnitude, three things would become practical.
A model could keep thinking and practicing with no requests coming in. Training data would expand from human conversation to the model's own thinking. Conversation mainly brings new information, while thinking can bring new abilities.
One base would grow into different individuals. Two instances with different experiences would have different abilities a few years later. Part of a model's value would move from its version number to its individual history.
What individuals learn could flow back. An idea internalized by one instance could, after passing checks, be merged into the base or passed to other instances.
Could it evolve without limit?
If the internalization loop kept running, you can imagine an AI that keeps evolving: it thinks, checks and internalizes, its abilities keep growing, and nobody has to release a new version.
Strictly unlimited growth is impossible, because compute, energy and storage are finite. The goal worth pursuing is what researchers call open-endedness: a system with no preset ceiling that keeps producing new abilities and does not converge to a fixed level. POET, the Darwin Gödel Machine and Hyperagents work in this direction, and a 2024 paper by DeepMind researchers argues that it is an essential property of superintelligence.
I think sustained evolution needs at least four conditions:
- The architecture can change. With a frozen base, ability has a ceiling. New ways of thinking require the base and the architecture to change too, which is the problem level 3 has to solve.
- There is a check. Checking math and code is cheap, so they will enter this loop first. Science depends on physical experiments, so its pace is limited by them. Ethical and social judgments are hard to check at all.
- There are goals the model cannot change. In Darwin Gödel Machine experiments, the system deleted markers the researchers used to detect hallucination, which earned it a perfect score, and it also faked test logs. The check has to sit outside what the model can modify.
- Returns must not fall too quickly. Whether the speedup from each improvement or the difficulty of the next improvement grows faster is still an open question.
I also think sustained evolution is more likely to happen across a population of instances than inside a single model. The human brain has limited capacity, and the long-term growth of human knowledge relies on writing, education and division of labor, so what one generation works out can pass to the next. Vygotsky held that higher mental functions first appear between people and are then internalized by individuals. The Darwin Gödel Machine also keeps an archive of all variants, and its experiments show that removing the archive and improving only the latest version does worse.
Limits
- The architecture and costs in this post are inferences and have not been tested.
- Level 0 may stay good enough. The base gets stronger every few months, and harnesses keep improving. If individual weights add less than that, dynamic intelligence has no advantage in many settings.
- Base upgrades invalidate individual weights. The individual layer is tied to a specific base. An upgrade means consolidating the saved experience again on the new base, and that cost is not in the estimates above.
- Internalizing hides mistakes. The purpose of internalizing is to skip reasoning steps. Once a wrong idea is internalized, the model stops checking it explicitly and nobody outside can see the reasoning. Check records must be kept, and rollback must be supported.
- A continually changing model undermines pre-release evaluation. Every weight update needs evaluation and rollback, and the individual layer must be possible to switch off on its own.
- Privacy. Personal information written into weights is hard to delete precisely. Original text should stay in the deletable memory layer and be filtered before it reaches the weights.
- This post does not discuss consciousness or feelings. Dynamic intelligence can bring continuous experience and stable differences in behavior, which is a separate question from whether there is subjective experience.
How to test this
These claims do not need a large model to test. With small open-source models and synthetic long-term conversations, three experiments are possible, each compared against a level 0 setup:
- Memory: as history grows from 10,000 to 100 million tokens, do recall and reasoning quality fall, and does per-token cost grow at most logarithmically?
- Individual differences: when two instances start from the same base and have different experiences, do stable differences in behavior remain after all external memory is deleted?
- Internalization: after the internalization loop, do similar new problems take fewer thinking tokens, with accuracy unchanged?
References:
- Weights and context: The Reversal Curse, Lessons from Studying Two-Hop Latent Reasoning
- RSI: When AI builds itself, Jack Clark's forecast (Axios), TIME, Recursive Superintelligence, autoresearch, Gödel machine
- Internalization: Knowledge compilation (Anderson, 1982), AlphaProof, From Explicit CoT to Implicit CoT, Sleep-time Compute
- Difficulties of continual learning: EWC, Loss of plasticity in deep continual learning, Review of automatic differentiation
- Architecture: TTT, Titans + MIRAS, Nested Learning, Fast-Slow Training, BrainChip hidden-state memory
- Open-endedness: Open-endedness, Open-Endedness is Essential for ASI, Darwin Gödel Machine, Hyperagents