#把 CoT 压成一个统一 think token：从 Pause Token 到潜空间推理的研究脉络

#0. 一句话结论

你提出的想法不是没人做，反而已经形成了一条很清晰的研究线：从 <pause> / dummy token 提供额外 forward 计算，到把 CoT 压缩成特殊 token / dense representation，再到 Coconut 这类连续潜空间推理。

但关键判断是：

“把所有 think 文本机械替换成同一个 token 然后 SFT”很可能不够；真正有效的版本通常需要让这个 token 的隐藏状态承载任务相关信息，或者在预训练/后训练阶段专门教模型如何利用这些 token。

换句话说，表面上看模型只在输出一个重复字符；但真正有用的不是这个字符本身，而是每输出一次 token，Transformer 又多跑了一轮，并且这个 token 对应位置的 hidden state 可以被后续 token attend 到。如果训练得当，这些 hidden state 就可能成为“不可读的草稿纸”。

你的想法可以概括成：

原始 CoT 数据：
Question -> <think> step1 step2 step3 ... </think> -> Answer

替换后数据：
Question -> <think> τ τ τ τ τ ... </think> -> Answer

推理时：
Question -> <think> τ τ τ τ τ ... </think> -> Answer

其中 τ 是统一的 think token / pause token / filler token。这个方向的核心问题是：

1. 额外 token 是否真的给模型更多计算？ 是的，每个 token 都触发一次新的自回归 forward，并产生新的 hidden state。
2. 这些 hidden state 是否会承载“思考内容”？ 不自动保证，需要训练目标设计。
3. 把自然语言 CoT 全部替换成同一个 token，会不会丢掉监督信号？ 会。最朴素的替换会把 step-level 语义监督抹掉，只剩“这里要等 N 步”的监督。
4. 有没有更强做法？ 有：learnable pause token、compressed CoT、hidden CoT、continuous thought、soft thinking、continue-thinking token 等。

下面按研究脉络展开。

#1. 先说人话：为什么“重复一个 token”理论上可能有用？

标准 decoder-only LLM 生成第 K+1 个 token 时，只能基于前面 K 个 token 的 hidden states 做计算。它的计算深度基本固定：每生成一个 token，模型跑一遍所有层。

如果我们让模型在答案前先生成 100 个“无意义”的 τ：

问题 -> τ -> τ -> τ -> ... -> 答案

那模型实际上做了 100 次额外的自回归步骤。每一步都会产生一个新的 hidden state。后面的 token 可以 attend 到这些 τ 位置的 hidden states。

所以 τ 不一定只是“空字符”。它可以像一张草稿纸：

• 外面看：每一步都只是同一个符号；
• 内部看：每个位置的 hidden state 都不同，因为它的上下文不同；
• 后续答案可以利用这些 hidden states。

这就是 Pause Tokens / contemplation tokens / latent reasoning 的共同直觉。

但这里有一个容易误解的点：

重复同一个 token，不等于重复同一个计算。

虽然 token id 一样，但第 1 个 τ、第 2 个 τ、第 50 个 τ 的位置编码、attention 上下文、KV cache 都不同，因此 hidden state 可以不同。

真正的问题不是“同一个 token 能不能提供计算”，而是：

模型有没有被训练成把这些额外 hidden states 当作有效工作区，而不是只学会空转。

#2. 最直接相关工作：Pause Tokens

#2.1 Think before you speak: Training Language Models With Pause Tokens（ICLR 2024）

• 论文：Think before you speak: Training Language Models With Pause Tokens
• arXiv：2310.02226
• 作者：Sachin Goyal 等
• 核心想法：在输入前缀后面追加一串 learnable <pause> token，模型看到最后一个 pause token 后才开始输出答案。

这篇几乎就是你想法的最直接祖先。

它问的问题非常直白：

语言模型平时生成下一个 token 时，只能基于已有 token 做一次固定量的计算。那能不能让它在真正输出前，多处理几个 dummy token，从而多做一些内部计算？

方法是：

原始：prefix -> answer

pause 版本：prefix -> <pause> <pause> ... <pause> -> answer

这里 <pause> 是 learnable token。关键不是让模型输出可读推理，而是让它“延迟回答”。

#2.2 主要实验结论

论文在 1B 和 130M decoder-only 模型上做了 pretraining + downstream finetuning。核心发现是：

只有当模型在预训练和下游微调阶段都见过 pause token 时，推理时加入 pause 才稳定有收益。

