Hoe gebruik je de thinking mode in Claude 4.5?

“Denkmodus” (ook wel aangeduid als uitgebreid denken, denken of denkblokken) in Claude 4.5 is een expliciete, configureerbare werkmodus die het model instrueert om een apart gebudgetteerd aantal tokens te besteden aan interne, stapsgewijze redenering (een “redeneringsketen”) voordat het het uiteindelijke antwoord geeft. Het is ontworpen om prestaties te verbeteren bij meerstapsredenering, complexe codeer- en agent-workflows en onderzoekstaken door latentie en tokenkosten in te ruilen voor diepere interne afweging. Claude 4.5 stelt deze mogelijkheid bloot op het niveau van de Messages API met expliciete parameters (bijv. thinking / budget_tokens of een effort-/“interleaved-thinking”-header), bewaart en versleutelt denkblokken optioneel voor latere verificatie of toolgebruik, en introduceert cache- en tokenboekhoudingsgedrag dat je moet beheren bij het bouwen van productie-workloads.

Wat is Claude 4.5? (En welke modellen zijn relevant?)

Claude 4.5 is Anthropic’s nieuwste set Claude-modellen die als incrementele “4.5”-updates zijn uitgebracht (bijvoorbeeld Sonnet 4.5 en Opus 4.5). Sonnet 4.5 biedt de beste balans tussen intelligentie, codering en agent-prestaties voor de meeste ontwikkelaars; Opus 4.5 richt zich op zeer intensieve redenering en bewaart denkblokken om de continuïteit over meerdere beurten te verbeteren. Beide modellen ondersteunen Claude’s uitgebreide denkmogelijkheden, hoewel sommige gedragingen (bijv. samengevat versus volledige denkinhoud) per model verschillen.

De prestatieverbeteringen in Claude 4.5, met name in Sonnet 4.5, zijn het duidelijkst zichtbaar in de SWE-bench Verified-benchmark, die de vaardigheid van een AI meet om echte GitHub-issues op te lossen.

Deze cijfers geven aan dat Claude 4.5 niet alleen beter is in het schrijven van snippets; het is aanzienlijk capabeler in het navigeren door volledige bestandssystemen en het uitvoeren van autonome taken zonder menselijke tussenkomst.

Waarom dit belangrijk is

• Coderen & agents: Sonnet 4.5 laat sterke winst zien bij realistische softwaretaken en langlopende codeerwerk—waardoor het een logische keuze is voor codegeneratie, codebewerking en autonome agent-flows.
• Uitgebreid denken & context: Modellen in de Claude 4.5-familie zijn gebouwd om te redeneren met zeer grote interne kladblokken (tientallen duizenden tokens of meer), wat diepere meerstapsredenering mogelijk maakt. Dat verandert hoe je prompts, tokenbudgetten en toolinteracties ontwerpt.

Wat is de Denkmodus in Claude 4.5?

De Denkmodus (officieel “Extended Thinking”) is een mogelijkheid waarmee het model “zijn werk” aan zichzelf kan tonen voordat het een uiteindelijke output levert. In tegenstelling tot standaardmodellen die direct tot een antwoord komen, gebruikt Claude 4.5 een toegewijde redeneerruimte om meerdere hypothesen te verkennen, mogelijke fouten in zijn logica te identificeren en zijn strategie te verfijnen.

De anatomie van een antwoord

In een standaardinteractie ontvangt het model een prompt en begint het het antwoord te genereren. In de Denkmodus wordt de reactie opgesplitst in twee afzonderlijke blokken:

Kerneigenschappen van de denkmodus

• Inschakelen op verzoek: Je geeft een thinking-object mee in de API-call, zoals {"type":"enabled","budget_tokens":10000}, om het in te schakelen en het model een intern tokenbudget te geven voor redenering.
• Budgettering: budget_tokens begrenst de interne redeneringstokens van het model. Meer budget => diepere denkmogelijkheden maar hogere kosten en latentie. In Claude 4-modellen worden denktokens in rekening gebracht, zelfs als je alleen een samenvatting te zien krijgt.
• Samenvatting & redactie: Voor veel Claude 4-modellen ziet de gebruiker een samengevatte versie van de denkinhoud; sommige interne redenering kan worden geredigeerd (versleuteld) door veiligheidssystemen en teruggegeven als redacted_thinking.
• Handtekeningen & verificatie: Denkblokken bevatten een ondoorzichtige signature die wordt gebruikt voor verificatie bij het terugsturen van denkblokken naar de API (vooral nodig bij gebruik van tools). Behandel de handtekening als ondoorzichtig—probeer deze niet te parseren.
• Verweven denken met tools: Claude 4 ondersteunt het verweven van denkblokken met toolexecuties (in sommige gevallen beta en vlaggebaseerd). Dit is krachtig voor agentisch werk (tool uitvoeren, denken, nog een tool uitvoeren, enz.).

