今年 9 月，The Information 报道称 OpenAI 即将发布的 GPT-6 Astra 采用了一种类似 Huginn 的 recurrent depth 架构 (The Information, 2026)。Huginn 是 Geiping 等人在 2025 年初开源的 3.5B 模型，其做法是在生成每个 token 时，让隐藏状态反复穿过中间的几层网络 (Geiping et al., 2025)。报道发出后，OpenAI 首席科学家 Jakub Pachocki 在 X 上直言这是 “confused reporting”，并澄清包括 Astra 在内，OpenAI 目前前沿模型的计算图深度都在 GPT-4 的两倍以内 (Pachocki, 2026)。
此后又传出了更具体的细节。10 月 6 日，X 上有人贴出微软一个公开页面的截图，显示 GPT-6 Sol 与 GPT-6.1 Sol 共享同一套基础模型权重，区别是 GPT-6 Sol 在推理时跑 3 遍，而 GPT-6.1 Sol 只跑 2 遍 (Algorithon, 2026)。随后 The Information 再次跟进，称 OpenAI 甚至有意限制了 Astra 的 loop 次数以保持思维链的可读性，而下一代旗舰模型也延续了 loop 设计 (Palazzolo et al., 2026)。
这些传闻指向的其实是同一种思路：让模型里的一组层被反复执行多次。把 loop 引入 Transformer 并不是新鲜事，早在 2018 年，Universal Transformer 就尝试过在层间共享权重 (Dehghani et al., 2019)；但在大模型随后的规模扩张中，占据主流的始终是“每层各用一份独立参数”的结构。直到 2025 年，Huginn（8000 亿 token）和字节的 Ouro（7.7 万亿 token）(Zhu et al., 2025) 先后把 loop 结构训练到了这样的数据规模，这一设计才重回前沿视野。今年 7 月，BOSS 直聘的 Nanbeige 团队开源了 Nanbeige4.2-3B，整个层栈跑两遍，预训练用了 28 万亿 token (Nanbeige LLM Lab, 2026)。当静态的参数规模与实际计算的深度被解绑之后，模型究竟能换来什么，又要付出什么代价？
What’s a loop
标准的 decoder-only Transformer 是一条单向流水线：模型由 $L$ 个物理层串联而成，每层拥有独立的参数权重，token 的隐藏状态从第 1 层依次流向第 $L$ 层，每层只经过一次。
looped Transformer 改变了这条前向通道的拓扑结构。它把连续的若干层定义为一个块（block）；向量穿过块内的最后一层后，重新折返到该块的第一层，带着上一遍计算出的状态重复通过，一共跑 $R$ 遍，最后才交给后续网络。图 1 展示了这一过程：两侧是折叠的物理结构，左边只有中间的块在 loop，右边整个层栈都在块里；中间则是把块沿遍数展开后的计算图。
从展开图可以看出，块里的层在计算图上出现了多次，但每一遍复用的都是同一套物理权重，变化的只有在层间流动的隐藏向量。记进入块的输入为 $h_0$，第 $r$ 遍的输出为 $h_r$，每一遍都以上一遍的状态作为输入迭代演进：$h_r = \text{Block}(h_{r-1})$。在因果自注意力中，第 $r$ 遍的 token 看到的是前文 token 在第 $r$ 遍的表示。因此展开来看，它的前向计算与一个更深的标准 Transformer 基本一致，主要区别是部分层之间的权重被绑定（weight-tied）了。
根据块外是否保留独立的层，常见的层栈组织形式有两种：
- 三明治结构（sandwich）：如图 1 左边所示，块的前后各保留少量独立的固定层。前面的 prelude 层只跑一遍，负责把输入的 token 映射到块所使用的表示空间；中间的块负责多轮迭代；后面的 coda 层也只跑一遍，接过最终表示后映射到词表概率分布。开头提到的 Huginn 便属于这种设计。
- 全栈 loop（full stack）：去掉首尾的独立层，让模型所有的 Transformer 层统一进入 loop。向量走完最后一层后直接回到第一层，传下去的仍是隐藏向量，不经过 LM head 变成 token，跑完 $R$ 遍才输出。2018 年的 Universal Transformer 与后来的 Ouro 都属于这种做法。
这种结构让物理参数量与实际计算深度解耦了。以图 1 为例，两个模型的显存中都只存了 4 层的参数，但当 $R = 3$ 时，左边每个 token 实际经历的有效计算深度是 $1 + 2 \times 3 + 1 = 8$ 层，右边是 $4 \times 3 = 12$ 层。只要增加 $R$，计算深度就能线性拉长，而常驻显存的权重大小完全不变。这就解释了为什么单看参数量无法判断模型有多深，Pachocki 所指的“计算图深度”，统计的应是展开后的实际有效层数（effective depth）。同样，微软截图中提到 GPT-6 Sol 跑 3 遍，也推不出整体深度扩大了 3 倍：全栈 loop 时是 3 倍，如果它采用了类似 Huginn 的三明治结构，两头的固定层并不会成倍放大，深度就到不了 3 倍。
此外，遍数 $R$ 也不需要在训练后锁死。如果在训练期间对每个 batch 随机采样 $R$，让模型适应不同长度的计算轨迹，那么在推理时，$R$ 就可以变成一个随时可调的旋钮：遇到简单 token 或低延时场景少跑几遍，遇到复杂推理多跑几遍换取更深的计算。微软截图中 GPT-6 Sol 与 GPT-6.1 Sol 共享底座参数、分别跑 3 遍与 2 遍的表述，说的应当就是这个旋钮。
Why loop
如果问一个推理模型：“What is the capital of the state where Miami is located?” 在开启思考模式时，模型会在回答里一步步写出来：先确定 Miami 属于 Florida，再由 Florida 查出首府是 Tallahassee。这种问题在研究中叫 2-hop（两跳）问题，第一跳找到连接两步的中间实体（bridge entity，这里是 Florida），第二跳再由它得到最终答案。
有意思的是，即使把思考模式关掉，让 Qwen3.6-27B 只输出一个词，它依然能一口答出 Tallahassee，中间没有生成任何可见的思考 token。这意味着，如果模型真的在内部走了这两步，整套推导就只能发生在输出这个词的那一次前向计算里。这种不把思考写成文字、在模型隐藏状态里完成的推演，被称为隐式推理（latent reasoning）(Chen et al., 2025)。
Loop 做的事情，就是让隐藏状态在模型里多转几圈，把单次前向的计算路径拉长。要理解反复跑同一个块究竟能换来什么，我们得先看清楚：在普通的 Transformer 里，单次前向到底受制于什么，为什么单靠普通的办法解不开。
Latent reasoning
在单次前向计算中，所有 token 的向量沿着残差流（residual stream）自底向上穿过每一层 (Elhage et al., 2021)。这个过程里有两套结构分工明确：自注意力负责在不同 token 之间横向搬运信息；前馈网络（FFN）则像一张存在参数里的键值表，负责按内容调出模型在预训练时记住的事实 (Geva et al., 2021)。
这种分工带来了严格的先后顺序。每一层自注意力的 query 和 key 都在这一层刚开始时就算好了，所以某一层刚写入残差流的新信息，序列里的其他位置最早也要等到下一层才读得到。回到 Miami 的例子，模型要在内部完成两跳，过程大致是这样的：先由 Miami 所在位置的 FFN 从参数中查出“Miami 属于 Florida”；随后，高一点楼层的注意力把 Florida 这个中间概念搬运到序列末尾；最后，末尾位置更高楼层的 FFN 才能据此查出首府 Tallahassee。
第二跳必须建立在第一跳的产出之上，推理链上的每一步因此只能在网络深度上按顺序依次往后排。第一跳完成得越晚，留给第二跳的层数就越少。更麻烦的是，模型记住的知识分散在不同层的 FFN 里，不会每一层都备份一份。如果第二跳要查的知识（比如“Florida 的首府是 Tallahassee”）恰好存放在较低的楼层，而隐藏状态为了完成第一跳早已穿过了这些层，后面的高层就查不到这条信息了。
这种层级依赖在模型内部可以直接看到。残差流里的向量不能直接读，最原始的 logit lens 把中间层的向量直接扔给模型自己的输出层去读 (nostalgebraist, 2020)，读出来的通常是模型马上要说出口的词；Florida 只是跳板，不会被说出口，很难被读到。Gurnee 等人今年 7 月提出的 Jacobian lens（J-lens）更进了一步 (Gurnee et al., 2026)：它先在大量文本上把后面各层对这一层状态的 Jacobian 取平均，得到一个固定的线性映射，用它把中间层的状态换算到最后一层，看看这一层的内容通常会把输出推向什么词。在 Neuronpedia 为 Qwen3.6-27B 搭的 J-lens 公开演示页 (Neuronpedia, 2026) 上输入这道题，问题后面紧跟的那个位置上，中间各层读出最多的就是从未被说出口的 Florida（图 2）。
<|im_start|>, the first token after the question. The paper reads the token right before the answer, but with thinking off that token is a line break after an empty think block whose middle layers mostly read line breaks, probably a trait of the thinking template. The swap is the demo’s intervention with its default settings: at layers 30 to 50 of every token, including the ones the model generates, it pushes the hidden state away from what the lens reads as ␣Florida and toward ␣Texas, while the input text stays the same. The model then answers Austin, and underlines mark the tokens whose readouts changed, darker where more layers changed. ␣ marks a space and \n a line break. Data from the Neuronpedia J-lens demo.读数只能说明 Florida 出现在了残差流里，要证明它确实是计算的一环，还得动手干预。演示页自带的干预是在第 30 到 50 层把代表 Florida 方向的分量换成 Texas，输入的提问不变，模型的输出就从 Tallahassee 变成了 Austin。Gurnee 等人在 Claude 的三个模型上用 50 道 2-hop 题做了统计，替换中间实体后，答案跟着变过去的比例在 54% 到 70% 之间；没变过去的题里，可能还有一条从问题直通答案的捷径在同时起作用，Lindsey 等人就在 Claude 3.5 Haiku 里见过两条路径并存 (Lindsey et al., 2025)。Gurnee 等人还发现，替换中间实体要在较低的层做才能改变答案，直接替换最终答案则要在更高的层才生效。可见中间概念是先在低层出现，再被更高层的计算拿去用的。
然而在实际中，普通的单次前向经常走不完第二跳。Yang 等人在 LLaMA-2 上用四万多道 2-hop 题分别检验两步有没有发生，统计改动输入或隐藏状态后内部读数朝预期方向变化的比例（随机水平是 50%）。就算模型从 7B 扩到 70B、层数从 32 层加到 80 层，第一跳的比例从约 71% 升到了 78%，第二跳却一直停在 61% 到 65%，几乎没有长进 (Yang et al., 2024)。
Biran 等人深入诊断了答错的题目，发现模型其实两条知识都知道，错就错在第一跳解出 Florida 太晚了 (Biran et al., 2024)。等 Florida 终于出现在残差流里，存放第二条事实的低层早就算完了。研究人员把较晚层的状态拷回同一位置较早的层重新算，原本答错的题目有 32% 到 66% 被救了回来。拷回哪一层是事后挑的，这个实验只能算诊断，但它说明了问题出在哪里。普通的 Transformer 就像一张单程票：计算只能单向往上走，一旦错过了存放知识的那层楼，就再也回不去了。
Stacking depth
要打破单程票的限制，最直观的两个反应是：要么用思维链（CoT），要么把模型直接堆得更深。但它们都有各自的局限。
思维链的逻辑很简单：既然单次前向不够走，那就把中间结果写出来 (Wei et al., 2022)。只要模型把 Florida 当成 token 输出出来，下一个 token 的前向计算就会重新从第一层开始跑，底层的全部参数和注意力便再次完整可用。推理链有多少步，CoT 就可以写多少个中间 token。代价大家也很熟悉：每多走一步，就要完整跑一遍前向，中间状态也必须落成一个具体的词。这条路和 loop 也可以叠加：CoT 增加的是步数，loop 加深的是每一步，一次前向能做的越多，需要写出来的步骤就越少，一个 loop 模型照样可以写 CoT。
另一条路是不写 token，直接把模型做得更深。但事情并没有这么简单，实证研究发现，把模型堆深并不会自动换来更长的推理链。Csordás 等人比较了 Llama 3.1、Qwen 3 和 OLMo 2 等系列里深浅不同的模型 (Csordás et al., 2025)：深模型后半段的层大部分时间都在对前面已经形成的预测做微调修补，即便直接跳过这些层，输出也几乎不受影响；在需要多跳的题目上，更深的模型也没有展现出能串联更多步骤的迹象。
换句话说，至少在这些模型里，盲目堆深层数更像是把原本同样的计算过程等比例拉伸到了更多层里，网络并没有主动把多出来的层开辟成推理的第二阶段。前面 LLaMA-2 从 32 层加到 80 层、第二跳仍不见改善，也符合这个图景。预训练目标本身对深度也不太敏感：Kaplan 等人发现，总参数量固定时，深宽比在 40 倍的范围里变动，预训练 loss 几乎不变 (Kaplan et al., 2020)。在海量的网页文本里，真正需要多步隐式推理才能猜对的 token 极少，平均下来的 loss 很难反映出它们，模型多半也就没有足够的动力去把各层重新分工。结果就是，存放在低层的知识依然只会被经过一次。第一跳要是解晚了，上面就算多出几十层，也找不回第二跳需要的那条事实。
What loop adds
Loop 同样增加了有效计算深度，只是多出来的深度来自把同一个块反复跑几遍。这种结构带来了普通叠层做不到的两个特性。
第一个特性是，低层的知识可以再查一次。在普通的模型里，状态走过第 10 层就永远离开了第 10 层。在 loop 结构里，隐藏状态走完块的第一遍后，第一跳算出来的 Florida 保留在向量里；接着它折返回块的第一层，原本位于块底层的注意力和 FFN，又重新排到了它的前面。这相当于在架构层面内建了 Biran 等人手动做的“状态拷回”：第二跳可以重新调用曾经错过的那批参数。在三明治结构里，折返回的是块的第一层，只跑一遍的 prelude 不会再被经过。
这一点在小规模的合成实验里得到了验证。Wang 等人从头训练了一个 8 层 Transformer 做两跳事实推理 (Wang et al., 2024)，发现训练中只单独出现过的事实只被学进了较低的层，到了两跳题里需要在上面几层作为第二跳去查时，模型就答不出来。他们让前 4 层和后 4 层共享参数，相当于把一个 4 层的块跑两遍，模型就学会了这些组合，只是学得慢得多。Ouro 的作者在合成的三跳问答中也观察到，loop 模型掌握这类组合所需的训练样本更少。
第二个特性是，同一套规则可以反复套用。许多推理任务其实是同一个操作的不断重复，比如一长串数字的累加、表达式树的自底向上化简，或者沿着变量赋值一步步回溯查找。对这种任务，普通的深层模型必须让每一层各自学会这个操作，要花掉不少参数；loop 模型只需要一套权重学会这个规则，然后通过循环多跑几次，就能顺理成章地走完整条链。Saunshi 等人的实验很能说明问题：在不写思维链、直接心算 32 个三位数之和的任务里，2 层的网络只跑 1 遍，准确率只有 38.8%，同样的 2 层网络循环 6 遍，准确率升到了 99.5%，几乎追平了拥有 12 层独立参数的模型 (Saunshi et al., 2025)。
放到更接近自然语言的规模上，Saunshi 等人用 2500 亿 token 训练了约 1B 参数的模型。4 层循环 6 遍的模型与 24 层的普通基线深度相同，参数量只有它的六分之一，在多步变量追踪这类 reasoning primitives 任务上以 56.9% 胜过了基线的 47.5%，代价是困惑度更差。他们还做了一组对照：保留全部 24 层的独立参数，只在训练中加一项正则，把每 4 层一组的参数往相邻一组拉近。这个模型同样拿到了 57.2%，困惑度也没有损失。可见在这类任务上，收益来自让各计算步执行相近的操作，权重是否真的同一份并不要紧；参数共享的好处是不用多花参数就能做到这一点。
不过，上面这些漂亮的收益大多来自受控的小型实验或合成任务。一旦放到真实的大模型和自然语言基准上，证据就开始打架了。Lu 等人测试了开源的 Huginn，发现把循环遍数从 4 遍拉到 32 遍，它不写思考过程做 GSM8K 的准确率只从 3.11% 挪到了 4.93%，再往上加就不动了；同一个模型写出 CoT 时，按两种计分方式分别能拿到 24.87% 和 38.13% (Lu et al., 2025)。Schwethelm 等人在固定有效深度的前提下训练了上百个规模较小的模型，在数学应用题和 reasoning primitives 上都没看到超出随机种子波动的架构差异 (Schwethelm et al., 2026)，这和 Saunshi 等人的结果不一致。两组实验的规模和训练量都不同，目前还说不清哪一组更接近大模型的情形。
另一个问题是，我们至今很难看懂每一遍循环里模型到底算出了什么。Lu 等人用 logit lens 和 coda lens（把块的输出交给 coda 去读）逐遍解码了 Huginn 的中间状态，读数随读法变化很大，中间结果和最终答案在各遍之间也没有规整的先后交接。两跳题之所以能像图 2 那样读、那样改，是因为它的中间结果是一个能叫出名字的实体；更复杂的推理往往没有这样一个词可以对照。在真实的复杂推理里，“每一遍循环刚好走一跳”目前还只是一种直觉上的设想，loop 有效的证据都还停留在准确率和学习速度这样的行为层面。
How to train
上一章我们看到，loop 是把同一组 Transformer 块在单次前向里反复调用：第 $r$ 遍输出的隐藏状态，直接作为第 $r+1$ 遍的输入。这种“原地转圈”的设计虽然省下了参数，却给训练挖下了不小的坑：Huginn 在规模化训练中接连失败了两次，Ouro 也被迫把设计好的 8 遍循环砍半退回到了 4 遍。
从计算图的角度看，训练它似乎并不复杂。我们只要把跑 $R$ 遍的循环按顺序“展开”，就会得到一个把同一个块串了 $R$ 次的深层网络；反向传播时，每一遍算出的梯度最终累加到这一套共享参数上，就像输入词表与输出层共用同一个嵌入矩阵一样直观。
但真正的差别出在参数被调用的上下文上。在普通的 Transformer 里，第 5 层的权重只处理第 4 层的输出，各层各司其职；而在 loop 模型中，同一个块从第 2 遍开始，处理的全都是自己上一遍刚吐出来的产物。这就带来了一个连锁反应：块权重中任何一点微小的偏差（比如不小心把状态里的某个特征方向放大了一点点），在单次前向中就会被连续重复 $R$ 遍；更要命的是，反向传播更新一次参数，会同时改动所有这 $R$ 遍的前向行为。
这意味着，训练 loop 模型除了普通的参数拟合，首先要牢牢管住隐藏状态在各遍之间的演化轨道：既不能让状态在循环往复中滚雪球崩溃，也不能让系统过早僵死、导致后面的循环全在空转。
Stability
要理解状态为什么容易失控，最好的例子莫过于 Huginn 在 3.5B 规模上的两次失败。它们恰好撞上了动力系统两个截然相反的极端。
Huginn 是一个 3.5B 参数、从随机初始化开始预训练的模型，采用第一章提到的三明治结构：前 2 层（prelude）把输入的 token 编码成向量 $e$，中间 4 层组成反复循环的块，最后 2 层（coda）把块的最终状态变成输出。第一次训练用的是最直接的设置：每一遍都把 $e$ 直接加到上一遍的状态上，中间不经过可学习的层；块里每个注意力子层和 MLP 子层的前后各做一次 RMSNorm，这些归一化不带可学习的缩放参数；输入嵌入不做缩放；峰值学习率取常规的 $4\times10^{-4}$。结果训练 loss 很快停滞。排查后发现，模型出现了表示坍缩（representation collapse）：同一条序列里不同位置的 token 向量越来越像，相关性一路升到 1.0。各个位置的状态几乎一样，模型也就无法预测下一个词。作者认为原因出在循环本身：块每跑一遍，token 之间的相关性就升高一些。注意力本来就在混合不同位置的信息，同一个块连续跑几十遍，这种混合一遍遍叠加，最后整条序列被混成了同一个状态。这个问题在小规模试验里没有出现，直到模型扩大到 3.5B 规模才暴露出来。
第二次训练，他们试图通过结构调整阻止坍缩：把状态和输入拼接后用一个可学习的 adapter 映射，换上经典的 pre-norm，并缩放输入嵌入。坍缩在前 150 步之后恢复了，却走向了另一个极端：模型学会了“摆烂”。无论跑 1 遍还是跑 32 遍，验证集困惑度毫无差别。按作者的解释，模型早早学会了忽略块传进来的状态，后面的 31 遍循环全成了摆设。
直到第三次尝试，团队保留了 adapter 和缩放，把归一化换回第一次那种子层前后各一次的写法，并把学习率一口气砍到原本的十分之一（$4\times10^{-5}$），才终于在 7500 亿 token 的训练中走通了全程：相关性保持健康，且跑的遍数越多、困惑度越低。三次之间同时改了好几处，论文没有拆开检验每一处的作用。
为了看清这“一碰就炸”和“原地装死”背后的机理，Prairie 等人在今年 4 月提出 Parcae 时 (Prairie et al., 2026)，把块里每一遍的更新拆解开来。
在第 $r$ 遍计算时，块能用到的原料最多两样：一是上一遍留下的状态 $h_{r-1}$；二是最初由前置层（prelude）编码好的原始输入 $e$。Huginn 和 Parcae 都把 $e$ 在每一遍重新喂给块（重新注入），Ouro 则没有这一步，块只接收上一遍的状态，所以这是一种架构选择。Huginn 的作者拿梯度下降作类比：梯度下降每一步都需要看数据，求出的才是和这份数据有关的解；如果只在第一遍给一次输入，一个越转越稳的迭代最后停在哪里就和输入无关了，最初要回答的提问也就被忘掉了。
Parcae 把这两者的混合与后续计算拆成了线性和非线性两部分：
\[h_r = A h_{r-1} + B e + \mathcal{R}(h_{r-1}, e).\]其中，$A$ 决定了上一遍的状态能按多大比例线性地继承下来，$B$ 控制当前输入怎样注入，而 $\mathcal{R}$ 则是其余的非线性计算，主要来自注意力与 MLP 子层。
如果暂时拿掉非线性部分 $\mathcal{R}$，状态的演化就退化成了一个纯粹的线性系统。此时，上一遍状态中的任何一个小扰动，每转一圈就会被矩阵 $A$ 连乘一次。这就像一个标量被反复乘以 $a$：只要 $\lvert a \rvert < 1$，扰动就会越乘越小，最终消解掉；一旦 $\lvert a \rvert > 1$，扰动就会指数级增长。在矩阵世界里，充当这个放大系数的是 $A$ 的谱半径 $\rho(A)$，即绝对值最大的那个特征值。当 $\rho(A) > 1$ 时，至少有一个方向上的分量会逐遍放大，状态只要在这个方向上有分量，范数就会随着循环遍数增长。当 $\rho(A) < 1$ 时，不管从什么起点出发，扰动最终都会衰减，线性迭代会平稳收敛到一个唯一的平衡态，数学上称为不动点（fixed point），满足 $h^\ast = A h^\ast + B e$。这些都只是线性部分的结论，完整的一遍更新还包括 $\mathcal{R}$。
需要澄清的是，这里说的“收敛到不动点”，是指同一个 token 的内部表征随循环次数增加而逐渐稳定，这与 Huginn 第一次失败中“不同 token 互相趋同”的表示坍缩是两码事：由于每个 token 的输入 $e$ 不同，它们各自收敛到的不动点依然各具特色。它也不同于训练 loss 的收敛，后者说的是 loss 随参数更新的步数不再下降。
用这个简化模型回头看，前人的踩坑逻辑就清楚多了。在这个拆分下，直接把输入 $e$ 加到状态上，合并这一步的 $A$ 就是单位矩阵，$\rho(A) = 1$，处在临界；后面 Transformer 层的残差连接还会带进自己的部分。Huginn 后来用的 adapter 则对 $A$ 没有任何约束。Prairie 等人观察到，发散的训练里学出来的谱半径都大于等于 1，状态的范数随遍数爆炸。
Parcae 采取了直截了当的解法：从结构上把矩阵 $A$ 限制为对角阵，且对角元素严格落在 $(0, 1)$ 区间内，卡死 $\rho(A) < 1$；注入的 $e$ 也先归一化再乘 $B$。这个约束只加在合并这一步，完整的一遍更新稳不稳定，还要看包括 $\mathcal{R}$ 在内的整个更新，$\rho(A) < 1$ 保证不了。它的效果来自实验：有了这个约束，Parcae 即使在激进的 $10^{-3}$ 峰值学习率下依然能平稳收敛（普通结构在 $4\times10^{-4}$ 下就崩了），训练后期（约 17 万步以后）的 loss 尖峰完全消失；在数据和参数量相同的条件下，验证困惑度比之前的 loop 模型最多低 6.3%。
而像 Ouro 这样没有加显式谱约束的架构，就只能靠工程调参小心翼翼地走钢丝：发现跑 8 遍时出现 loss 尖峰和梯度震荡，就主动退回 4 遍；同时把 batch size 从 400 万逐步加到 800 万 token 来平滑梯度，并使用比同规模 Transformer 更小的学习率。无论是结构约束还是调低学习率，都是在按住扰动的放大系数。但正如 Huginn 第二次失败所显示的，另一头同样存在：那次训练没有发散，后面的遍数却对预测毫无贡献。把每一遍的变化都压得很小的迭代，同样可能让后面的几十圈循环沦为毫无意义的空转。
Starting point
回顾前文聊到的 Huginn、Ouro 和 Parcae，它们不约而同地选择了从随机初始化开始的完整预训练。这条路线的难处在于，模型必须同时啃下两块硬骨头：一是掌握庞大的语言和世界知识，二是让同一个网络块反复跑几十遍还保持稳定。
但把这两件事拆开来看就会发现：第一件事的解法已经非常成熟，训好的普通 Transformer 随手可得；上一节讲的“失控”和“空转”，都出在第二件事上。既然如此，最顺理成章的思路就是直接从一个训好的普通 Transformer 出发，截取其中一部分层充当共享块，再用一段增量训练教会它循环。
Bae 等人在 Gemma 2B 上试了这条路 (Bae et al., 2024)。原模型有 18 层，他们打算砍成一个 9 层的块循环跑两遍，从而捏出一个参数减半的 Recursive Gemma 1B。可原模型里有两层要映射到现在的同一层上，参数该怎么取？实验发现：如果严格做权重共享，按固定间隔挑出一半的层（同时保留第一层和最后一层）效果最好；如果更灵活一点，允许每一遍在共享底座上叠一个小 LoRA，就可以把对应的两层权重取平均作为底座，再用差值的截断奇异值分解（SVD）来初始化 LoRA。结果，这个改造模型仅追加训练了 150 亿 token，少样本平均准确率就达到了 51.7%，把同等参数量、按同样配方从头训练的模型（38.2%）远远甩在身后。
McLeish 等人则采用了更贴合 Huginn 三明治结构的拆分法 (McLeish et al., 2025)：他们把 22 层的 TinyLlama 直接切段，前 4 层做前置 prelude，中间第 10 到 17 层做循环块，最后 4 层做后置 coda，中间剩下的 6 层直接扔掉。拿这套配方去改造 Llama-3.2-1B，继续训练 1200 亿 token 后的 loss，依然明显低于从零训练的同结构模型；按照曲线推算，从零训练至少要 9500 亿 token 才能追平。
但“拿来主义”并不是没有门槛的。普通大模型的层生来就处在固定深度，每次前向只跑一遍，它们从没经历过被连续反复施加。Chen 等人的实验表明，如果完全不加训练，硬把冻结模型的中间几层拉来原地转圈，性能通常会变差 (Chen et al., 2026)；他们把每一遍拆成几次带阻尼的小步、限制状态的变动幅度，才在 Qwen3-4B-Instruct 的 MMLU-Pro 上换来 2.64 个百分点的提升。
因此，改造之后的继续训练，实际上是在同时赶几项工期。首先是疗伤：粗暴地挑走和丢弃部分层，会先破坏模型原有的语言建模能力，McLeish 等人先在普通网页文本上跑 260 亿 token 让它“回血”，再混入数学推理数据，这比一上来就混训在 ARC-Challenge 上高出 5 个百分点。其次，原有的知识和表示在这段训练里也会继续调整：按训练算力对齐来比，算力追加之后，原模型的 GSM8K 准确率停住了，改造后的模型还在继续攀升。最后，这些现成的层同样要学会前面提到的“在反复迭代中保持稳定”：在改造训练中，经典的 AdamW 优化器在 $5\times10^{-5}$ 的学习率下训到中途，loss 出现尖峰、变成 NaN，换上 Muon 优化器才稳住。
表面上看，这和前文“从头训练更难”的直觉有些矛盾，其实两边比较的起点并不相同。Bae 和 McLeish 等人比的是追加同样多的训练量，改造模型带着原模型整套预训练的底子进场，自然占了便宜。Nanbeige 团队在训练 Nanbeige4.2-3B 时，问的则是另一个问题：如果本来就要做一次完整的预训练，是先训好一个普通 Transformer 再切层改造，还是从第一步就直接训 loop 结构？在他们的实验里，从头直接训 loop 的效果明显更好。报告给出的解释是：当模型从随机初始化开始学习时，内部表示可以在整个预训练过程中逐步适应同一组层的反复调用；如果等权重已经定型在单次前向的习惯里再强行引入循环，就错过了这段适应期。因此，半路改造更适合手里已有现成模型、追加预算又有限的场景；要是打算从零投入大规模预训练，还是应该让循环从一开始就参与进来。
Training depth
权重无论是从头初始化还是半路改造，一旦开始训练，开发者立刻会撞上另一个避不开的选择题：每一步训练时，到底该让模型跑几遍循环？
直觉上，如果每步训练都死板地固定跑 $R$ 遍，损失函数其实只落在了第 $R$ 遍的最终输出上，中间第 1 到 $R-1$ 遍的输出根本没有接收到直接的梯度监督。这样训出来的模型是僵化的：我们希望在推理时根据任务难度自由拧动遍数旋钮（简单的题少跑两遍，难的题多跑几遍），但前提是模型在训练阶段就得见识过各种深浅不同的循环次数。
为了实现这种泛化，各家团队在训练策略上各有做法。Huginn 每个 micro-batch 随机抽一个循环遍数，均值约为 32，带有长尾；但由于一个批次只用一个遍数，不同训练步之间的梯度会随着抽到的深度波动。Parcae 更进一步，在同一个 micro-batch 内部为每条样本独立抽取不同的遍数，每一步更新都融合了从浅到深的梯度，训练过程中的 loss 尖峰随即抹平，低遍数下的表现也更好。Ouro 则不搞随机抽样，每条样本都雷打不动跑满 4 遍，但在每一遍的出口处都挂上一个输出头（LM head）计算 loss，强迫模型在跑 1 遍、2 遍、3 遍、4 遍时都必须具备语言建模能力。
需要注意的是，推理时这个旋钮能拧多远，和训练时覆盖的深度范围有关。Ouro 训练时最高只跑过 4 遍，它的 1.4B 推理模型在 AIME 2024 上强行跑 8 遍，准确率从 65.0% 一下掉到了 38.7%；而 Huginn 的抽样分布带有长尾，训练中偶尔也会跑到远多于 32 遍，推理时跑 32 遍以上未必超出它见过的范围。超出训练范围后退化多少，要看具体的架构和训练方法。
然而，一旦把训练遍数拉大，显存危机就接踵而至了。前向计算跑 $R$ 遍已经无法逃避；如果反向传播还要老老实实做全量求导，就必须把整整 $R$ 遍的所有中间激活值全锁在显存里，反向的计算量也跟着 $R$ 增长。遇到 Huginn 偶尔抽到的超大遍数，显存开销会远超平均水平。
Huginn 最终给出的破局法是截断反向传播（truncated BPTT）：前向计算依然忠实地跑完 $R$ 遍，但只保留最后 8 遍的计算图做反向传播。在第 $R-8$ 遍和第 $R-7$ 遍之间，反向求导的链条被一刀切断，前面的循环只负责输送前向状态，不存激活值，梯度也不再沿状态传回这些遍数。
这样一来，每一步训练需要保存的激活和反向的计算量都被锚定在 8 遍以内，和抽到多深无关，随遍数增长的只剩前向。共享块依然能从最后 8 遍里吸收充足的梯度；前置层 prelude 也安然无恙，因为它的输出 $e$ 在这最后 8 遍里依然每一遍都在被重新注入。前向的开销仍随遍数增长，McLeish 等人借鉴了网络渐进式加深（gradual stacking）的思路，在训练进程中让平均遍数从低到高平滑爬升到 32，在相同总算力下换取了更低的验证 loss。
许多人的第一反应会是：把前 $R-8$ 遍的梯度直接丢掉，难道不会算不准吗？
这再次呼应了我们在第一节推导出的收敛结论。我们可以借助一个最简单的标量递推式 $h_r = a h_{r-1} + b$ 来直观感受（其中 $b$ 对应每一遍注入的输入）：跑完 $R$ 遍后，输入 $b$ 对最终状态 $h_R$ 的导数是一个等比级数：
\[\frac{\partial h_R}{\partial b} = \sum_{j=0}^{R-1} a^j.\]其中第 $j$ 项代表倒数第 $j+1$ 遍注入的信息，经过后面 $j$ 轮缩放后在最终输出中激起的回响。只对最后 $K$ 遍反传，保留的正好是这个级数的前 $K$ 项。
只要迭代是收缩的（$\lvert a \rvert < 1$），越早的项衰减得越快，丢掉的部分是以 $a^K$ 的量级萎缩的微小量，截断反传几乎不损失什么；反之，如果 $\lvert a \rvert \ge 1$，最早的那几项不比后面的小，$\lvert a \rvert > 1$ 时还更大，截断丢掉的反而是大头。真实的 loop 模型里，$a$ 换成了每一遍更新对状态的 Jacobian，而且各遍不同。Huang 等人推导了对应的结论 (Huang et al., 2026)：在稳定的不动点附近，只反传最后 $K$ 遍得到的梯度，近似于完整梯度展开成级数后的前 $K$ 项，误差随 $K$ 几何衰减。
简言之，截断反传敢扔掉前面的梯度，前提是被保留的那几遍处在收缩的区域；状态离不动点还远，或者更新在放大扰动时，这个近似就没有保证。
Early exit
模型已经被训练得适应各种深度，而且在收缩的迭代里，状态越往后变化越小，推理时就多了一个收益点：不同难度的 token 需要的推演深度不同，一个词的输出如果已经不再变化，再硬跑完全程多半只是在消耗算力。让容易的 token 提前退出（early exit），就能把算力留给真正棘手的词，难的是判断一个 token 什么时候可以停。
业界给出了两种思路。Huginn 走的是无监督的启发式判定，完全不需要额外训练，直接比对当前这一遍与上一遍输出的词表概率分布，只要两者的 KL 散度低于 $5\times10^{-4}$，就当场截断输出。在 MMLU 各学科的测试中，模型在高中数学题上早早就刹车交卷，而在道德情境题上平均会多想 3.5 遍；在 MT-Bench 上，提前退出拿到了与跑满固定遍数几乎持平的成绩（5.56 分 vs 5.63 分）。这个判据看的是输出分布：输出不再变，隐藏状态仍可能在输出层读不到的方向上变化，模型也可能只是停在了一个很有把握的错误答案上。
Ouro 走的是有监督的学习门控，专门在每一遍外挂一个由线性层和 sigmoid 构成的“刹车控制器”，预测继续思考能否给当前 token 带来实质性的 loss 下降。推理时累加停止概率，超过阈值 $q$ 便停下。在 MMLU 上，固定跑 1 遍（约 40%）和跑 4 遍（67.35%）差距悬殊，而门控机制让模型平均只跑 2.5 遍，就拿到了 66%。Bae 等人提出的 Mixture-of-Recursions（MoR）则把“谁继续算”的决定提前到了训练里 (Bae et al., 2025)：每一遍开始前，路由器给各个 token 打分，只有得分最高的一部分 token 进入下一遍，训练和推理都只为这些活跃 token 计算。不过，在整条序列里按排名挑 top-k 有个因果性问题：一个 token 能不能入选，会受序列后面其他 token 分数的影响，这在自回归逐词生成时还拿不到，MoR 为此在训练时给路由器加了一项辅助损失，让它学会只看当前 token 就判断自己会不会入选，推理时据此独立做判断。
有趣的是，如果放弃复杂的门控网络，仅仅用一条朴素的规则，“只要相邻两遍隐藏状态的变动量小于阈值就停”，在平均跑 2 到 3 遍时，表现跟费劲训练的门控相比仅差了 1 到 2 个百分点。这说明判断一个 token 该不该停所需的信号，大部分已经包含在它的状态还动不动里。
然而，在自回归生成的工程落地中，早退机制带来了一个棘手的副作用：KV cache 出现了断层。
在因果注意力机制中，当前 token 在第 $r$ 遍计算时，要去查阅前文所有历史 token 在第 $r$ 遍计算出的 Key 和 Value。在传统模型里，每个 token 跑完的深度都一样；但在早退机制下，假设前面的代词在第 3 遍就已经满意离场了，当前正在深度思考的动词跑到了第 10 遍，它该去哪里读取前一个代词在第 4 到第 10 遍的 KV 缓存呢？
对于这个缓存缺失难题，目前有三种化解路线。第一种是 Huginn 采用的降级对齐：如果前面的 token 在第 3 遍退出了，后面更深的遍数去查它时，就一律复用它停留的最深版本，即第 3 遍生成的 KV。各遍的 K、V 由同一组投影矩阵算出，落在同一个空间里，可不同遍数的状态并不相同，这样替换是否可行只能看实验，上面 MT-Bench 的结果就是在这种做法下得到的。第二种是 MoR 的做法，干脆让退出的 token 在更深的遍数里不再被看到：第 $r$ 遍的注意力只在仍然留在这一遍的 token 之间计算，缓存也只存这些 token 的 KV，后续的词跑到第 $r$ 遍时也就不需要去查已经退出的词。第三种是 Huang 等人采用的终态唯一缓存：他们的模型训练后状态接近不动点，解码时干脆为每个 token 只保留最后一遍的 KV，不管后续 token 跑到哪一遍，一律查阅这份单一缓存。常规做法下每遍各存一份 KV，缓存会随有效深度成倍增长；在他们 1.6B 以下的模型、训练时的 5 遍深度上，这招砍掉了三分之二的缓存开销，而困惑度最多仅上升了 0.85%。
把整套训练和推理技术拼在一起，会发现它们都依赖状态在各遍之间怎样演化，要求却各不相同。为了防止训练发散，扰动不能在各遍之间被放大；截断反传要省显存，依赖的是更早遍数对梯度的影响逐渐衰减；推理时的早退刹车需要一个看得见的信号，说明再跑下去输出或状态变化不大；只有终态 KV 压缩要求状态真的接近不动点。
然而，这里也藏着 loop 模型的一个内在矛盾。我们费尽周折引入循环，本意是希望它多跑几遍，能在每一次循环中做出新的推导；可一旦状态真正落入了不动点，$h_r$ 和 $h_{r-1}$ 几乎没有区别，后续的循环就会失去计算活性，变成纯粹的空转。Huginn 训练时平均跑 32 遍，在 ARC-Challenge 上，遍数从 4 加到 16 还有收益，超过 16 遍曲线就平了，可能与此有关；早期试验中多跑 31 遍毫无起色，则是后面遍数白跑的极端情形。
驯服一个 loop 模型，就是要在这两头之间找到站位：既要用架构约束和训练设置管住扰动，让迭代保持可控、让梯度可以放心截断；又要让隐藏状态在最终停下之前，还能继续走得足够深，后面的遍数才有东西可算。
Why not
从原理上看，loop 最诱人的地方是它把计算深度变成了可以随意拧动的旋钮：参数量不用增加，多转几圈就能换来更深的推理，早期的 Huginn 也确实把平均遍数拉到了 32 遍。但如果我们把目光转向那些真正按生产级数据量训练出来的模型，会发现大家选的循环其实都非常浅：用了 28 万亿 token 预训练的 Nanbeige4.2-3B，整个层栈只跑 2 遍，技术报告提到，超过 2 遍之后继续增加遍数，能力提升已经很小，训练却会明显变慢、变不稳；微软截图中露面的 GPT-6.1 Sol 同样只跑 2 遍，字节的 Ouro 也从原定的 8 遍退回到了 4 遍。既然循环理论上能把网络不断加深，为什么落地的模型都不约而同地停在了两到四遍？要回答这个问题，得算清楚引入 loop 之后必须付出的几笔账。
Compute
把 16 层的网络折叠成 4 层循环 4 遍，省下来的只有存放权重的显存，每次前向依然要结结实实地跑完 16 层的矩阵乘法，计算量一点没少。如果按相同的训练算力预算来比，结果对 loop 并不友好。Schwethelm 等人做过这样的等算力对照：一个只有 410M 独立参数、循环 4 遍的模型，每个 token 消耗的算力与 1B 的普通模型相当，预训练 loss 却只追平了 580M 的普通模型。也就是说，在普通的稠密架构下，把预算花在让同一组层多转几圈上，压低预训练 loss 的效率反而不如把算力直接拿去训练更多的独立参数。
同样花掉 1B 模型的算力，loop 模型的语言建模 loss 却落在了后面，多半是因为预训练 loss 有很大一部分取决于模型记住了多少世界知识，而记忆容量取决于独立参数的总数，并不随计算深度增长。在 Ouro 的人物传记记忆测试中，无论模型循环跑 1 遍还是 4 遍，每个参数能存下的信息量始终维持在大约 2 bit 左右，把同一套参数反复算四遍，并不能让它多记住四倍的事实。前文提到 Saunshi 等人的 loop 模型在推理题上胜过了同深度的普通基线，语言建模的困惑度却更差，多半也与此有关：循环拉长了推理链，却把原本用来装知识的独立层砍掉了。
如果稠密 loop 在等算力下吃亏是因为参数太少、装不下足够多的知识，一个自然的办法就是把“装知识”的任务交给混合专家（MoE）。MoE 用庞大的专家池扩充总参数量，每次前向只激活其中一小部分，正好补上了 loop 缺的记忆容量，又不至于让单 token 算力跟着暴涨。SMELT 团队沿着这条路做了实验 (Wang et al., 2026)：他们在 MoE 模型里把中间一半的层循环跑两遍，同时收窄隐藏维度、扩大专家池并调整注意力头，使每个 token 的计算量、总非嵌入参数量以及 KV cache 容量都与普通的 MoE 对照模型保持一致。把这套配置一路扩到 540 亿非嵌入参数后，他们在算力最优前沿上观测到了 6.8% 到 18% 的训练算力节省（当然，这离不开宽度、专家数与循环的协同调整，并非单纯给现成模型加个循环就能自动生效）。把两组实验对照着看，loop 在算力上究竟是亏是赚，多半取决于知识容量有没有被补齐：在参数受限的稠密结构里，循环挤占了存储事实的空间；一旦容量交由稀疏专家承担，反复利用同一组层才在训练算力上显出收益。
Latency
训练算力之外，真正决定模型能不能上线服务的，往往是推理阶段的延迟和显存带宽。loop 结构把同一个块串行执行 $R$ 遍，每一遍都必须严格等上一遍算完才能动工，生成单个 token 的延迟因此随着遍数线性拉长。更棘手的是显存开销：前文提到，如果每一遍循环都单独保存一份 KV cache，缓存体积就会跟着有效深度成倍膨胀，原本靠共享权重省下来的显存很快又被吃了回去。为了堵住这个缺口，研究者尝试过压缩循环中的缓存，但到了大规模训练里可能要付出效果代价，比如 Nanbeige 团队就测试过让两遍循环共用同一份 KV cache，虽然缓存占用直接减半，模型在各项评测上的表现却始终不如每遍各存一份的完整配置。
每一遍都要实打实地花掉延迟和缓存，上一章设想的动态遍数，平时少跑几遍、只在遇到难题时多跑几遍，看上去能把平均延迟压下来，但从现有的工程实现来看，这条路比预想的要窄。一方面，动态早退在真正落地时很容易变成“省了名义深度、没省实际算力”：在 GPU 上做批量推理时，batch 里的各条序列虽然停在各自的位置，每一步却都是一起各生成一个 token，这一步要等所有序列算完才算结束。只要还有一个 token 的门控没让它停下，已经停下的那些就只能陪着空转，而 batch 越大，几乎每一步都会碰上一个要跑满遍数的 token（图 3）。就连 Ouro 开源的推理代码，实际执行时也是先把 4 遍全部跑完，再根据门控信号去挑出某一遍的输出 (ByteDance Seed, 2025)。
另一方面，即便在逐请求场景下允许自由调节遍数，可调的区间也很有限：正如我们在训练深度一节看到的，遍数一旦拧出训练覆盖的上限，模型准确率就会大幅滑坡；而在训练范围之内，像 Huginn 这样训练时平均跑 32 遍的模型，在 ARC-Challenge 上超过 16 遍之后准确率曲线就已经走平。当多跑几遍带来的边际收益很快触顶，而每增加一遍带来的延迟却实实在在地一分不少时，推理部署往往只能把遍数收紧在很小的范围里。
Monitorability
9 月 The Information 报道 GPT-6 Astra 采用了 recurrent depth 架构后，Redwood Research 的 Ryan Greenblatt 在 X 上说这 “may be the single worst development for AI security/safety to date” (Wright, 2026)。一个网络结构改动之所以引发如此强烈的安全警报，背后有一套清晰的推理链条：在标准的推理模型里，单次前向的层数是固定的，模型如果想要执行一段足够长的多步规划，就必须把中间步骤写成思维链（CoT） token，好让下一次前向计算能够重新读取，而这些写出来的文字恰好给了审查人员和监控程序一扇观察模型意图的窗口。Korbak 等四十多位作者联名发表的立场文件基于这一前提发出警告 (Korbak et al., 2025)：他们专门点名了 Huginn 和 Coconut (Hao et al., 2024) 这类在隐空间里循环推理的结构，认为一旦网络高层算出的状态无需落成 token 就能折返回低层继续加工，长串行计算就不再需要借助思维链，这扇安全监控的窗口也就随之关闭了。
这种担忧抓住了思维链监控最核心的机制，但如果顺着前文对计算图的拆解往下看，有两点需要分清。第一，在隐藏状态里不写字地完成推理，并不是 loop 带来的新能力。我们在第二章已经见过，没有 loop 的 Qwen3.6-27B 关掉思考模式照样能直接答出 Miami 所在州的首府，中间词 Florida 只在残差流里一闪而过；普通 Transformer 同样在做隐式推理，只是单次前向最多只能串行穿过 $L$ 层，超出这个长度的推导才被迫写成 token。第二，把层栈循环 $R$ 遍，确实抬高了单次前向能串行的计算上限，但它抬高的是一个固定的常数倍数。以传闻中的两三遍为例，模型一次前向能走的最长路径只是变成了原来的两三倍，并非无限延伸（图 4）。真正把长度上限彻底去掉的，是 Korbak 等人同时提到的 Coconut 那类跨 token 隐式循环：它把上一步最后一层的隐藏向量直接当成下一步的输入，推理可以在任意多个位置之间连续传递而始终不落成文字。把只跑两三遍的层内循环与没有长度上限的跨 token 循环混为一谈，无形中放大了前者的结构变化。
GPT-6 Astra 发布时的 system card 给出了真实前沿模型上的一组具体测量 (OpenAI, 2026)：与前代模型相比，Astra 的思维链可监控性确实出现了明显下滑，主要表现为模型输出的 CoT 变得更短、包含的信息更少，甚至更频繁地出现极短或完全空白的思考过程；而在那些仍然写出较长 CoT 的样本上，可监控性基本能够恢复。与之相伴的另一面，是模型不写 CoT 也能直接完成任务的能力大幅跃升。英国 AI Security Institute 的独立测试显示，在完全关闭推理输出时，Astra 能独立解出的数学题难度相当于人类 30.9 分钟的工作量，而同代的 GPT-6 Sol 只有 3.6 分钟。Astra 的 CoT 可控性，也就是按指令约束自己思维链里写什么（比如全程不许出现某个词）时能做到的比例，达到了 60.9%，GPT-6 Sol 为 23.2%；这个比例越高，模型就越容易把思维链改写得躲过监控。有意思的是，OpenAI 在报告中表示相当确信 CoT 可控性的变化与架构改动无关，并发现这些变化与不写 CoT 能力的提升同步；最初联名发出警告的 Korbak 本人也在 OpenAI 任职，他在回应相关报道时同样表示，可监控性下降主要是能力增强的副产品，尽管他依然对失去思维链深感担忧。
另一方面，把 loop 视为监控的终结，还隐含了一个前提：模型一旦用上循环，就不会再写思维链，或者它的中间状态天生无法解读。至少从目前已公开的模型来看，这两种情况都没有发生。Astra 依然在输出思维链，只是写得更精简；Nanbeige4.2 在后训练中专门保留了思考模式，并用强化学习调节推理长度；Ouro 也发布了专门输出推理过程的 Thinking 版本。更进一步，循环中的隐状态也并非注定是个黑盒：Fan 等人提出的 LOTUS 在一个循环模型里用标准思维链的各个步骤去监督每一轮隐状态，训练完成后，把循环结束时的向量直接送进输出层就能还原出对应的推理步骤 (Fan et al., 2026)。这和前文 Lu 等人在无监督的 Huginn 上读不出规整步骤并不矛盾，它说明中间状态能不能读懂很大程度上取决于训练目标，循环结构本身并没有把门焊死。
退一步说，即便模型因为能力变强而少写了不少思考过程，思维链监控也还没有失效。前人早就注意到，模型写出来的 CoT 并不总是它做决定的真实依据：Chen 等人在题目里悄悄埋入提示，发现 Claude 3.7 Sonnet 和 DeepSeek R1 在借助提示改写答案后，主动在 CoT 里承认用过提示的比例平均只有 25% 和 39% (Chen et al., 2025)。但这类题目原本不写思维链也能做出来，写出的文字更像是事后补上的说辞。Emmons 等人把这种“事后解释”与真正“作为计算草稿”的思维链区分开来 (Emmons et al., 2025)：他们发现，当一项复杂或危险的任务必须依赖思维链作为工作草稿才能完成时，模型很难在顺利完成任务的同时又骗过监控程序；只是他们也提醒，一旦训练方式或架构设计让模型不再需要借助自然语言就能完成这类计算，规避监控就会变得容易得多。Astra 的评估结果恰好印证了前半句：模型并没有表现出在思维链里暗藏隐写信息的能力，规避监控的风险可能主要局限在那些本来就不需要 CoT 就能做完的任务上。
综合这些证据来看，把 loop 本身当成 AI 安全上最坏的消息，担心得有些过度了。隐式推理在 loop 出现之前就已经存在，loop 也没有让模型放弃输出思维链，它所做的只是在单次前向里把串行计算深度乘上了一个有限的倍数。比起模型有没有采用权重共享的循环结构，更值得持续盯紧的是模型在不写思维链的情况下究竟能独立完成多复杂的任务，以及哪些高风险行为仍然离不开思维链作为计算草稿。更深的循环确实会把“不写也能做成”的边界往外推一截，但这和扩大模型规模、加强强化学习所起的作用在方向上是一致的，把它算进 loop 的一份代价即可，不必视作某种打破安全防线的异类。
Outlook
回到文章开头的那几条传闻。无论是截图里跑 2 遍和 3 遍的 GPT-6 Sol 系列、传闻中被刻意限制了循环次数的 Astra，还是公开权重并同样选择跑 2 遍的 Nanbeige4.2-3B，它们拼出的其实是一幅相当克制的图景：前沿实践里的 loop 没有把几十层网络无限折叠，只停留在两三遍的浅层循环上。在这样一个区间里，模型有机会靠参数复用获得“回头再查一次低层知识、反复套用同一套计算规则”的深度收益，也能通过扩大底座规模或引入稀疏专家来补足记忆容量，同时尽量把串行延迟、显存占用以及隐式推理带来的安全风险压在可承受的范围内。
至于两三遍的浅层循环在超大规模模型上究竟能榨出多少额外的推理能力，目前依然是一个悬而未决的经验问题。小规模受控实验里那些亮眼的多跳和算法推理增益，到了自然语言大模型的复杂分布上还能兑现几分，仍有待更多公开的对照实验来给出答案。