Tree Of Thoughts
Run complex agent tasks that need multiple solution paths explored, scored, and merged before you commit to one implementation.
Overview
tree-of-thoughts is a journey-wide agent skill that explores multiple solution paths with meta-judge evaluation and synthesis—usable whenever a solo builder needs structured reasoning before committing to one approach.
Install
npx skills add https://github.com/neolabhq/context-engineering-kit --skill tree-of-thoughtsWhat is this skill?
- Eight-phase Tree of Thoughts flow: exploration, pruning, expansion, and evidence-based synthesis
- Meta-judge generates evaluation rubrics before independent judges score branches
- Adaptive strategy: polish clear winners, synthesize splits, or redesign failed branches
- Multiple agents probe different regions of the solution space in parallel
- argument-hint supports task description plus optional output path and success criteria
- Eight-phase Tree of Thoughts systematic reasoning pattern
Adoption & trust: 530 installs on skills.sh; 1.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You face a complex decision or design problem where a single linear answer hides better options you never explored.
Who is it for?
Ambiguous architecture choices, multi-step agent tasks, and any work where parallel hypotheses and rubric-based judging beat one-shot chat.
Skip if: Trivial one-path edits, tasks with an already locked spec, or jobs that only need a single tool call with no exploration.
When should I use this skill?
Task description and optional output path or criteria for complex reasoning that needs exploration, pruning, and synthesis.
What do I get? / Deliverables
You get a pruned, judge-scored, and synthesized best path (or merged plan) instead of an unverified first guess.
- Synthesized best solution or plan from explored branches
- Evaluation rubric and scored branch outcomes from meta-judge workflow
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Compare three positioning angles before you commit to a niche for your SaaS.
Explore MVP scope variants and prune features that fail your meta-judge criteria.
Branch on auth, queue, or storage designs then synthesize the winner into an implementation plan.
Enumerate threat-mitigation paths and score them before changing production config.
Generate competing root-cause hypotheses for an outage and merge the best-supported fix path.
How it compares
Use instead of asking the agent to “think step by step” once without branch exploration, pruning, or independent judges.
Common Questions / FAQ
Who is tree-of-thoughts for?
Solo and indie builders shipping with Claude Code, Cursor, or Codex who need rigorous multi-path reasoning before coding or deploying agent workflows.
When should I use tree-of-thoughts?
During validate when comparing product or scope options; during build when designing agent flows or backends with trade-offs; during ship when evaluating launch or security strategies; and during operate when diagnosing incidents with several root-cause hypotheses.
Is tree-of-thoughts safe to install?
Review the Security Audits panel on this Prism page and inspect the skill source in your repo before granting broad agent permissions for multi-agent runs.
SKILL.md
READMESKILL.md - Tree Of Thoughts
# tree-of-thoughts <task> Execute complex reasoning tasks through systematic exploration of solution space, pruning unpromising branches, expanding viable approaches, and synthesizing the best solution. </task> <context> This command implements the Tree of Thoughts (ToT) pattern for tasks requiring exploration of multiple solution paths before committing to full implementation. It combines creative sampling, meta-judge-generated evaluation specifications, multi-perspective evaluation, adaptive strategy selection, and evidence-based synthesis to produce superior outcomes. Key benefits: - **Systematic exploration** - Multiple agents explore different regions of the solution space - **Structured evaluation** - Meta-judges produce tailored rubrics and criteria before judging - **Independent verification** - Judges apply meta-judge specifications mechanically, reducing bias - **Adaptive strategy** - Clear winners get polished, split decisions get synthesized, failures get redesigned </context> ## Pattern: Tree of Thoughts (ToT) This command implements an eight-phase systematic reasoning pattern with meta-judge evaluation and adaptive strategy selection: ``` Phase 1: Exploration (Propose Approaches) ┌─ Agent A → Proposals A1, A2 (with probabilities) ─┐ Task ───┼─ Agent B → Proposals B1, B2 (with probabilities) ─┼─┐ └─ Agent C → Proposals C1, C2 (with probabilities) ─┘ │ │ Phase 1.5: Pruning Meta-Judge (runs in parallel with Phase 1) │ Meta-Judge → Pruning Evaluation Specification YAML ───┤ │ Phase 2: Pruning (Vote for Best 3) │ ┌─ Judge 1 → Votes + Rationale ─┐ │ ├─ Judge 2 → Votes + Rationale ─┼─────────────────────┤ └─ Judge 3 → Votes + Rationale ─┘ │ │ │ ├─→ Select Top 3 Proposals │ │ │ Phase 3: Expansion (Develop Full Solutions) │ ┌─ Agent A → Solution A (from proposal X) ─┐ │ ├─ Agent B → Solution B (from proposal Y) ─┼──────────┤ └─ Agent C → Solution C (from proposal Z) ─┘ │ │ Phase 3.5: Evaluation Meta-Judge (runs in parallel w/ Phase 3)│ Meta-Judge → Evaluation Specification YAML ───────────┤ │ Phase 4: Evaluation (Judge Full Solutions) │ ┌─ Judge 1 → Report 1 ─┐ │ ├─ Judge 2 → Report 2 ─┼──────────────────────────────┤ └─ Judge 3 → Report 3 ─┘ │ │ Phase 4.5: Adaptive Strategy Selection │ Analyze Consensus ────────────────────────────────────┤ ├─ Clear Winner? → SELECT_AND_POLISH │ ├─ All Flawed (<3.0)? → REDESIGN (Phase 3) │ └─ Split Decision? → FULL_SYNTHESIS │ │ │ Phase 5: Synthesis (Only if FULL_SYNTHESIS) │ Synthesizer ────────────────────┴──────────────────────┴─→ Final Solution ``` ## Process ### Setup: Create Directory Structure Before starting, ensure the directory structure exists: ```bash mkdir -p .specs/research .specs/reports ``` **Naming conventions:** - Proposa