论文摘要和正文报告：对于 1B 模型，pause-training 在多个任务上有提升，例如：

• SQuAD exact match 提升约 18%；
• CommonSenseQA 提升约 8%；
• GSM8K 提升约 1% accuracy。

但它也发现：

• 如果只在下游 finetuning 加 pause，而预训练没有，收益弱很多，甚至可能掉点；
• 每个任务有自己的最佳 pause token 数；
• pause token 放在 prefix 后面通常比放在前面更好；
• 减少 inference-time pause 数量时，性能会相对平滑下降。

#2.3 对你想法的启发

这篇论文给你的想法一个重要判断：

可行，但不是简单 SFT 就一定行。

如果你只是拿一个已经训练好的模型，把 CoT 文本替换成 τ τ τ... 再 SFT，可能会遇到和论文里 “standard pretrain + pause finetune” 类似的问题：模型底层并没有在预训练阶段学会如何利用这些 dummy tokens 作为计算空间。

更强版本可能是：

1. 在继续预训练阶段插入 pause/filler token；
2. 在 SFT 阶段把 CoT 压成这些 token；
3. 在 RL/RLVR 阶段让模型学会选择 token 数量、何时停止、如何利用这些 token 改善最终答案。

#3. 从 pause token 到 “contemplation tokens”：不只是等一等，而是压缩思考

Pause Tokens 的 τ 本质上更像“给模型额外算力”。但你的问题更进一步：

能不能把真实 CoT 的内容压进统一 token 的 hidden states 里？

这就进入了 contemplation tokens 这一类工作。这个术语在 Compressed Chain of Thought 中被明确使用，用来指那些在推理时为模型提供额外计算的特殊 token。

可以把路线分成三层：

#4. Compressed Chain of Thought：把 CoT 压成 dense contemplation tokens

#4.1 Compressed Chain of Thought: Efficient Reasoning Through Dense Representations（2024）

• 论文：Compressed Chain of Thought: Efficient Reasoning Through Dense Representations
• arXiv：2412.13171
• 作者：Jeffrey Cheng, Benjamin Van Durme
• 核心想法：把显式 CoT 压缩成连续 dense contemplation tokens，用更少 token 获得类似推理收益。

这篇文章非常贴近你的问题，因为它直接讨论了：

CoT 很长，生成慢；能不能不生成完整自然语言推理，而生成一小段 dense representation 来承载推理？

它对相关方法做了一个很有用的分类：

CCoT 的关键在于：它不满足于“空转等待”，而是希望 contemplation tokens 是 contentful 的，也就是它们应该对应原始 CoT 的压缩版本。

#4.2 对你想法的启发

你的方案如果只是：

step1 step2 step3 -> τ τ τ

那 τ 的 label 本身没有携带 step1/step2/step3 的内容。模型能否把内容自动转移到 hidden state，取决于最终答案 loss 是否足够强、训练分布是否足够好。

CCoT 的启发是：

更稳的路线不是简单替换，而是显式设计一个“压缩 CoT 到 token/embedding”的训练目标。

例如：

1. teacher 生成完整 CoT；
2. compressor 把 CoT 压成若干 latent / dense tokens；
3. student 只看到问题 + compressed tokens，预测最终答案；
4. 通过答案 loss、对比学习 loss、重构 loss 或 distillation loss 让 compressed tokens 保留足够推理信息。

这比“全部换成同一个 token 然后 SFT”更接近可控、可解释、可优化的研究方案。

#5. Hidden Chain-of-Thought：把显式 CoT 变成特殊压缩表示

#5.1 Expediting and Elevating LLM Reasoning via Hidden Chain-of-Thought Decoding（2024）

• 论文：Expediting and Elevating Large Language Model Reasoning via Hidden Chain-of-Thought Decoding
• arXiv：2409.08561
• 核心想法：训练一个辅助 CoT 模型，把完整思考过程压缩成 compact special token representation，再让 HCoT 模型基于这个隐藏表示预测答案。

这篇的摘要说得很清楚：

• 生成完整 CoT 会导致输出序列很长，推理成本高；
• 他们用 semantic alignment 压缩 CoT；
• 辅助 CoT 模型学习生成与 ground-truth CoT 对齐的 compact special token representation；
• HCoT 模型在 prefix instruction + compressed CoT representation 条件下生成答案；
• 在数学推理、agent invocation、问答任务上达到接近或更好的效果，同时 decoding time 至少 1.5x speedup。

