Tree of Thoughts (ToT) Reasoning (Enhanced v2.0.0)
v2.0.0 Enhancement: Parallel execution + intelligent caching (FoT pattern)
Speed Improvement: 3-5x faster for complex problems
Cache Benefit: 50-200x faster for similar cached problems
Advanced reasoning through systematic exploration of solution spaces.
What is Tree of Thoughts?
Traditional reasoning (Chain of Thought):
CODEBLOCK0
Tree of Thoughts:
CODEBLOCK1
Key differences:
- - Explores MULTIPLE paths
- Evaluates EACH branch
- Can BACKTRACK from dead ends
- SELECTS optimal solution
- More robust than linear thinking
When to Use ToT
Use ToT for:
- - Multiple possible solutions exist
- Problem is ambiguous or complex
- Need to compare approaches
- High cost of failure
- Creative/optimization problems
- Uncertain which method works
Skip ToT for:
- - Simple, clear problems
- Single obvious solution
- Time-critical decisions
- Routine operations
- Well-known procedures
Parallel Execution + Caching (v2.0.0)
Performance Improvements
| Scenario | Before | After | Speedup |
|---|
| 3-branch exploration | 3.0s | 1.0s | 3x |
| 5-branch exploration |
5.0s | 1.2s | 4.2x |
| Deep tree (depth 4) | 8.0s | 2.0s | 4x |
| Similar cached problem | 5.0s | 0.025s | 200x |
Parallel Tree Generation
CODEBLOCK2
Intelligent Caching
CODEBLOCK3
CLI Flags
CODEBLOCK4
ToT Process
Step 1: GENERATE Thoughts
CODEBLOCK5
Step 2: EVALUATE Thoughts
CODEBLOCK6
Step 3: EXPAND Promising Thoughts
CODEBLOCK7
Step 4: EVALUATE Branches
CODEBLOCK8
Step 5: SEARCH for Solution
CODEBLOCK9
Step 6: SELECT Optimal Path
CODEBLOCK10
Thought Evaluation
Evaluation Criteria
Feasibility (0-10):
CODEBLOCK11
Quality (0-10):
CODEBLOCK12
Cost (0-10, inverse):
CODEBLOCK13
Risk (0-10, inverse):
CODEBLOCK14
Scoring Formula
CODEBLOCK15
Adjust weights based on priorities:
- - Quality-focused: INLINECODE0
- Speed-focused: INLINECODE1
- Safety-focused: INLINECODE2
Search Strategies
Breadth-First Search (BFS)
CODEBLOCK16
Depth-First Search (DFS)
CODEBLOCK17
Best-First Search
CODEBLOCK18
Beam Search
CODEBLOCK19
ToT Templates
Decision Problem
CODEBLOCK20
Creative Problem
CODEBLOCK21
Integration Patterns
ToT + Task Decomposition
CODEBLOCK22
ToT + Error Recovery
CODEBLOCK23
ToT + Self-Reflection
CODEBLOCK24
Backtracking
When a path fails:
CODEBLOCK25
Example:
CODEBLOCK26
Pruning Strategies
Early pruning:
- - Score < 3/10: Drop immediately
- Infeasible: Drop immediately
- High risk + low quality: Drop
Continuous pruning:
- - After expansion, keep only top 50%
- Remove redundant branches
- Merge similar thoughts
Practical Examples
Example 1: Choose Architecture
CODEBLOCK27
Example 2: Fix Performance Bug
CODEBLOCK28
ToT Reasoning Log
Track ToT sessions in: INLINECODE3
CODEBLOCK29
Metrics
- - Average thoughts generated per problem
- Search depth average
- Backtrack rate
- Decision quality (outcomes)
- Time to decision
- Solution diversity
Quick Actions
- -
tot [problem] - Run ToT reasoning - INLINECODE5 - Evaluate multiple options
- INLINECODE6 - Make decision with ToT
- INLINECODE7 - Show current ToT tree
Best Practices
- 1. Generate many thoughts initially (5-10)
- Evaluate objectively (use criteria)
- Prune aggressively (don't explore poor options)
- Expand gradually (depth vs breadth balance)
- Backtrack when stuck (dead ends happen)
- Document reasoning (learn from decisions)
- Review outcomes (improve evaluation accuracy)
Remember: The best solution is rarely the first one you think of. Explore, evaluate, select.
Real Usage Example
Scenario: Choosing the best system improvement to implement
Problem
"What ONE improvement should I make to the OpenClaw system today?"
Initial Thoughts (Generated 5 options)
| Option | Description | Feasibility | Quality | Cost | Risk | Score |
|---|
| A | Auto-create log files | 9 | 7 | 9 | 9 | 8.3 |
| B |
Add quick-action triggers | 4 | 8 | 3 | 5 |
5.0 |
| C | Add integration examples | 9 | 6 | 8 | 9 |
7.6 |
| D | Create error pattern detection | 7 | 9 | 6 | 7 |
7.4 |
| E | Create skill test runner | 6 | 9 | 5 | 6 |
6.5 |
Scoring Formula
CODEBLOCK30
Expansion (Top 2)
- - A → A1: Auto-create all log files AND error folder → Score: 8.5
- D → D1: Simple regex-based error classifier → Score: 7.8
Decision: A1 (Auto-create log files)
Rationale: Highest score, lowest risk, immediate usability improvement
Outcome
Created:
- - INLINECODE8
- INLINECODE9
- INLINECODE10
Lesson: Simple infrastructure improvements often beat complex features.
思维树 (ToT) 推理 (增强版 v2.0.0)
v2.0.0 增强: 并行执行 + 智能缓存 (FoT 模式)
速度提升: 复杂问题处理速度提升 3-5 倍
缓存优势: 相似缓存问题处理速度提升 50-200 倍
通过系统化探索解决方案空间实现高级推理。
什么是思维树？
传统推理 (思维链):
问题 → 步骤 1 → 步骤 2 → 步骤 3 → 解决方案
(单一线性路径)
思维树:
问题
/ | \
路径 A 路径 B 路径 C
/ \ | / \
A1 A2 B1 C1 C2
| | | | |
[评估] [评估] ... [评估]
\ | | / /
\ | | / /
最佳解决方案
主要区别:
- - 探索多条路径
- 评估每个分支
- 可从死胡同回溯
- 选择最优解决方案
- 比线性思维更稳健
何时使用 ToT
使用 ToT 的场景:
- - 存在多种可能解决方案
- 问题模糊或复杂
- 需要比较不同方法
- 失败成本高
- 创意/优化问题
- 不确定哪种方法有效
跳过 ToT 的场景:
- - 简单、清晰的问题
- 单一明显解决方案
- 时间紧迫的决策
- 常规操作
- 已知流程
并行执行 + 缓存 (v2.0.0)
性能提升
| 场景 | 之前 | 之后 | 加速比 |
|---|
| 3 分支探索 | 3.0 秒 | 1.0 秒 | 3 倍 |
| 5 分支探索 |
5.0 秒 | 1.2 秒 | 4.2 倍 |
| 深层树 (深度 4) | 8.0 秒 | 2.0 秒 | 4 倍 |
| 相似缓存问题 | 5.0 秒 | 0.025 秒 | 200 倍 |
并行树生成
python
async def paralleltreeof_thoughts(problem, branches=5, depth=3):
并行生成和评估思维树。
优势:
- 比顺序执行快 3-5 倍
- 所有分支同时生成
- 评估并行化
# 步骤 1: 并行生成所有初始思维
initial_thoughts = await asyncio.gather(*[
generatethoughtasync(problem) for _ in range(branches)
])
# 步骤 2: 并行评估所有思维
evaluations = await asyncio.gather(*[
evaluatethoughtasync(thought) for thought in initial_thoughts
])
# 步骤 3: 选择最佳思维进行扩展
topthoughts = selecttopk(initialthoughts, evaluations, k=3)
# 步骤 4: 并行扩展
expanded = await asyncio.gather(*[
expandthoughtasync(thought, depth-1) for thought in top_thoughts
])
return selectbestsolution(expanded)
智能缓存
python
def cachedtreeofthoughts(problem, cachettl_hours=24):
带语义缓存的 ToT，用于相似问题。
缓存命中条件:
- 重复相同问题 (精确匹配)
- 相似问题 (>85% 语义相似度)
- 相关问题类型 (相同领域)
cachekey = semantichash(problem)
cached = cacheget(cachekey)
if cached and semantic_similarity(problem, cached[problem]) > 0.85:
return {
solution: cached[solution],
from_cache: True,
cache_age: (now - cached[timestamp]).minutes
}
# 生成新解决方案
result = paralleltreeof_thoughts(problem)
# 缓存供将来使用
cacheset(cachekey, {
problem: problem,
solution: result,
timestamp: now()
})
return {result, from_cache: False}
CLI 标志
--parallel 使用并行执行 (默认)
--cached 启用缓存 (默认)
--sequential 禁用并行执行
--no-cache 禁用缓存
--branches N 设置分支数量 (默认: 5)
--depth N 设置树深度 (默认: 3)
ToT 流程
步骤 1: 生成思维
给定问题，生成多个初始方法:
- - 思维 A: [方法 1]
- 思维 B: [方法 2]
- 思维 C: [方法 3]
步骤 2: 评估思维
对每个思维，评估:
- - 可行性: 这能行吗？
- 质量: 结果会有多好？
- 成本: 需要多少时间/资源？
- 风险: 可能出什么问题？
步骤 3: 扩展有前景的思维
取最佳思维并扩展:
- - 思维 A → A1, A2, A3
- 思维 B → B1, B2
(仅扩展有前景的分支)
步骤 4: 评估分支
评估每个扩展分支:
- - A1: [评分/10]
- A2: [评分/10]
- B1: [评分/10]
步骤 5: 搜索解决方案
策略:
- - BFS: 广度优先探索所有分支
- DFS: 深入探索有前景的分支
- 最佳优先: 始终扩展评分最高的
- 束搜索: 保留前 K 个分支
步骤 6: 选择最优路径
选择预期结果最佳的路径:
思维评估
评估标准
可行性 (0-10):
- - 10: 绝对可能
- 7-9: 很可能
- 4-6: 可能
- 1-3: 不太可能
- 0: 不可能
质量 (0-10):
- - 10: 完美解决方案
- 7-9: 优秀解决方案
- 4-6: 合格解决方案
- 1-3: 较差解决方案
- 0: 未解决问题
成本 (0-10, 反向):
- - 10: 成本可忽略
- 7-9: 低成本
- 4-6: 中等成本
- 1-3: 高成本
- 0: 成本过高
风险 (0-10, 反向):
- - 10: 无风险
- 7-9: 低风险
- 4-6: 中等风险
- 1-3: 高风险
- 0: 必然失败
评分公式
分数 = (可行性 × 0.3) + (质量 × 0.3) + (成本 × 0.2) + (风险 × 0.2)
根据优先级调整权重:
- - 质量优先: 质量 × 0.5
- 速度优先: 成本 × 0.5
- 安全优先: 风险 × 0.5
搜索策略
广度优先搜索 (BFS)
第 1 层: 探索所有初始思维
第 2 层: 扩展所有有前景的思维
第 3 层: 继续广度方向
适用于: 全面探索
深度优先搜索 (DFS)
第 1 层: 选择最有前景的思维
第 2 层: 深入该分支
第 3 层: 继续深度方向
适用于: 快速深入解决方案
最佳优先搜索
始终扩展评分最高的节点
使用优先队列
适用于: 快速找到最优解
束搜索
每层仅保留前 K 个分支
早期剪枝低评分分支
适用于: 兼顾效率与质量
ToT 模板
决策问题
markdown
问题: [待决策事项]
初始思维
- 1. 选项 A: [描述]
- 可行性: 8/10
- 质量: 7/10
- 成本: 9/10
- 风险: 8/10
-
分数: 7.9/10
- 2. 选项 B: [描述]
- 可行性: 9/10
- 质量: 6/10
- 成本: 7/10
-
