21 Algorithm of Thoughts (AoT)：用一条上下文，教会 LLM 自己走迷宫

LIUDAN'S WORLD

231人浏览 · 2026-05-17 14:11:49

LIUDAN'S WORLD · 2026-05-17 14:11:49 发布

Algorithm of Thoughts (AoT)：用一条上下文，教会 LLM 自己走迷宫

阅读提示：本文约 1.2 万字，包含 6 张 Mermaid 架构图与 2 段结构化伪代码。建议先通读「玩具示例」建立直觉，再进入机制拆解。如果你曾在 CoT 和 ToT 之间感到纠结——前者太线、后者太贵——那这篇文章就是为你写的。

0. 从一个抓狂的瞬间说起

想象你正在玩「24 点」。手牌是 8, 6, 4, 4。目标是：用加减乘除和括号，让结果等于 24。

如果我们把这个问题丢给三种不同的 AI，会发生什么？

选手 A：标准 Prompt（Direct Prompting）
它直接吐出答案：8 * (6 - 4) + 4 = 20……错了。没有过程，没有检查，错了就错了，像考试铃响前胡乱填涂答题卡的考生。

选手 B：Chain-of-Thought（CoT）
它开始自言自语：「我先试试 8 + 6 = 14，然后 14 + 4 = 18……不对。再试试 8 * 6 = 48，48 / 4 = 12，再加 4 是 16……还是不对。」它很诚实，把每一步都写出来，但路径只有一条——一旦走进死胡同，就只能硬着头皮继续，或者祈祷最后一步能奇迹般绕回来。听起来像不像在迷宫里闭着眼睛摸墙走？

选手 C：Tree-of-Thought（ToT）
它变聪明了：「第一步我有三个选择：8+6、86、64。让我分别算下去。」它真的开了三个并行线程，像派出三支探险队。但代价是——每探索一个节点，就要重新调用一次 LLM。一个 24 点问题可能需要 20～50 次 API 调用。推理质量上去了，钱包和延迟却崩溃了。

那么，有没有一种方法，能像 CoT 一样只发一次请求，又像 ToT 一样在脑子里（而不是在服务器上）开多条分支、还能随时回溯？

这就是我们今天要一起探索的 Algorithm of Thoughts（AoT）。别急，听起来抽象对吧？我们一步一步来。

1. 宏观视角：AoT 到底在解决什么问题？

1.1 先画一张大地图

如果把 LLM 的推理策略看成「从起点到终点的导航方式」，那么目前的主流方法可以画成下面这张图。注意看，AoT 占据了一个非常独特的生态位：

我们怎么理解这张图？

CoT 是「单行道」：一条路走到黑，没有回头路。
ToT 是「立交桥网络」：可以分叉、可以回溯，但每上一条新路都要交过路费（一次 LLM 查询）。
AoT 是「在单行道里模拟立交桥」：它只开一次车（单次查询），但司机的脑子里装着整张地图，遇到岔路口时，它会在同一个对话窗口里「假装」自己正在探索 A 路，评估完发现不通，再「倒退」回来探索 B 路——所有动作都在一次生成中完成。

1.2 核心洞察：LLM 的上下文就是「工作记忆」

AoT 的底层假设非常大胆：LLM 的上下文窗口（context window）本身就是一个足够大的「工作记忆」空间。如果我们能在 prompt 里教会它一种「算法式的思考模板」，它就能在这个空间里自我调度，而不需要外部控制器反复插嘴。

换句话说，CoT 让模型「写日记」，ToT 让模型「开视频会议」（多次拉人进来讨论），而 AoT 让模型「在日记本上画流程图」——自己框定步骤、自己打勾叉、自己画箭头回溯。

在上图里，ToT 的每个节点都对应一次独立的 LLM API 调用；而 AoT 的所有节点都挤在同一次生成流里，靠模型自己维护「当前走到哪了」「哪些分支已经标记为红色（死路）」。

2. 中观视角：AoT 的四大齿轮

现在我们已经了解了 AoT 的「整体功能定位」——单次查询内的算法化推理。接下来我们把它拆开，看看内部到底由哪些齿轮咬合而成。

别急，我们不会直接扔定义。先问你一个问题：如果你要在一张纸上手写一个 DFS（深度优先搜索）算法，你会怎么组织信息？

大概率你会写：

当前走到哪个节点了；
这个节点有哪些邻居还没试；
试完一个邻居后，判断是不是死路；
如果是死路，画个叉，退回上一个节点，换下一个邻居。

AoT 的 prompt 设计，本质上就是把这套「手写 DFS 的纸面格式」编码成 in-context example，让 LLM 照葫芦画瓢。