Voor praktische voorbeelden en de meest actuele parameters zijn Anthropic’s Messages/Extended Thinking-docs de canonieke referentie.

Hoe retourneert de Messages API denkinhoud

Samengevat versus volledige denkinhoud; versleuteling & handtekeningen

Verschillende Claude 4-modelversies gaan anders om met denkinhoud: recentere Claude 4-modellen (zoals Sonnet/Opus 4.5) geven vaak een samengezichte publieke weergave van de interne redenering terug, terwijl het volledige kladblok mogelijk wordt versleuteld en alleen beschikbaar is via een signature-veld (of geredigeerde blokken). Wanneer tools worden gebruikt (of je de interne staat over toolcalls heen wilt behouden), moet je denkblokken teruggeven aan de API of het handtekeningenmechanisme gebruiken dat in de docs wordt beschreven. Dit mechanisme helpt gevoelige interne redenering te beschermen en maakt tegelijkertijd veilige voortzetting van het denkproces mogelijk wanneer dat nodig is.

Praktische aanpak

Toolgebruik / voortzetting: als je volgende verzoek dezelfde interne staat moet voortzetten (bijv. tools zijn uitgevoerd op basis van het denken), voeg dan het geretourneerde denkblok of de handtekening toe wanneer je de API opnieuw aanroept, zodat het model kan ontsleutelen en doorgaan waar het was gebleven.

Request: stuur thinking: {type: "enabled", budget_tokens: N}.

Response: je kunt (a) een samengevatte publieke output ontvangen, (b) een versleutelde signature of redacted_thinking-blok, of (c) beide.

CometAPI biedt de Claude 4.5 API aan voor 20% van de officiële API-prijs, en kan ook worden aangeroepen via de Anthropic Messages. Je moet een API-sleutel verkrijgen voordat je begint.

Voorbeeld 1 — eenvoudige curl (niet-streaming) met denken ingeschakeld

curl https://api.cometapi.com/v1/messages \
  -H "x-api-key: $CometAPI_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {
      "type": "enabled",
      "budget_tokens": 10000
    },
    "messages": [
      {"role": "user", "content": "Ontwerp een robuuste strategie voor datavalidatie voor CSV-imports, laat tests + code zien."}
    ]
  }'

De response bevat content-blokken. Inspecteer elk blok en geef de voorkeur aan de text-blokken voor de uiteindelijke output; thinking-blokken bevatten de samenvatting van de interne analyse van het model.

Voorbeeld 2 — Python: verzoek, denkinhoud en tekstblokken parsen

import os, requests

API_KEY = os.environ["CometAPI_API_KEY"]
URL = "https://api.cometapi.com/v1/messages"
HEADERS = {
    "x-api-key": API_KEY,
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {"type": "enabled", "budget_tokens": 8000},
    "messages": [{"role": "user", "content": "Leg uit hoe je property-based testing in Python doet; voeg voorbeeldcode toe."}]
}

r = requests.post(URL, headers=HEADERS, json=payload)
r.raise_for_status()
resp = r.json()

# Blokken parsen
for block in resp.get("content", []):
    if block.get("type") == "thinking":
        thinking_summary = block.get("thinking")
        print("=== DENKEN (samenvatting) ===")
        print(thinking_summary[:1000])  # afkorten voor logs
        print("handtekening:", block.get("signature")[:64], "...")
    elif block.get("type") == "text":
        print("=== FINALE TEKST ===")
        print(block.get("text"))

