ADHD：给 Coding Agent 装上 Tree-of-Thought 并行推理引擎

CLI 调用 LLM 偶发 90 秒卡死时，该怎么设计重试和超时机制？教科书方案会告诉你：用指数退避加 jitter，设一个绝对超时，再自动重试一次。这个答案挑不出大错，但你可能直觉觉得它少问了一句：慢的真是网络吗，还是模型本身选错了？用户等得越久，按钮是不是应该越烫，甚至能一键转投更快的模型？

ADHD 解决的就是这类问题。它不是让 Agent “再想一想”的 prompt，而是给 AI 编程 Agent 装上的并行推理结构：先让多个互相隔离的分支从不同认知视角同时发散，再让一个单独的 critic 负责打分、聚类、剪掉陷阱、深化幸存者。本篇讲的是这个 skill 的机制、边界和使用判断。

ADHD 是什么（不是 prompt 技巧）

ADHD 的定位很清楚：它试图修复自回归推理里的过早收敛，而不是给 prompt 加一点鼓励词。

自回归模型逐个 token 往下生成。一旦前几步选中了某个方向，后面的内容就会围绕它展开。这个机制很高效，但在开放式工程题里有一个副作用：第一个看起来合理的答案会变成锚点，模型会顺着最常见、最像训练数据的路径滑下去。这个答案经常是教科书式正确答案，也经常漏掉不显而易见但更有价值的选项。

普通 prompt 也能要求模型“列出多个方案再比较”“从不同角度思考”“避免过早下结论”。问题是这些分支仍在同一个上下文里互相污染。模型一边生成一边评估，某个早期方向被写出来后，后续分支很难真正摆脱它。

ADHD 的做法更硬：发散阶段拆成 N 个完全隔离的 Agent SDK 调用，每个分支只看到原始问题、一个认知 frame 和禁止评估的 system prompt。分支之间零共享上下文。评审阶段再由单独的 critic 调用统一打分、聚类、剪枝和深化。

一句话：CoT 让一个脑子想得更慢，Tree-of-Thought 让一个脑子搜得更宽，ADHD 让多个脑子并行地想得不一样，再让评审挑。

两阶段机制：Diverge/Focus 硬墙隔离

ADHD 的核心是两阶段：Phase 1 Diverge 和 Phase 2 Focus。两个阶段中间有一堵硬墙，发散时禁止评估，评估时才允许收敛。

Phase 1 Diverge：N 路并发隔离

第一阶段会选择 N 个认知 frame，默认 N=5，然后并发启动 N 个隔离的 Agent SDK query。每个分支只拿到三样东西：

1. 原始问题。
2. 一个 frame 的视角 prompt，例如用延迟、内存布局、监管、on-call 或反演来重问这道题。
3. 禁止评估、排序、犹豫的 system prompt。

分支之间互不可见。监管审计视角的分支看不到速通玩家分支写了什么，硬件工程师视角的分支也不会被 10 岁小孩视角提前锚定。每个分支都是独立的 stateless session，锚定效应不是靠模型自律压住，而是从结构上被切断。

并发由 semaphore 控制，默认 concurrency=4。Token 成本随分支数线性增长，是 O(N×每分支)，不是 N²，因为后面的分支不会重新读取前面分支的完整内容。

Phase 2 Focus：单独 critic 调用

第二阶段换成一个单独的 critic 调用。它做三件事：

1. score：给每个分支的新颖度、可行性、契合度打 0 到 10 分，陷阱要写出机制化理由。
2. cluster：按底层角度聚类，而不是按关键词粗暴合并。
3. deepen top-K：默认深化 K=3 个幸存方案，补出草图、承重风险、第一步动作和 3 到 5 个子想法。

这个设计的关键是 generator 和 critic 的机械分离。generator 阶段禁止评估，critic 阶段必须评估；它们不是同一会话里的两段口头承诺，而是两次不同的 API 调用。

隔离分支的调用形状大致是这样：

const branches = await Promise.all(
  frames.map((frame) =>
    withSemaphore(concurrency, () =>
      callLLM({
        systemPrompt: `${frame.vantage}\n\nFORBIDDEN: evaluation, ranking, hedging. JSON array out.`,
        userPrompt: `${problem}\n\n${context ?? ""}`,
      }),
    ),
  ),
);