根据 Sel et al. (2024) 的原始论文，AoT 可以拆成四个相互咬合的组件。我们用一个「玩具示例」来把它们具象化。

2.1 玩具示例：3 个数字的简化 24 点

假设问题被简化成：用 2, 3, 4 得到 6。允许加减乘除。

人类算法式思考过程可能是这样的：

第一步：选择两个数操作
├── 尝试 2 + 3 = 5，剩余 [5, 4]
│   └── 5 + 4 = 9 ≠ 6  → 标记为 X，回溯
├── 尝试 2 * 3 = 6，剩余 [6, 4]
│   └── 6 - 4 = 2 ≠ 6  → 标记为 X，回溯
│   └── 6 + 4 = 10 ≠ 6 → 标记为 X，回溯
│   └── 6 / 4 = 1.5 → 不行，回溯
├── 尝试 3 * 4 = 12，剩余 [12, 2]
│   └── 12 / 2 = 6 == 6 → 标记为 ✓，成功！

注意这里发生了什么：我们在一条连续的文本流里，完成了「探索→评估→回溯→再探索」的闭环。没有开新线程，没有重启对话，只是不断在纸上追加记录。

AoT 就是把这种「纸面记录风格」变成 prompt 里的示例。

2.2 四大齿轮详解

齿轮 1：子问题分解（Decomposition）

问题驱动：面对 2, 3, 4 这三个数，我们不会一口吞下去对吧？我们会本能地想：先挑两个数算一下，把问题变成「两个数怎么得到 6」。

AoT 的 in-context example 会明确展示这种分解：「首先，从当前集合中选择两个数进行运算，将结果放回集合，使集合大小减 1。」这听起来像 RNN 的「时间步」概念——每个时间步处理一个子问题，把状态（剩余数字集合）传递到下一步。

齿轮 2：候选生成（Proposal / Branching）

问题驱动：分解完后，我们面临什么？选择困难症。2 和 3 可以相加、相减、相乘、相除。该试哪一个？

在 AoT 的示例里，这一步被写成：「可选操作：2+3=5, 2-3=-1, 2*3=6, 2/3=0.67」。关键技巧是：示例不会替模型做选择，而是展示「把所有合法选项列出来」的格式。这就像全连接层把所有特征都摊平，让后续层去加权——AoT 把所有候选分支都摊平在上下文里，让模型的「下一 token 预测」去决定先深入哪一个。

齿轮 3：启发式评估（Evaluation / Heuristic Pruning）

问题驱动：如果我们已经试了 2+3=5，接下来 5 和 4 怎么都凑不出 6。人类会在脑子里快速估算：「5 和 4，最大是 9，最小是 1，不可能到 6 吗？等等，5+4=9, 5-4=1, 5*4=20, 5/4=1.25，确实没有 6。」然后果断放弃这条分支。

AoT 的示例会展示这种「快速心算」的文本格式：「评估：剩余数字 [5, 4]，目标 6。所有组合结果：{9, 1, 20, 1.25}，均不等于 6。判定：死路。执行回溯。」

注意这里的精妙之处：模型没有被要求调用外部计算器，而是被引导在上下文里做「符号级的心算」。这降低了延迟，但也对模型的算术能力提出了要求（原始论文使用 GPT-4 进行实验，部分原因就在于此）。

齿轮 4：回溯与路径选择（Backtracking & Selection）

问题驱动：判定死路后，我们怎么办？擦掉这一步，回到上一个分叉口，换一条路。

在 AoT 的生成中，这一步被文本化为：「回溯到上一层。已尝试 2+3，标记为 X。接下来尝试 2*3。」

 渲染错误: Mermaid 渲染失败: Parse error on line 4: ...n TB S0[状态: [2,3,4] 目标: 6] -->|选 ----------------------^ Expecting 'SQE', 'DOUBLECIRCLEEND', 'PE', '-)', 'STADIUMEND', 'SUBROUTINEEND', 'PIPE', 'CYLINDEREND', 'DIAMOND_STOP', 'TAGEND', 'TRAPEND', 'INVTRAPEND', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got 'SQS'

在上图里，所有箭头都是文本层面的箭头——它们不是外部控制器的函数调用，而是模型自己生成的字符串「→ 回溯到上一层」。换句话说，LLM 在「玩角色扮演」：它扮演的角色是一个正在执行 DFS 的算法，而剧本（prompt）已经告诉它每一幕该怎么写。

3. 微观视角：上下文里的一维「时空折叠」

现在我们已经了解了四大齿轮。接下来进入最微妙的部分：这些齿轮如何在单次生成中咬合？