Deze code extraheert en print de samengevatte denkinhoud en het uiteindelijke antwoord. Als je de continuïteit wilt behouden in agent-flows met meerdere beurten, neem dan de ongewijzigde denkblokken op in de volgende aanvraag in de messages-array (zie volgend voorbeeld).

Voorbeeld 3 — denkblokken hergebruiken in een multi-turn flow (Python pseudo)

# Na de initiële response (resp hierboven):
# Voeg het assistant-bericht inclusief het denkblok toe aan het gesprek
assistant_message = {
  "role": "assistant",
  "content": resp["content"]  # voeg ruwe content-array toe (bevat thinking + text-blokken)
}

# Volgende user-beurt: stel een vervolgvraag en voeg het vorige assistant-bericht toe
payload2 = {
  "model": "claude-opus-4-5",  # Opus bewaart denkblokken beter over meerdere beurten
  "max_tokens": 20000,
  "thinking": {"type": "enabled", "budget_tokens": 12000},
  "messages": [
    {"role": "user", "content": "Pas nu de validatielogica aan voor een avro-pipeline."},
    assistant_message
  ]
}
r2 = requests.post(URL, headers=HEADERS, json=payload2)

Het behouden van exact ongewijzigde denkblokken is cruciaal bij toolgeïntegreerde of lange agent-workflows. Opus 4.5 heeft verbeterde standaarden voor het behoud en cachen van denkblokken.

Hoe stream ik denkinhoud en toon ik voortgang in een UI?

Best practices voor streaming

• Gebruik de streaming-endpoints van de SDK’s (de Python/TypeScript SDK’s hebben stream-helpers). Voor langlopende of hooggebudgetteerde redeneerjobs voorkomt streaming HTTP-timeouts en geeft het je gedeeltelijke tekst terwijl het model berekent. Typische code gebruikt een iterator over text_stream (Python) of event-parsing (JS).
• Verwacht soms twee fasen in streams: het model kan eerst zichtbare redeneerchunks produceren en vervolgens afronden met het antwoord. Bouw je UI voor gechunkte content en toon “denkt…” versus eindantwoordstatus.
• Als de API een signature_delta of content_block_delta retourneert bij streaming, leg die vast en voeg ze toe aan volgende calls zoals vereist door de specificatie.

Als je tussentijdse redeneer-voortgang in een UI wilt tonen, stream de response. De server stuurt thinking_delta-events gevolgd door text_delta-events.

curl https://api.cometapi.com/v1/messages \
  --header "x-api-key: $CometAPI_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "stream": true,
    "thinking": { "type": "enabled", "budget_tokens": 8000 },
    "messages": [ { "role": "user", "content": "Leid me door het debuggen van deze falende unittest en stel fixes voor." } ]
  }'

Bij streaming: verwerk content_block_start, content_block_delta (dat thinking_delta en text_delta bevat) en content_block_stop-events in de juiste volgorde. Zo kun je de stapsgewijze redenering van het model live weergeven.

Hoe werkt Claude Code met de denkmodus? (terminal + VS Code)

Claude Code is de interactieve, agentische coding-terminal die de Messages API en toolrunners integreert. De CLI/IDE-ervaring toont denken op twee manieren:

• Globale / sessieniveau-instellingen: Claude Code biedt een /config-instellingenpaneel om gedrag aan te passen (hoe de agent om toestemming vraagt, of denkblokken behouden blijven, enz.). Gebruik die UI in plaats van ruwe JSON te herhalen als je een persistente gedragswijziging wilt.
• Modelselectie & CLI-commando’s: Je kunt claude-sonnet-4-5 of claude-opus-4-5 kiezen als actief model in de REPL; de tools en denkgedrag volgen dan de semantiek van de Messages API. De CHANGELOG en release notes geven aan dat denken nu standaard is ingeschakeld voor sommige Opus 4.5-deployments en dat denkconfiguratie zichtbaar is via /config.

Praktische flow in Claude Code:

1. Start een project in de REPL.
2. Gebruik /config om denkgerelateerde flags te inspecteren (behoud, uitgebreidheid, enz.).
3. Vraag de agent om een lange taak uit te voeren—het zal denkinhoud produceren en, indien nodig, om toestemming vragen om bepaalde bash-stappen uit te voeren. Behoud denkblokken wanneer je beslissingen later wilt verifiëren of opnieuw wilt uitvoeren.