#5.2 对你想法的启发

这条路线和你的想法的差别在于：

• 你设想的是“统一 token 反复输出”；
• HCoT / CCoT 更偏向“特殊 token representation 承载压缩语义”。

如果把你的想法增强一下，可以变成一个更强研究问题：

能不能让一串表面相同的 token，在 hidden state 上表示不同的压缩推理状态？

这比“一个 token 代表所有 think”更准确。因为严格说，模型不是把所有思考压进 token id，而是压进每个位置的 hidden state / KV cache。

#6. Coconut：干脆不在语言空间思考，在连续潜空间思考

#6.1 Training Large Language Models to Reason in a Continuous Latent Space（Coconut, 2024）

• 论文：Training Large Language Models to Reason in a Continuous Latent Space
• arXiv：2412.06769
• 作者：Shibo Hao, Sainbayar Sukhbaatar, DiJia Su, Xian Li, Zhiting Hu, Jason Weston, Yuandong Tian
• 核心想法：不用自然语言 token 表示中间推理，而是把模型上一步的 last hidden state 直接作为下一步输入 embedding，形成 continuous thought。

Coconut 的核心观点是：

自然语言不一定是最适合推理的空间。很多词只是为了文本连贯，不一定是推理必需；而某些关键决策需要规划和搜索，离散语言 token 可能迫使模型过早承诺一条路径。

它的方法可以理解为：

传统 CoT：
问题 -> 生成语言 step1 -> 生成语言 step2 -> 答案

Coconut：
问题 -> hidden thought 1 -> hidden thought 2 -> 答案

区别是，hidden thought 不被 decode 成具体词，而是作为连续向量直接喂回模型。

#6.2 实验中与 pause token 的比较

Coconut 论文中有一个很重要的表格，比较了 CoT、No-CoT、iCoT、Pause Token、Coconut 等。在 GSM8K、ProntoQA、ProsQA 上，Coconut 在某些逻辑/规划任务上显著优于 No-CoT 和 Pause Token，并且 token 数更少。

其中一个关键现象是：

Continuous thought 可能允许模型在一个 latent state 中保留多个候选下一步，表现出类似 breadth-first search 的行为，而语言 CoT 往往必须一次采样一个 token，容易过早走上一条路径。

这点和你的兴趣非常相关：如果我们关心 long-horizon agent、model-based RL、latent-space reasoning，那么真正有价值的不是“让模型输出更多看不见的 token”，而是：

让模型在潜空间中维护一个可更新的任务状态 / belief state / search frontier。

#6.3 对你想法的启发

Coconut 会提醒我们：

• 如果 token id 永远相同，语义容量主要来自 hidden state；
• 与其训练模型输出同一个离散 token，不如直接训练 continuous latent step；
• 但 continuous latent step 工程上更难，因为它改变了标准自回归 token 接口，不像 repeated τ 那样容易兼容现有 serving。

因此你的方案有一个现实优势：它兼容现有 LLM 推理框架。它不需要改模型 forward 接口，只需要新 token + 数据/训练。

#7. Continue-Thinking Token / Wait：从“思考压缩”转向“控制继续想多久”

#7.1 s1: Simple test-time scaling（2025）

• 论文：s1: Simple test-time scaling
• arXiv：2501.19393
• 核心贡献之一：budget forcing。

s1 的做法很简单：如果模型太早结束 thinking，就在生成中追加 Wait，强迫它继续想；如果超预算，就强行终止。

这说明一个重要事实：

某些普通自然语言 token，例如 Wait，在 reasoning model 中已经可以起到“继续思考”的控制作用。

但 Wait 本身不是一个被专门训练的 latent token，它更多是一个 prompt/decoding trick。

#7.2 Learning a Continue-Thinking Token for Enhanced Test-Time Scaling（2025/2026）

• 论文：Learning a Continue-Thinking Token for Enhanced Test-Time Scaling
• arXiv：2506.11274
• 核心想法：给 distilled DeepSeek-R1 增加一个单独的 <|continue-thinking|> token，只训练这个 token 的 embedding，其他模型参数冻结，用 RL 学会触发 extended reasoning。

这篇非常有意思，因为它几乎就是：

“能不能学习一个专门的继续思考 token，而不是手写 Wait？”

论文报告：