3.1 如果画成向量/矩阵，会是什么样子？

我们知道，LLM 的每一次生成都是「基于前面所有 token 的注意力加权」。如果把 AoT 的上下文看成一个矩阵，每一行是一个「认知步骤」，那么它的注意力模式会非常特殊：

在标准 CoT 里，注意力几乎是「单向流动」的：t=1 → t=2 → t=3 → …，像瀑布一样。但在 AoT 里，每当出现「回溯」字样时，模型的注意力会重新聚焦到更早的上下文节点（如 t=1 的问题状态）。这是一种在一维序列中模拟二维树遍历的技巧——论文作者称之为「contextual folding（上下文折叠）」。

3.2 从 toy example 推广到真实规模

在玩具示例里，我们只有 3 个数字，搜索深度只有 2 层。但在真实的 24 点问题里（4 个数，深度 3），分支因子和深度都变大了。AoT 怎么应对？

答案是：in-context example 的「算法骨架」保持不变，只是填充的「数据」变大了。

就像你写了一个 RNN cell，在时间步 1 处理词向量 x₁，在时间步 t 处理 x_t——cell 的结构不变，输入的序列长度可以变。AoT 的 prompt 设计也是如此：它展示的是一个元算法（meta-algorithm），而不是某个具体问题的解法。

原始论文中，AoT 的示例通常只给 1 个 in-context example（对比 CoT 的 3～8 个 few-shot），但这个 example 非常长，因为它要完整展示一次 DFS 或 BFS 的「心路历程」。

4. 结构化伪代码：AoT 的算法内核

好了，直觉和比喻已经够多了。在继续之前，让我们把 AoT 的核心流程翻译成结构化伪代码。这会帮助我们把「聊天式的理解」锚定到精确的算法步骤上。

4.1 高层流程：Prompt 构建阶段

这段伪代码描述的是我们（人类工程师）在调用 LLM 之前，如何构造 AoT prompt：

Algorithm: Construct_AoT_Prompt
Input: 任务描述 T, 算法模板 A ∈ {DFS, BFS, Best-First}, 示例问题 P<sub>ex</sub>
Output: 完整 Prompt 字符串 S

1.  S ← 系统指令("你是一个遵循算法步骤的推理引擎。")
2.  S ← S + 任务描述 T
3.  S ← S + 算法模板 A 的文本化规则:
       while 未到达终止状态 do
           生成当前状态的所有合法操作候选 C ← Generate_Candidates(状态)
           if C = ∅ then
               标记当前路径为死路
               执行 Backtrack(上下文)
               continue
           end
           按启发式排序 C（可选）
           for each c ∈ C do
               应用操作 c，得到新状态 S<sub>new</sub>
               评估 S<sub>new</sub> 的启发式分数 h(S<sub>new</sub>)
               if h(S<sub>new</sub>) = 目标值 then
                   返回成功路径
               end
               if h(S<sub>new</sub>) 表明不可行 then
                   标记 c 为 X，在上下文中记录 "回溯"
               else
                   深入 S<sub>new</sub>（递归/栈推进）
               end
           end
       end
4.  S ← S + 完整示例 P<sub>ex</sub> 的逐步推演记录
       // 注意：示例必须包含至少一次死路评估和一次回溯
5.  S ← S + 待解问题 P<sub>new</sub> 的初始状态
6.  return S

关键点：第 4 步的示例不是只给正确答案，而是像教学一样，故意展示一条死路和如何纠正。这类似于强化学习中的「失败案例回放」，让模型学会「什么情况下该放弃」。

4.2 运行时流程：LLM 的生成阶段

这段伪代码描述的是LLM 拿到 Prompt 后，在单次生成中「自我执行」的过程。注意：这不是外部代码，而是模型在生成 token 时隐式遵循的「心理剧本」：

Algorithm: AoT_Runtime
Input: Prompt S（包含算法规则与示例）
Output: 推理轨迹 R 与最终答案