回到开头那道 retry/timeout 题，baseline 容易给出标准 hybrid：15 秒首字超时、30 秒字间超时、90 秒绝对上限，再自动重试一次。ADHD 的价值不在于把这个答案写得更长，而在于可能额外挑出“等待越久按钮越烫，一键取消并转投更快模型”这样的选项，同时把“逆序流式输出 token”“按耐心收费”这类听着新奇但工程上有坑的方案提前标掉。

与 CoT/ToT 的结构对比

维度	Chain-of-Thought (CoT)	Tree-of-Thought (ToT)	ADHD
线程数	单线	单树遍历	N 路并行隔离
共享上下文	yes，全部共享	yes，通常部分共享	no，硬墙隔离
generator/critic	同一会话内同步评估	同一模型交替生成和评估	分阶段、分调用、相反 posture
分支驱动	没有显式分支	下一步变体	认知 frame 重问整题
并行性	无	多数顺序	真并发，semaphore 控制
适合问题	多步逻辑、数学推导	搜索、规划、解谜	开放式工程设计与构思

三条承重差异

第一，ADHD 是隔离而不是搜索。ToT 的分支仍在同一棵树上展开，早期节点会影响后续节点。ADHD 的分支在发散期互不可见，锚定按构造被消掉。

第二，ADHD 用 frame，而不是 next-step 变体。ToT 常常是在“下一步怎么走”里扩展选项；ADHD 是把整道题从另一个认知位置重问一遍。它不是把参数微调一点，而是让模型从延迟、物理约束、监管责任或凌晨 3 点 on-call 的压力里重新看问题。

第三，generator-critic 分离是机械的，不是承诺式的。同一会话里说“先不要评估”仍然容易在生成过程中偷偷比较。ADHD 用不同调用、不同 system prompt 和不同姿态把这件事硬拆开。

还要澄清一点：frame 不是 persona。persona 是“你是某某角色”，frame 是“用某种约束和词汇重问整道题”。前者换身份标签，后者换问题框架。

15 个认知 frame 与自定义方法

ADHD 内置 15 个认知 frame，用来把同一道题扭到不同方向。codeMode 默认偏向代码和设计视角，每次还会保留一个 wild slot，避免发散太规矩。

内置 frame 示例

frame	视角
硬件工程师	用延迟、内存布局、物理约束思考
监管审计	从合规、风险、责任追溯角度思考
10 岁小孩	用最朴素的语言和逻辑思考
试图攻破它的竞品	从对抗视角思考漏洞和弱点
生物学	用进化、生态、代谢约束思考
物流	用供应链、仓储、运输约束思考
游戏设计	用玩家体验、平衡性、反馈循环思考
市场	从定价、竞品、定位角度思考
反演	从结果倒推，假设已经成功
$0 或无限预算	用极端预算约束思考
移除承重假设	去掉你认为理所当然的假设
速通玩家	用最少步骤达成目标
蚁群	用分布式、无中心协作思考
凌晨 3 点 on-call	用紧急、疲劳、资源受限思考
wild slot	保留一个随机视角

选择规则

• 同一个问题和同一个 seed 会确定性地选出同一组 frame，便于复现。
• codeMode 默认偏向 code/design 视角，不会把工程题完全交给无关比喻。
• 每次固定保留一个 wild slot，让系统有机会跳出过于规整的框架。

自定义 frame

自定义 frame 不需要写很长，关键是它要真的改变问题。一个合格 frame 至少满足三条里的两条：

1. 有独特词汇，不只是“多角度思考”。
2. 有独特姿态，例如对抗、建设、天真、极端约束。
3. 有可复现扭曲，每次套上去都能稳定改变推理方向。

例如你可以为订阅产品写一个 frame：

name: subscription_retention
vocabulary: ["订阅", "留存", "流失", "续费", "生命周期"]
stance: "用订阅流失率和生命周期价值思考，而不是一次性交易"
distortion: "假设用户会流失，设计减少流失的机制"

这个 frame 不只是把模型叫成“增长负责人”，而是把问题压到留存、流失和生命周期价值这套约束里。

什么时候该用、什么时候不该用

ADHD 是决策点工具，不是日常逐键工具。最简单的判断是：junior 能 Google 到的，baseline 赢；senior 会说“让我换个角度想一分钟”的时刻，才轮到 ADHD。

适用场景

场景	为什么适用
架构/设计决策	代价高，需要多角度论证，容易遗漏陷阱
API/SDK/CLI 接口设计	用户心智模型多样，需要覆盖不同入口
命名	语义歧义多，不同角色会读出不同含义
模糊调试	根因不明确，需要先生成假设再验证
迁移重构规划	性能、安全、兼容和节奏之间有冲突
扩大 code review	需要模拟不同 reviewer 的关注点
策略定价	商业约束多，适合加入对抗和市场视角