• learned token 相比 baseline 和固定 Wait budget forcing，在若干数学 benchmark 上更好；
• 在 GSM8K 上，固定 Wait 带来约 1.3% absolute improvement，而 learned token 带来约 4.2% improvement；
• 但它也发现：如果固定 token 本来就不能改善某个设置，learned token 往往也没有显著收益。

#7.3 对你想法的启发

这条线回答的是另一个问题：

不是把 CoT 内容压成 token，而是用一个 token 控制模型“继续思考”。

它和你的方案的关系是：

• 你的 τ 可以是 思考占位 token；
• <|continue-thinking|> 更像 控制 token，告诉模型别停，继续展开；
• 二者可以结合：τ 负责提供 latent workspace，controller 负责决定继续多少步。

这对 Agent 尤其重要：不是每个状态都需要同样长的 think token。真正好的系统应该会动态分配计算预算。

#8. Soft Thinking：不用单个离散 token，而用连续概念 token

#8.1 Soft Thinking: Unlocking the Reasoning Potential of LLMs in Continuous Concept Space（2025）

• 论文：Soft Thinking: Unlocking the Reasoning Potential of LLMs in Continuous Concept Space
• arXiv：2505.15778
• 核心想法：生成 soft abstract concept tokens，这些 token 是多个 token embeddings 的概率加权混合，而不是某一个离散词。

它的动机和 Coconut 类似：离散 token 迫使模型每一步只能选择一个词，而连续概念 token 可以表达多个相关含义的混合。

这和你的想法的差别是：

• 你的 τ 是单一离散 token；
• Soft Thinking 的“token”在 embedding 空间里是 soft mixture；
• 它试图让每个 thinking step 的表示本身更有表达力。

不过后续也有工作质疑 soft thinking 是否真的并行探索多条路径，说明这个方向仍在早期。

#9. Sentinel Tokens / Pause-Tuning：特殊 token 也可以用于长上下文信息聚合

你的想法主要是 reasoning，但还有一条相邻线：用特殊 token 聚合上下文。

#9.1 Taking a Deep Breath: Sentinel Tokens（2024）

• 论文：Taking a Deep Breath: Enhancing Language Modeling of Large Language Models with Sentinel Tokens
• arXiv：2406.10985
• 方法：把文本分成 chunks，在每个 chunk 后插入 <SR> token，并修改 attention mask，让 <SR> 聚合该 chunk 的信息。

这不是 CoT 压缩，但说明特殊 token 可以成为“信息汇聚点”。

#9.2 Pause-Tuning for Long-Context Comprehension（2025）

• 论文：Pause-Tuning for Long-Context Comprehension: A Lightweight Approach to LLM Attention Recalibration
• arXiv：2502.20405
• 方法：在长上下文中人工插入 pause tokens，微调模型，让它重新分配注意力，缓解 lost-in-the-middle。
• 报告结果：LLaMA 3.2 3B Instruct 和 LLaMA 3.1 8B Instruct 在 Needle-in-a-Haystack 上平均提升约 10.61% 和 3.57%。

这条线对你的启发是：

特殊 token 不一定只用于“多算几步”，也可以作为 attention / memory / summary anchor。

如果把它迁移到 Agent，就是在长轨迹中插入特殊 latent state token，压缩前面若干步工具调用、观察、失败原因、当前计划。

#10. 回到你的原始方案：直接把 CoT 全部替换成统一 token，会发生什么？

我们可以把方案拆成几个版本。

#10.1 版本 A：最朴素替换

Question + full CoT + Answer
变成：
Question + τ τ τ ... + Answer

然后 SFT。

这个版本的优点：

• 实现简单；
• 完全兼容现有自回归训练；
• inference 时可用 τ 数量控制计算预算；
• 不泄露 CoT，输出更短、更安全。

但缺点也明显：

1. 语义监督被抹掉了。 原本每一步 CoT 都给模型提供中间目标；替换成同一个 token 后，模型只知道“这里要输出 τ”，不知道每个 τ 应该承载什么。
2. 训练 loss 可能太弱。 τ 的 token prediction 很容易学，只要一直输出同一个 token；真正难的是最后答案。最终答案 loss 是否足以反向塑造所有 τ hidden states，不一定。
3. 模型可能学会空转。 它可以把 τ 当作格式要求，而不是工作区。
4. 长度分配没有依据。 原始 CoT 多长，不一定等于真正需要多少 latent compute。
5. 可解释性下降。 你不知道 τ 内部是不是真在思考，还是只是延迟。

