Tree-of-Thought: Gestructureerde Verkenning
Op deze pagina
Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(Responses API) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Tree-of-Thought: Gestructureerde Verkenning
Tree-of-Thought (ToT) is een prompttechniek die de redenering van het model structureert als een beslissingsboom. In plaats van één lineair denkpad te volgen, verkennt het model meerdere takken, evalueert het elke tak en behoudt het alleen de veelbelovendste. De overeenkomst met een zoekalgoritme is direct: u genereert kandidaten, beoordeelt ze en snoeit de rest. Dit maakt de techniek uiterst effectief voor problemen die planning of terugdraaien vereisen.
Verschil met Chain-of-Thought
Chain-of-Thought (CoT) volgt een lineaire redenering: stap 1, stap 2, stap 3. De zwakte hiervan is structureel. Als het model in stap 2 het verkeerde pad inslaat, erven alle volgende stappen die fout over, en er is geen mechanisme om terug te gaan. De redenering kan perfect geformuleerd zijn, maar vertrekt vanuit een onjuiste premisse. Tree-of-Thought verkennt op elke stap meerdere richtingen en verworpt doodlopende wegen voordat er verdere ontwikkeling in wordt geïnvesteerd.
# Chain-of-Thought (lineair)
# Stap 1 → Stap 2 → Stap 3 → Antwoord
# Tree-of-Thought (boomgebaseerd)
# Stap 1
# / | \
# Opt A Opt B Opt C ← evaluatie
# | | ✗ ← snoeien
# Opt A1 Opt B1
# | |
# Antwoord Antwoord ← definitieve selectie
Implementatie met één prompt
De eenvoudigste versie past in één aanroep: de prompt dwingt het model een verkenningsstructuur te volgen—genereer drie benaderingen, evalueer ze, kies er één en werk deze uit. Dit is goedkoop en vaak voldoende om een open vraag aan te pakken. Houd rekening met één beperking voordat u hierop vertrouwt: het model stelt voor en evalueert in dezelfde adem, waardoor het toegeeflijk is tegenover zijn eigen ideeën, wat resulteert in minder streng snoeien dan nodig is.
from openai import OpenAI
client = OpenAI()
def tree_of_thought_simple(problem: str) -> str:
"""ToT in één prompt."""
prompt = f"""Los dit probleem op met de Tree-of-Thought-aanpak.
Probleem: {problem}
Stap 1 - Genereer 3 verschillende benaderingen:
- Benadering A: ...
- Benadering B: ...
- Benadering C: ...
Stap 2 - Evalueer elke benadering (sterke en zwakke punten):
- Benadering A: ...
- Benadering B: ...
- Benadering C: ...
Stap 3 - Selecteer de beste benadering en werk deze uit:
Geselecteerde benadering: ...
Gedetailleerde uitwerking: ...
Stap 4 - Definitief antwoord:
..."""
response = client.responses.create(
model="gpt-5.6-sol",
reasoning={"effort": "none"}, # temperature vereist effort none
input=prompt,
temperature=0.7
)
return response.output_text
Implementatie met meerdere aanroepen
Voor complexe problemen splitst u elke stap op in afzonderlijke aanroepen. Deze opdeling biedt u twee dingen die één prompt niet kan bieden. Ten eerste temperatuurregeling per stap: 0,8 voor generatie, waar diversiteit van voorstellen het hele doel van de methode is, en vervolgens 0,3 voor evaluatie en ontwikkeling, waar u juist rigorositeit en reproduceerbaarheid wilt. Ten tweede tussentijdse resultaten die u kunt inspecteren, loggen of zelfs ter validatie aan een mens kunt voorleggen voordat u de keten laat doorgaan.
def tree_of_thought(problem: str, breadth: int = 3,
depth: int = 3) -> dict:
"""ToT met meerlagige verkenning."""
system = "U bent een expert in gestructureerde probleemoplossing."
# Stap 1: Genereer initiële takken
gen_prompt = (f"Probleem: {problem}\n\n"
f"Stel {breadth} verschillende benaderingen voor om "
f"dit probleem op te lossen. Geef voor elke benadering een titel en "
f"een beschrijving van 2-3 zinnen. Nummer ze 1 tot {breadth}.")
branches_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vereist effort none
instructions=system,
input=gen_prompt,
temperature=0.8
)
branches = branches_response.output_text
# Stap 2: Evalueer elke tak
eval_prompt = (f"Probleem: {problem}\n\n"
f"Hier zijn {breadth} voorgestelde benaderingen:\n{branches}\n\n"
f"Evalueer elke benadering op 3 criteria (score /10):\n"
f"- Haalbaarheid\n- Efficiëntie\n- Eenvoud\n\n"
f"Rank ze van best naar slechtst met onderbouwing.")
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vereist effort none
instructions=system,
input=eval_prompt,
temperature=0.3
)
evaluation = eval_response.output_text
# Stap 3: Werk de beste tak uit
dev_prompt = (f"Probleem: {problem}\n\n"
f"Evaluatie van benaderingen:\n{evaluation}\n\n"
f"Werk de hoogst gerangschikte benadering gedetailleerd uit. "
f"Lever een complete, uitvoerbare oplossing.")
solution = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature vereist effort none
instructions=system,
input=dev_prompt,
temperature=0.3
)
return {
"branches": branches,
"evaluation": evaluation,
"solution": solution.output_text
}
Uitgewerkt voorbeeld: Software-architectuur
Het onderstaande probleem is precies het type waarbij ToT waarde toevoegt. Verschillende strategieën zijn verdedigbaar—caching, read-replica’s, het extraheren van de zoekservice, blue-green deployment—en de keuze hangt af van beperkingen die de prompt expliciet stelt, met name de teamgrootte. Een directe prompt zou u de oplossing geven die het vaakst in technische literatuur wordt genoemd, ongeacht deze beperkingen; ToT zet deze af tegen de anderen en moet zijn rangschikking verdedigen op basis van haalbaarheidscriteria.
problem = """
Onze monolithische REST API (Django, PostgreSQL) loopt tegen zijn limieten aan:
- Maximaal 500 verzoeken/seconde
- Responstijd > 2s op zoek-eindpunten
- Deployment = 30 minuten downtime
- 3 ontwikkelaars in het team
Hoe kunnen we prestaties en beschikbaarheid verbeteren
zonder de volledige applicatie opnieuw te schrijven?
"""
result = tree_of_thought(problem, breadth=4)
print(result["solution"])
Waar ToT wint en waar het uw tijd verdoet
De techniek blinkt uit bij planningsproblemen—architectuur, roadmaps, strategie—bij beperkte problemen zoals optimalisatie of resource-toewijzing, bij complexe debugging waar meerdere oorzaken gelijktijdig aannemelijk blijven, en bij technische beslissingen zoals het kiezen van een framework of database. Deze situaties delen twee kenmerken: er bestaan meerdere geldige oplossingen en er is een expliciet criterium om onderscheid te maken.
Sla het daarentegen over voor simpele feitelijke vragen waar niets te verkennen valt en u zou betalen voor drie aanroepen om een voor de hand liggend antwoord te krijgen. Het faalt ook bij open creatieve taken vanwege het ontbreken van een verdedigbaar evaluatiecriterium: het ranken van drie reclameslogans op een haalbaarheidsschaal slaat nergens op. Vermijd het ten slotte wanneer latentie kritiek is, aangezien de versie met meerdere aanroepen mechanisch meerdere API-verzoeken ketent voordat er iets wordt teruggegeven.
Combineren met redeneerinstellingen
Bij hoge redeneerinstellingen voeren GPT-5.6-modellen al gestructureerde interne verkenning uit. Expliciete ToT wordt dan grotendeels overbodig en brengt u in rekening voor hetzelfde werk twee keer. Reserveer het voor situaties waarin redeneren is uitgeschakeld of laag staat, zoals in de onderstaande vergelijking.
# Met laag redeneerniveau: expliciete ToT is nuttig
result = tree_of_thought(problem, breadth=3)
# Met hoog redeneerniveau: het model redeneert al diepgaand
response = client.responses.create(
model="gpt-5.6-sol",
input=problem,
reasoning={"effort": "high"}
)
Om in uw eigen context een beslissing te nemen, neemt u een architectuur- of ontwerpprobleem dat u deze week daadwerkelijk op uw bord heeft, voert u dit uit via multi-call ToT met breadth=3 en dient u het vervolgens ongewijzigd in via een directe prompt. Vergelijk de twee oplossingen en vooral de tokenkosten van elk. Voor een beslissing met hoge stakes rechtvaardigt het kwaliteitsverschil ruimschoots de extra kosten; voor een secundaire vraag doet het dat niet, en wetende dit voorkomt u dat u de techniek uit gewoonte overal toepast.
Belangrijkste punten
- ToT verkennt meerdere redeneerpaden en selecteert de beste
- Eenvoudige versie met één prompt of geavanceerde versie met meerdere aanroepen
- Ideaal voor planning, architectuur en complexe debugging
- Bij hoge redeneerinstellingen hebben GPT-5.6-modellen al impliciete ToT
- De extra tokenkosten zijn gerechtvaardigd voor beslissingen met grote impact