Installatie en setup

Claude Code vereist Node.js en kan globaal worden geïnstalleerd.

# Claude Code CLI installeren
npm install -g @anthropic/claude-code

# Authenticeren
claude-code --init

Denkmodus activeren in de terminal

Claude Code ondersteunt diverse flags en natuurlijke taaltriggers om de redeneerdiepte te sturen.

Tips:

• Gebruik think/think harder wanneer je wilt dat de agent alternatieve implementaties verkent.
• Wanneer Claude Code toolcalls uitvoert (tests draaien, git-operaties), behoud eventuele thinking-blokken als de CLI/agent die teruggeeft; anders kan de agent context verliezen tussen stappen.

Voordelen van Verweven denken en het behouden van blokken

Voor geavanceerde agent-workflows introduceert Claude 4.5 twee bètamogelijkheden die multi-turn-interacties en toolgebruik aanzienlijk verbeteren: Verweven denken en Denkblokken behouden.

Verweven denken (Beta)

Standaardredenering gebeurt één keer vóór de output. Verweven denken (ingeschakeld via de interleaved-thinking-2025-05-14-header) stelt Claude in staat te “denken” tussen toolcalls door.

Stel dat Claude een server debugt:

1. Denk: "Ik moet eerst de logs controleren."
2. Toolcall: read_file(logs.txt)
3. Denk: "De logs tonen een database-timeout. Nu moet ik de connection pool-instellingen controleren."
4. Toolcall: read_file(db_config.yml)

Deze “continue reflectie” zorgt ervoor dat het model zijn strategie aanpast op basis van de data die het van tools ontvangt, in plaats van een rigide, vooraf gedefinieerd plan te volgen.

Denkblokken behouden

In gesprekken met meerdere beurten, vooral die met toolgebruik, is het essentieel om eerdere thinking-blokken terug te geven aan de API.

• Redeneringscontinuïteit: Door zijn eerdere gedachten te ontvangen, behoudt Claude de logische context van zijn traject.
• Opus 4.5-optimalisatie: In Claude Opus 4.5 is dit gedrag geautomatiseerd. Het model behoudt standaard alle eerdere denkblokken in zijn context, zodat het zelfs in sessies van 30+ uur niet “vergeet” waarom het bepaalde architectuurkeuzes tien beurten geleden maakte.

Best practices voor het gebruik van de THINKING-modus met Claude 4.5

Kies het juiste model en budget voor de taak:

Gebruik Sonnet 4.5 voor coderen en agent-workflows waar je de beste balans wilt tussen snelheid, kosten en sterke codeerkwaliteiten; gebruik Opus 4.5 voor de diepste redenering en de grootste contextvensters of wanneer je lange autonome sessies plant. Beide ondersteunen uitgebreid denken. Kies budget_tokens in verhouding tot de complexiteit van de taak (begin klein voor experimenten; verhoog het budget alleen als je materiële kwaliteitsverbeteringen observeert).

Monitor en beheer kosten & latentie

Je wordt gefactureerd voor alle denktokens die Claude produceert, niet voor de samengevatte output die je ontvangt. Dat betekent dat lange interne afwegingen de kosten verhogen, zelfs als je slechts een korte samenvatting ziet. Houd tokengebruik bij en overweeg geleidelijke tuning (bijvoorbeeld: 2k → 8k → 32k) bij de overgang van exploratie naar productie.

Behoud denkblokken alleen wanneer nodig

Denkblokken kunnen cryptografisch worden ondertekend en bewaard voor latere verificatie en voor verweven toolgebruik. Vermijd het terugsturen van denkblokken in elke volgende request, tenzij je workflow vereist dat het model zijn eerdere interne afwegingen behoudt (bijv. wanneer een agent stappen opnieuw uitvoert en de bewaarde motiveringen nodig heeft). Denkblokken altijd behouden vergroot het contextvolume en kan de tokenboekhouding compliceren.

Wanneer denkinhoud naar gebruikers streamen