#10.2 版本 B：pause-pretraining + CoT replacement SFT

先在继续预训练中让模型习惯：

文本片段 -> <pause>... -> 下一个 token

再做：

Question -> τ... -> Answer

这更接近 Pause Tokens 论文中有效的设置。它让模型先学会利用 dummy tokens 做 delayed next-token prediction，再迁移到 reasoning。

#10.3 版本 C：teacher CoT distillation 到 latent token

更强版本：

1. teacher 生成完整 CoT；
2. student 不输出 CoT，只输出 τ；
3. 训练时除了最终答案 loss，还加一些辅助约束：

- hidden states 对齐 teacher CoT hidden states；

- 用 probe 从 τ hidden states 重构关键中间变量；

- contrastive loss：正确 CoT 压缩表示接近，错误 CoT 远离；

- process reward：不同阶段的 latent state 能支持下一步判断。

这个版本才真正接近：

把显式 CoT 内化为隐藏推理状态。

#10.4 版本 D：latent recurrent / continuous thought

不再要求输出同一个离散 token，而是让模型把上一步 hidden state 直接喂回去，类似 Coconut。

优点是表达力更强；缺点是要改模型推理接口，不如统一 token 工程上方便。

#11. 为什么“同一个 token”仍然可能承载不同思考？

一个常见误解是：如果 token id 一样，那每一步信息不就一样了吗？

不是。

第 t 个 τ 的输入 embedding 中 token embedding 部分相同，但它的 hidden state 取决于：

• 位置编码；
• 前面所有 prompt tokens；
• 前面所有 τ 的 hidden states；
• attention pattern；
• layer-by-layer transformation。

因此：

τ_1 hidden state ≠ τ_2 hidden state ≠ τ_3 hidden state

真正的信息在 hidden states / KV cache 里，而不是 token id 里。

这就像你在草稿纸上每一行都画同一个符号“□”，但每一行的脑内状态不同。外人看到的都是“□”，模型内部未必相同。

但问题是：

模型会不会自然学会把每一行“□”当作不同草稿？

这需要训练。

#12. 这条线和“隐藏 CoT / 商业 reasoning tokens”的关系

现在很多商业 API 会隐藏 reasoning trace，只返回 final answer，但仍然可能计费 reasoning tokens。相关工作如 CoIn: Counting the Invisible Reasoning Tokens in Commercial Opaque LLM APIs 关注的是如何审计这些不可见 reasoning tokens。

这说明产品层面已经接受了一个事实：

reasoning 不一定要以用户可见自然语言形式暴露。

但商业 API 的 hidden reasoning tokens 未必是你说的“统一 token”。它们可能是：

• 服务器端保留的普通文本 CoT；
• 隐藏通道中的特殊 token；
• 多轮内部采样/搜索；
• verifier / tool / reranker 组合；
• 或者模型 routing + budget 控制。

所以不能直接说“o1/R1 就是统一 think token”。公开研究里，最接近的是 Pause Tokens、CCoT、HCoT、Coconut、continue-thinking token。

#13. 研究脉络总结：从“多算几步”到“潜空间工作区”

#阶段 1：显式 CoT —— 用语言当草稿纸

代表：Chain-of-Thought prompting、STaR、Quiet-STaR、R1 类 reasoning traces。

核心优势：

• 可监督；
• 可读；
• 易通过 SFT/RL 学；
• 能把复杂任务拆成步骤。

核心问题：

• token 成本高；
• 慢；
• CoT 未必忠实；
• 容易啰嗦；
• 不一定是最适合推理的表示空间。

#阶段 2：Pause / Wait —— 给模型额外 test-time compute

代表：Pause Tokens、s1 budget forcing、continue-thinking token。

核心优势：

• 简单；
• 兼容标准 decoder；
• 可控制预算；
• 可以让模型多检查、多修正。

核心问题：

• 不保证 token 内部有内容；
• 可能只是延迟；
• 需要训练模型利用这些 token；
• 固定预算容易 overthinking / underthinking。

#阶段 3：Compressed / Hidden CoT —— 把语言草稿压缩成隐藏表示

代表：Hidden CoT、Compressed Chain of Thought。

核心优势：

• 试图保留 CoT 的语义监督；
• 推理更快；
• 可以降低可见 token 成本；
• 更接近“压缩思考”。

核心问题：