1.  初始化上下文窗口 C ← S
2.  初始化隐式栈 Stack ← [初始状态]
3.  while Stack ≠ ∅ 且 生成长度 < 最大 token 限制 do
       当前状态 s ← Stack.top()

       // 步骤 A：候选生成
       基于 C 中的规则，生成候选集 Candidates(s)

       // 步骤 B：评估与剪枝
       对 each cand ∈ Candidates(s) do
           在 C 中追加 "尝试: cand"
           计算/估算结果值 v ← Evaluate(cand)

           if |v - 目标| < ε then
               C ← C + "成功! 最终答案 = cand"
               return 提取 C 中的答案路径
           end

           if v 超出可行域 或 明显远离目标 then
               C ← C + "评估: 不可行 (v = " + str(v) + ") → 标记 X"
               C ← C + "执行: 回溯到状态 s"
               // 注意：这里不修改 Stack，只是文本声明
           else
               C ← C + "评估: 有潜力 (v = " + str(v) + ") → 继续深入"
               Stack.push(新状态 s<sub>new</sub>)
               break  // 深度优先：只选一个深入
           end
       end

       // 步骤 C：回溯触发
       if 所有 cand 都被标记 X then
           Stack.pop()
           C ← C + "栈弹出: 返回上一层"
       end

       // 步骤 D：注意力重聚焦（隐式）
       模型注意力重新加权 C 中更早的「分叉点」token
       // 这由 Transformer 的自注意力机制自动完成
   end
4.  if Stack = ∅ then
       return "无解"
   else
       return 从 C 中提取的最终答案

啊哈时刻来了：注意第 3 步里的 Stack——它并不是 Python 里的 list，而是模型在上下文中通过文本字符串维护的「虚拟栈」。当模型写「执行：回溯到状态 [2,3,4]」时，它实际上是在强制自己的注意力重新聚焦到那个位置的上下文。这是一种「用文本协议模拟数据结构」的元认知技巧。

5. 视觉对比：AoT vs. CoT vs. ToT 的「时空结构」

现在我们已经了解了 AoT 的内核。为了让你对三种方法的区别有一个「肌肉记忆」级别的理解，我们用三张并排的 Mermaid 图来展示它们在「时间-空间」中的展开方式。

5.1 CoT：一维线性流

特征：时间轴 = 推理深度。没有空间分支。像 RNN 的隐藏状态传递：h_t = f(h_t-1, x_t)。

5.2 ToT：二维树，多次查询

特征：空间上是一棵树，但每个节点都是一次独立的 LLM API 调用。外部控制器（Python 脚本）维护树结构，LLM 只负责生成单个节点内容。时间（延迟）和计算成本随分支数线性增长。

5.3 AoT：一维序列模拟二维树

特征：表面上是一条时间线（t=1 到 t=16），但文本内容中嵌入了「回溯」指令，使得注意力在时间上「折叠」回更早的状态。这就像把一张二维的地图（ToT 的树）压缩进了一维的 DNA 双螺旋——信息密度极高，但展开后依然能读出树形结构。

6. 深入机制：为什么 AoT 能在单次查询内「自我纠正」？

6.1 类比全连接层：候选生成是「特征摊平」

在全连接层里，输入特征被摊平成一个向量，然后每个神经元对所有特征做加权求和。AoT 的候选生成阶段非常类似：模型把当前状态的所有合法操作「摊平」成一个文本列表，然后在生成下一个 token 时，本质上是在对这些候选做「softmax 选择」。

不同的是，这个「选择」不是一次性完成的，而是通过自回归生成逐步展开的。模型先写「尝试 8+6=14」，然后评估，发现不行，再写「回溯」。这相当于在神经网络的前向传播中，把某些路径的激活值手动压到接近零（剪枝），然后重新采样。

6.2 类比 RNN：状态传递是「上下文隐状态」

RNN 靠隐藏状态 h_t 传递历史信息。AoT 靠什么？靠上下文中显式写出的状态字符串。当模型写「当前状态：[14, 4, 4]」时，它实际上是在给自己建立一个「文本隐状态」。下一步生成时，这个字符串会被 tokenize 后进入注意力计算，成为「历史信息」的一部分。

这种「文本即状态」的设计有一个巨大好处：状态是可解释的。你可以把模型的中间输出打印出来，直接读到它在想什么。相比之下，RNN 的 h_t 是一团黑盒向量。

6.3 锚定已知：如果你懂 RNN，你就懂了 AoT 的 70%

概念	RNN / 传统神经网络	AoT
时间步	t=1,2,3…	生成序列中的 token 位置
隐藏状态	h_t	上下文中显式写出的「当前状态」文本
状态转移	h_t = tanh(W·h_t-1 + U·x_t)	文本形式的「应用操作 → 新状态」
回溯/遗忘	门控机制（LSTM/GRU）	文本指令「回溯到…」+ 注意力重聚焦
输出	y_t = softmax(V·h_t)	下一个 token 的预测分布

顿悟时刻：AoT 不是在外部写了一个搜索算法去调用 LLM，而是把搜索算法的「控制流」编译进了 prompt，让 LLM 的 next-token prediction 去执行这个控制流。LLM 既是 CPU（执行者），也是 RAM（存储上下文状态），还是硬盘（记录已探索路径）。