Gestreamde denkinhoud is uitstekend voor ontwikkelaarstools en educatieve UI’s (het tonen van “bezig met denken” terwijl het model deliberaties uitvoert). Stream geen ruwe denkinhoud naar eindgebruikers van productiegerichte consumentenapps zonder aandacht voor veiligheid en redactie: samengevat denken bestaat precies om die reden. Als je streamt, voorzie UI-elementen die interne redenering labelen (bijv. “Assistant-redenering — intern”), en beheer of de eindgebruiker de samengevatte of de volledige redenering ziet.

Toolgebruik en verweving

Combineer je denken met tools (code-executie, webfetch, lokale processen), gebruik dan het ontwerp van verweven denken wanneer je wilt dat het model tools selecteert, ze uitvoert en redeneert over resultaten binnen dezelfde beurt. Verweving verhoogt de complexiteit (en kan featureflags vereisen) maar is krachtig voor agentische automatisering. Wees expliciet over welke denkinhoud je behoudt en test hoe het model tools selecteert onder een run met denken ingeschakeld.

Praktische troubleshooting en operationele notities

Veelvoorkomende fouten en wat ze betekenen

• Ongeldige denkinstellingen + geforceerde toolkeuze: Als je denken aanvraagt maar ook bepaalde toolgebruikmodi forceert die incompatibel zijn met denken, retourneert de API een fout—mix tool_choice: {"type":"tool","name":"..."} niet met denken.
• Budget > max_tokens: Voor verweven-denkscenario’s verschillen de effectieve tokenregels—de platformdocs leggen uit wanneer budget_tokens groter mag zijn dan max_tokens. Lees het gedeelte “interleaved thinking” zorgvuldig voordat je grote budgetten test.
• Handtekeningvalidatie: Als je denkblokken behoudt voor latere calls, voeg de geretourneerde signature toe zodat de API kan verifiëren dat ze van Claude afkomstig zijn; dit voorkomt manipulatie en houdt de keten verifieerbaar.

Observeerbaarheid & instrumentatie

Log: (1) modelselectie, (2) thinking.budget_tokens, (3) daadwerkelijke consumptie van denktokens (je wordt ervoor gefactureerd), (4) streaming-latenties (tijd tot eerste thinking_delta), en (5) uiteindelijke teksttokens. Gebruik deze metrics om budgetten en SLO’s te bouwen voor gebruikersgerichte flows.

Gefaseerde uitrol & human-in-the-loop

Rol denken-ingeschakelde modellen uit achter featureflags. Begin met een percentage van ontwikkelaars- of interne traffic, verzamel fouten of redacties, en iteratief verbeter prompts en budgetten. Vereis voor gevoelige domeinen menselijke review op outputs die substantiële interne redenering bevatten voordat ze worden vrijgegeven.

Debuggingtips

• Begin klein: schakel een laag budget_tokens in en schaal op om stapsgewijze verbeteringen te begrijpen.
• Zet streaming aan en log content_block_delta-/handtekening-events om te begrijpen wanneer het model denkblokken produceert.
• Als je Claude Code gebruikt: controleer /config en de projectinstellingen; raadpleeg de Claude Code-changelog als gedrag niet overeenkomt met de verwachte defaults.

Conclusie:

Claude 4.5, gecombineerd met de kracht van Extended Thinking en de Claude Code CLI, vertegenwoordigt de grootste sprong in ontwikkelaarsproductiviteit sinds de uitvinding van de IDE. Door het model toe te staan “zijn werk te tonen” en te delibereren over complexe problemen, is Anthropic voorbij het “chatbot”-tijdperk en de “agentische” era binnengegaan.

Of je nu de Messages API integreert in een aangepaste dev-tool of Claude Code gebruikt om je dagelijkse PR’s te beheren, het beheersen van de Denkmodus is essentieel. Het biedt de transparantie die nodig is voor vertrouwen en de redeneerdiepte die nodig is voor excellentie.

Ontwikkelaars hebben toegang tot het Claude 4.5-model (Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.5) via CometAPI. Om te beginnen, verken de modelmogelijkheden van CometAPI in de Playground en raadpleeg de API-gids voor gedetailleerde instructies. Voordat je toegang krijgt, zorg ervoor dat je bent ingelogd bij CometAPI en een API-sleutel hebt verkregen. CometAPI biedt een prijs die veel lager ligt dan de officiële prijs om integratie te vergemakkelijken.

Klaar om te beginnen?→ Gratis proef van Claude 4.5!