• 训练复杂；
• 压缩表示是否忠实难验证；
• 如果压缩过强，可能丢掉关键中间变量；
• 需要设计对齐/重构/最终任务 loss。

#阶段 4：Continuous / Latent Thought —— 不再执着于语言 token

代表：Coconut、Soft Thinking、SoftCoT 等。

核心优势：

• 表达空间更自由；
• 可能避免语言 token 的过早承诺；
• 更适合规划、搜索、belief state；
• 与 model-based RL / latent world model 更自然衔接。

核心问题：

• 工程接口不标准；
• 训练不稳定；
• 可解释性更差；
• 很难证明 latent state 真的在做想象/搜索。

#14. 对你这个想法的可行性判断

#14.1 我认为“能达到一部分预期”

如果目标是：

让模型在答案前多做一些不可见/低可见的计算，并且用 token 数控制计算预算。

那么可以。Pause Tokens 和 continue-thinking token 已经说明这件事有可行性。

#14.2 但“直接替换所有 CoT 为同一个 token”大概率不是最优

因为它丢掉了 CoT 中最宝贵的监督：中间推理结构。

更准确地说，它把训练信号从：

每一步应该怎么推

降级成：

这里应该等多少步，最后答案是什么

这可能对简单任务够用，但对复杂数学、代码 Agent、长轨迹任务，最终答案 loss 太稀疏，难以训练出可靠 latent reasoning。

#14.3 更有研究价值的问题是：如何让统一 token 的 hidden state 变成 decision-sufficient state

我觉得最有潜力的表述不是：

一个 token 能不能代表思考？

而是：

一串表面相同的 token，能不能通过训练形成一系列 decision-sufficient latent states，使最终答案/下一步行动只依赖这些压缩状态即可？

这就和你的长期兴趣连接上了：

• LLM Agent 的长轨迹不可能全部显式保留；
• model-based RL 需要 latent state / imagined rollout；
• code agent 需要把观察、测试失败、代码结构压缩成当前任务状态；
• 潜空间推理关心的正是“语言之外的思考表示”。

#15. 如果要做实验，我建议的最小可行路线

#15.1 实验 1：朴素 CoT replacement baseline

数据：GSM8K / MATH / simple code reasoning。

构造：

<question>
<think> τ τ τ ... τ </think>
<answer> final answer </answer>

其中 τ 数量可以等于原始 CoT token 数的压缩比例，例如：

• 1:1：每个 CoT token 替换一个 τ；
• 1:4：每 4 个 CoT token 替换一个 τ；
• 固定预算：统一 32/64/128 个 τ。

对照组：

• No-CoT SFT；
• Full-CoT SFT；
• Short-CoT SFT；
• Pause token only，不来自 CoT 长度；
• Wait budget forcing。

看：最终准确率、token 数、不同 τ 数量下的 scaling curve。

#15.2 实验 2：预训练是否必要

对照：

1. base model 直接 SFT τ-CoT；
2. base model 先做 pause continued pretraining，再 SFT；
3. instruction model 直接 SFT；
4. reasoning model 直接 SFT。

核心问题：

模型是否必须先学会 delayed next-token prediction，才能利用 τ？

这是 Pause Tokens 论文留下的关键点。

#15.3 实验 3：hidden state 是否真的包含中间变量

不要只看最终准确率。要 probing：

• 对数学题，probe τ_i hidden state 是否能预测中间数值；
• 对图/逻辑题，probe 是否能预测当前节点、候选路径、未满足条件；
• 对代码任务，probe 是否能预测 bug location、下一步 action、测试失败原因。

如果 probe 发现 τ hidden states 中没有中间信息，那说明模型只是空转或靠 final answer memorization。

#15.4 实验 4：teacher hidden state distillation

更强训练：

• teacher 用 full CoT 生成；
• student 用 τ 生成；
• 对齐 student 的 τ hidden states 与 teacher 某些 CoT span 的 pooled hidden states；
• 或者训练一个 decoder 从 τ hidden states 重构 teacher CoT 的摘要/关键变量。

这可以验证：

显式 CoT 的计算能否被压缩进统一 token 位置的隐藏状态。

#15.5 实验 5：Agent 版本

对长轨迹 Agent，可以把每一段观察-行动-反馈压缩为 latent memory token：

obs_1, action_1, result_1 -> τ_state
obs_2, action_2, result_2 -> τ_state
...
当前决策 -> next action

