Tree of Thoughts

Einfach erklärt

Tree of Thoughts (ToT) lässt ein LLM wie ein Schachcomputer denken: Statt nur einem Gedankengang zu folgen, exploriert es mehrere mögliche Pfade, bewertet jeden Zwischenschritt, und wählt den vielversprechendsten.

Chain-of-Thought vs. Tree of Thoughts:

Chain-of-Thought (linear):
Problem → Schritt 1 → Schritt 2 → Schritt 3 → Lösung

Tree of Thoughts (verzweigt):
                    ┌→ Schritt 2a → ✗ (Sackgasse)
Problem → Schritt 1 ┼→ Schritt 2b → Schritt 3 → Lösung ✓
                    └→ Schritt 2c → ✗ (schlechter)

Wann ist ToT besser?

Situation	CoT	ToT
Einfache Frage	✓	Overkill
Ein klarer Lösungsweg	✓	Unnötig
Mehrere mögliche Ansätze	○	✓
Frühe Fehler fatal	✗	✓
Kreative Exploration	○	✓

Beispiel – Rätsel lösen:

Problem: "24 Game" – Mache aus 4, 9, 10, 13 die Zahl 24

ToT-Ansatz:
├── Pfad A: (13 - 9) × (10 - 4) = 4 × 6 = 24 ✓
├── Pfad B: (4 + 9) × ... → keine Lösung gefunden
└── Pfad C: 10 + 13 + ... → zu groß, abgebrochen

→ Pfad A ist die Lösung

Technischer Deep Dive

ToT-Algorithmus

Drei Kernkomponenten:

1. Thought Decomposition: Problem in Zwischenschritte zerlegen
2. Thought Generator: Mehrere Kandidaten pro Schritt generieren
3. State Evaluator: Zwischenstände bewerten (gut/schlecht/unsicher)

Pseudocode:

def tree_of_thoughts(problem, max_depth=5):
    root = State(problem)
    frontier = [root]
    
    while frontier:
        state = select_best(frontier)  # BFS oder DFS
        
        if is_solution(state):
            return state.path
        
        if state.depth < max_depth:
            # Generiere mehrere Gedanken
            thoughts = generate_thoughts(state, n=3)
            
            for thought in thoughts:
                # Bewerte jeden Gedanken
                score = evaluate_thought(thought)
                
                if score > threshold:
                    new_state = state.extend(thought)
                    frontier.append(new_state)
    
    return best_partial_solution(frontier)

Suchstrategien

Breadth-First Search (BFS):

• Alle Pfade gleichmäßig explorieren
• Gut wenn Lösungstiefe unbekannt
• Höherer Speicherbedarf

Depth-First Search (DFS):

• Einen Pfad tief verfolgen, dann backtrack
• Speichereffizienter
• Kann in schlechten Pfaden stecken bleiben

Best-First Search:

• Immer den vielversprechendsten Pfad zuerst
• Erfordert gute Bewertungsfunktion
• Oft der beste Kompromiss

Bewertungsfunktionen

LLM als Evaluator:

Prompt: "Bewerte diesen Zwischenschritt auf einer Skala 
von 1-10. Wie wahrscheinlich führt er zur Lösung?

Problem: [Original-Problem]
Bisherige Schritte: [Pfad]
Aktueller Schritt: [Thought]

Bewertung:"

Voting (Self-Consistency):

• Mehrere Samples generieren
• Häufigste Antwort gewinnt
• Robuster, aber teurer

ToT in der Praxis

Mit modernen Reasoning-Modellen:

GPT-5 Thinking und Claude Sonnet 4.6 haben ToT-ähnliche Fähigkeiten eingebaut:

Prompt: "Denke über mehrere Lösungsansätze nach, 
bewerte jeden, und wähle den besten.

Problem: [Komplexes Problem]"

Das Modell exploriert intern verschiedene Pfade.

Explizites ToT-Prompting:

Schritt 1: Generiere 3 verschiedene Ansätze für dieses Problem.

Schritt 2: Bewerte jeden Ansatz:
- Ansatz A: [Stärken/Schwächen]
- Ansatz B: [Stärken/Schwächen]  
- Ansatz C: [Stärken/Schwächen]

Schritt 3: Verfolge den vielversprechendsten Ansatz weiter.

Schritt 4: Wenn du in eine Sackgasse gerätst, 
gehe zurück und versuche einen anderen Ansatz.

Kosten-Nutzen

Aspekt	CoT	ToT
API-Calls	1	5-20+
Latenz	Niedrig	Hoch
Kosten	$	$$$$
Qualität (einfach)	Gut	Gleich
Qualität (komplex)	Mittel	Sehr gut

Empfehlung:

• Einfache Aufgaben: CoT oder direkt
• Komplexe Aufgaben: ToT oder Reasoning-Modelle
• Produktion: Reasoning-Modelle mit eingebautem ToT