7. 变体与演进：从 AoT 到 AoT+

7.1 原始 AoT 的局限性

别急，原始 AoT 并不是完美的。根据后续研究（特别是 AoT+ 论文），它有两个主要痛点：

状态幻觉（State Hallucination）：模型在回溯后，有时会「记错」上一层的状态。比如它应该回到 [8,6,4,4]，却错误地写成了 [8,6,4]。这类似于 RNN 的长程依赖衰减——只不过这里是「文本长程依赖」。
认知过载（Cognitive Load）：当搜索深度超过 5～6 层时，上下文里堆满了「尝试-X-回溯」的记录，模型开始混淆哪些分支已经试过。

7.2 AoT+ 的改进：System 3 Thinking

2025 年初的论文《LLMs CAN PLAN ONLY IF WE TELL THEM》提出了 AoT+，在原始框架上增加了两个机制：

System 3 触发器：当模型检测到「当前状态与目标差距很大」或「连续两次死路」时，强制进入「慢思考」模式，生成更详细的评估文本，而不是匆忙选择下一个分支。
状态校验层：每次回溯后，模型被要求在上下文中「复述」上一层的状态，并与历史记录做比对（类似数据库的 checksum）。

实验表明，AoT+ 在 Blocksworld 等规划任务上，成功率从原始 AoT 的约 60% 提升到了 90%+，且依然保持单次查询的优势。

8. 这意味着什么？训练与实际使用

8.1 对 Prompt 工程师的启示

示例质量 > 示例数量：AoT 只需要 1 个精心设计的 in-context example，但这个示例必须包含完整的搜索轨迹（包括失败和回溯）。不要只给正确答案，要给「解题的心路历程」。
格式即算法：prompt 里的缩进、标记符号（如 X、→、[状态]）不是装饰，而是控制流的语法。模型对这些符号的注意力分布会直接影响回溯的准确性。
模型能力门槛：原始论文明确提到，AoT 在 GPT-4 上效果显著，但在较小模型上可能失效。因为小模型的长程注意力较弱，难以在 2k+ token 的上下文里准确执行回溯。

8.2 对系统架构师的启示

在实际系统中，可以把 AoT 放在「中等复杂度」的甜蜜点：比 CoT 更能处理需要试错的问题，比 ToT 更节省延迟和 API 成本。

8.3 对研究者的启示

AoT 揭示了一个深刻的趋势：prompt 工程正在从「数据驱动」（堆更多示例）转向「控制流驱动」（在上下文里嵌入算法）。未来的方向可能包括：

自动编译：把 Python 伪代码自动转换成 AoT 风格的 prompt；
混合架构：让 LLM 在 AoT 的「单查询搜索」和外部工具的「精确计算」之间自动切换；
理论分析：从计算复杂性角度，证明 AoT 在哪些问题类上可以达到与 ToT 相当的搜索覆盖率。

9. 闭环总结：一张图带走所有知识点

让我们用最后一张图，把今天探索的所有内容收束起来：

记住这个闭环：分解 → 生成 → 评估 →（成功/死路/深入）→ 输出或回溯。所有动作都在单次 LLM 调用的上下文窗口里完成。这就是 AoT 的精髓。

10. 延伸阅读与参考文献

如果你想继续深入，以下是我为你精选的国外核心文献，按阅读顺序排列：

Sel, B., Al-Tawaha, A., Khattar, V., et al. (2024). Algorithm of Thoughts: Enhancing Exploration of Ideas in Large Language Models. ICML 2024. citeweb_search:1#4 —— AoT 的奠基论文，包含完整的 24 点、Game of 24 等实验细节。
Yao, S., Yu, D., Zhao, J., et al. (2024). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. citeweb_search:1#0 —— 理解 AoT 的必读物，对比阅读能更清晰地看到 AoT 在「查询效率」上的优势。
Besta, M., et al. (2024). Topologies of Reasoning: Demystifying Chains, Trees, and Graphs of Thoughts. citeweb_search:1#0 —— 系统性地把 CoT/ToT/GoT/AoT 放在「拓扑结构」的框架下分析，非常适合建立宏观视角。
Kambhampati, S., et al. (2025). LLMs CAN PLAN ONLY IF WE TELL THEM. citeweb_search:1#3 —— 提出 AoT+，解决状态幻觉问题，在规划任务上取得 SOTA。
Chen, W., et al. (2022). Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks. citeweb_search:1#15 —— 如果你好奇「把代码逻辑放进 prompt」这个思路的源头，PoT 是重要先驱。