评价不只是 final success，还包括：

• 下一步 action accuracy；
• 是否减少上下文长度；
• 是否提升长轨迹恢复能力；
• 是否能在失败后压缩出正确 diagnosis。

这比数学题更贴近你关心的 LLM Agent / model-based RL。

#16. 关键开放问题

#16.1 统一 token 的容量到底在哪里？

不是 token id，而是：

• hidden state；
• KV cache；
• position-wise dynamics；
• attention 对前文的重新读取；
• 后续 token 对这些 hidden states 的使用方式。

所以研究时不要问“一个 token id 能表达多少信息”，而要问：

一串同 token 不同位置的 hidden states，能形成多大有效计算容量？

#16.2 训练信号够不够？

最终答案 loss 很稀疏。要让 latent token 真学到推理，可能需要：

• process supervision；
• teacher distillation；
• verifier reward；
• intermediate probing loss；
• curriculum：先部分替换 CoT，再完全替换。

#16.3 预算怎么动态分配？

固定输出 100 个 τ 会导致：

• 简单题 overthinking；
• 难题 underthinking；
• agent 长轨迹中计算分配不合理。

需要 controller：

• 什么时候开始 think；
• 生成多少个 τ；
• 什么时候停止；
• 是否展开多条 latent branch；
• 是否调用工具/搜索/验证。

这就是 adaptive test-time compute。

#16.4 怎么证明它真的在思考？

必须做因果验证：

• 删除某些 τ hidden states，性能是否下降？
• shuffle τ states，性能是否变化？
• 替换为其他题的 τ states，答案是否被污染？
• 从 τ state probe 出中间变量是否和正确推理一致？
• 干预某个中间变量方向，最终答案是否改变？

否则很容易只是“看起来在思考”。

#17. 我对这个方向的研究判断

我觉得这个方向值得做，但要避开一个坑：

不要把 novelty 放在“把 CoT 换成同一个 token”这个表面操作上；要放在“如何训练、验证、控制一串不可读 latent working states”上。

最有潜力的研究切口可能是：

#17.1 Decision-Sufficient Latent Thought Token

目标不是重构完整 CoT，而是压缩出对最终决策足够的信息。

这非常适合 Agent：agent 不需要把所有历史都说出来，只需要保留对下一步行动有用的状态。

#17.2 From CoT Compression to Agent State Compression

数学 CoT 是线性推理；Agent 轨迹是观察、工具、失败、修正、环境状态的混合。你可以把 τ 从“思考 token”推广成“任务状态 token”。

#17.3 Model-Based Latent Rollout Token

在 model-based RL 里，agent 会在内部想象未来。LLM Agent 也可以用 τ 表示 imagined rollout：

当前状态 -> τ_rollout_1 -> τ_rollout_2 -> τ_rollout_3 -> action

外部不显示每个 imagined state，但训练时用环境反馈/RLVR/teacher rollout 约束。

#17.4 Faithfulness / Causality Benchmark for Hidden Reasoning

现在很多 latent reasoning 工作缺少强因果验证。可以设计 benchmark：要求 hidden token 中必须保存某些可干预变量，否则无法完成任务。

#18. 代表论文列表

#19. 最后总结

你的想法可以成立，但要精确定义：

不是“一个 token 本身包含思考”，而是“一串相同 token 对应的不同 hidden states，为模型提供额外计算步和隐式工作区”。

已有研究已经证明：

1. <pause> token 可以带来额外计算收益，但最好在预训练和微调阶段都加入；
2. Wait / continue-thinking token 可以控制 reasoning model 继续想；
3. CoT 可以被压缩成 hidden / dense / continuous representations；
4. 潜空间推理可能在规划/搜索任务上比自然语言 CoT 更有优势；
5. 但简单把 CoT 文本替换成同一个 token，大概率会丢掉中间监督，需要更强的 distillation、probing、RL 或 curriculum。

如果要把它变成研究，我建议标题不要叫“统一 think token 替换 CoT”，而可以叫：

Learning Decision-Sufficient Latent Thought Tokens for Efficient Reasoning and Agent Planning

或者更偏 Agent：

Latent Working Tokens: Compressing Long-Horizon Agent Trajectories into Decision-Sufficient Hidden States

这会比单纯的 CoT token 替换更基础、更有延展性，也更贴近你关心的 model-based RL、latent-space reasoning 和长轨迹 Agent。