不适用场景

场景	为什么不适用
查事实	单一正确答案，不需要发散
已知根因 bug 修复	因果链已明确，发散会拖慢修复
一搜即得	baseline 更快、更便宜
内层循环/逐键低延迟	30 到 90 秒的延迟不可接受
单一正确答案问题	多分支不会增加有效信息

安装与触发

安装前先做第三方 skill 安全审查。至少看一眼 SKILL.md：它要求 Agent 做什么，会不会调用外部命令，会不会读写你不希望它碰的目录。可以参考 OpenClaw 技能安全审查实战指南 的检查思路。

通用安装

通用安装命令是：

npx skills add UditAkhourii/adhd

它会自动识别 Claude Code、Cursor、Antigravity、Codex、Cline、Gemini CLI、Windsurf 等约 50 种 Agent，并安装对应 skill 文件。

Codex 专用安装

如果通用命令没有把 skill 注册到 Codex，可以强制指定目标：

npx skills add UditAkhourii/adhd -a codex -g

也可以手动安装：

curl -o ~/.codex/skills/adhd/SKILL.md https://raw.githubusercontent.com/UditAkhourii/adhd/main/SKILL.md

手动安装后重启 Codex，让 skill 目录重新加载。

触发方式

触发方式是：

/adhd "问题"

例如：

/adhd "CLI 调用 LLM 偶发 90s 卡死，该怎么设计 retry/timeout/UX？"

不要把它接到每次补全。更合适的用法是在架构、接口设计、命名、模糊调试这类节点上显式触发。

成本与价值

成本数据

维度	数据
LLM 调用次数	约 10 次：N=5 发散 + 1 次打分 + 1 次聚类 + K=3 深化
时间	通常 30 到 90 秒
成本倍数	单发的 5 到 10 倍
Token 成本	O(N×每分支)，线性增长，不是 N²

价值定位

官方给的定位是：用 0.30 美元量级去撬动一个 5 万美元级别的架构决策。这个说法不是让你把每个小问题都跑一遍 ADHD，而是在提醒你，开放式工程决策的错误成本可能远高于一次多分支推理。

真实项目里还要注意上下文成本。在 Claude Code 或类似 Agent 会话里，每个分支可能都会加载基础项目上下文、工具说明和仓库规则。纯算法上是 O(N×每分支)，实际账单更接近 N×(base context + branch work)。所以它适合“该不该这样设计”的节点，不适合“下一行代码怎么补”的节点。

eval 结果解读

ADHD 项目给出了一组自测 eval：6 道开放工程题，同模型，独立 LLM 评审，A/B 顺序随机。这个口径要写清楚，它不是第三方学术基准，也不是人工评测。

五维对比表

维度	ADHD	baseline	提升
breadth（方案宽度）	9.00	4.83	1.9x
novelty（新颖度）	7.83	2.67	2.9x
trap detection（陷阱发现）	9.50	1.83	5.2x
actionability（可执行性）	9.50	6.50	1.5x
builder usefulness（对 builder 有用）	7.67	6.83	1.1x

口径标注

这组数字适合说明方向，不适合当权威跑分引用。它证明不了“ADHD 一定比所有推理策略强”，但能支持一个更窄的判断：在开放工程题上，隔离发散加单独 critic 的结构，确实可能让方案宽度、新颖度和陷阱发现明显不同。

因此正文里不要把它写成“行业基准领先”，更稳妥的说法是“项目自测显示，在 6 道开放工程题里，ADHD 在 5 道题上胜出，尤其是 trap detection 差距大”。事实边界守住，读者才知道该怎么用这组数据。

结论

ADHD 值得关注的地方，不是它把答案写得更长，而是它把“想得不一样”做成了结构：发散分支互相隔离，frame 让问题被重新提问，critic 单独上线负责剪枝。这个结构正好戳中 Coding Agent 在开放式工程题里的常见弱点：过早收敛到第一个顺眼答案。

把它放在关键决策点上，而不是日常逐键循环里。架构、接口、命名、迁移、模糊调试，这些地方值得多花 30 到 90 秒；查事实、修已知根因 bug、写一行样板代码，baseline 更合适。

如果你正在整理自己的 AI 编程工具链，可以继续读 2026 年 AI 编程工具全景盘点 看它在工具版图里的位置，也可以读 DeepAgents 架构解析 了解子代理和规划工具如何组织更长链路的推理。