Sådan bruger du tænketilstand i Claude 4.5

“Thinking mode” (også kaldet udvidet tænkning, tænkning eller tænkeblokke) i Claude 4.5 er en eksplicit, konfigurerbar køremodus, der instruerer modellen i at bruge et separat budget af tokens på at generere intern, trinvis ræsonnering (en “chain-of-thought”) før den leverer det endelige svar. Den er designet til at forbedre ydeevnen på flertrins-ræsonnering, kompleks kodning og agent-baserede arbejdsflows samt researchopgaver ved at bytte latenstid og token-omkostning for dybere intern overvejelse. Claude 4.5 eksponerer denne kapabilitet på Messages API-niveau med eksplicitte parametre (f.eks. thinking / budget_tokens eller en effort/“interleaved-thinking”-header), bevarer og kan valgfrit kryptere tænkeblokke til senere verifikation eller værktøjsbrug og introducerer cache- og token-regnskabsadfærd, som du skal håndtere i produktionsarbejdsbelastninger.

Hvad er Claude 4.5? (Og hvilke modeller bør jeg interessere mig for?)

Claude 4.5 er Anthropic’s nyeste sæt af Claude-modeller, udgivet som inkrementelle “4.5”-opdateringer (for eksempel Sonnet 4.5 og Opus 4.5). Sonnet 4.5 er positioneret som den bedste balance mellem intelligens, kodning og agentisk ydeevne for de fleste udviklere; Opus 4.5 fokuserer på meget høj-indsats-ræsonnering og bevarer tænkeblokke for at forbedre kontinuitet på tværs af flere ture. Begge modeller understøtter Claude’s udvidede tænkning, men noget adfærd (f.eks. opsummeret vs. fuld tænkning) varierer efter model.

Ydelsesforbedringerne i Claude 4.5, især i Sonnet 4.5, er mest synlige i benchmarken SWE-bench Verified, som måler en AI's evne til at løse virkelige GitHub-issues.

Disse tal indikerer, at Claude 4.5 ikke blot er bedre til at skrive snippets; den er markant mere kapabel til at navigere i hele filsystemer og udføre autonome opgaver uden menneskelig indblanding.

Hvorfor det er vigtigt

• Kodning og agenter: Sonnet 4.5 viser stærke forbedringer på virkelige softwareopgaver og langvarigt kodningsarbejde—hvilket gør den til et naturligt valg til kodegenerering, kode-redigering og autonome agent-flows.
• Udvidet tænkning og kontekst: Claude 4.5-familiens modeller er bygget til at ræsonnere med meget store interne kladdeblokke (tit titusindvis af tokens eller mere), hvilket muliggør dybere flertrins-ræsonnering. Det ændrer, hvordan du designer prompts, tokenbudgetter og værktøjsinteraktioner.

Hvad er Thinking Mode i Claude 4.5?

Thinking Mode (officielt benævnt "Extended Thinking") er en kapabilitet, der tillader modellen at “vise sit arbejde” for sig selv, før den leverer en endelig output. I modsætning til standardmodeller, der binder sig til et svar med det samme, bruger Claude 4.5 et dedikeret ræsonneringsrum til at udforske flere hypoteser, identificere potentielle fejl i sin logik og finpudse sin strategi.

Anatomi af et svar

I en standardinteraktion modtager modellen en prompt og begynder at generere svaret. I Thinking Mode deles svaret op i to distinkte blokke:

Nøgleegenskaber ved thinking mode

• Aktiveres på anmodning: Du sender et thinking-objekt i API-kaldet såsom {"type":"enabled","budget_tokens":10000} for at slå det til og give modellen et internt tokenbudget til ræsonnering.
• Budgettering: budget_tokens sætter loft over modellens interne ræsonneringstokens. Mere budget => større potentiale for dybere ræsonnering, men højere omkostning og latenstid. I Claude 4-modeller bliver thinking-tokens faktureret, selv hvis du kun modtager en opsummeret visning.
• Opsummering og redigering: For mange Claude 4-modeller ser brugeren en opsummeret version af tænkningens indhold; noget intern ræsonnering kan blive redigeret (krypteret) af sikkerhedssystemer og returneret som redacted_thinking.
• Signaturer og verifikation: Tænkeblokke inkluderer en uigennemsigtig signature, der bruges til verifikation, når tænkeblokke sendes tilbage til API’et (særligt nødvendigt ved brug af værktøjer). Du bør betragte signaturen som uigennemsigtig — forsøg ikke at parse den.
• Interleavet tænkning med værktøjer: Claude 4 understøtter at interleave tænkeblokke med værktøjsudførelser (beta og i nogle tilfælde flag-baseret). Dette er kraftfuldt til agentiske workflows (kør værktøj, tænk, kør et andet værktøj osv.).

For praktiske eksempler og de mest opdaterede parametre er Anthropics Messages/Extended Thinking-dokumentation den kanoniske reference.

Hvordan returnerer Messages API tænkningens indhold

Opsummeret vs. fuld tænkning; kryptering og signaturer

Forskellige Claude 4-modelversioner håndterer tænkning forskelligt: nyere Claude 4-modeller (som Sonnet/Opus 4.5) returnerer ofte en opsummeret offentlig visning af den interne ræsonnering, mens den fulde kladde kan være krypteret og kun tilgængelig via et signature-felt (eller redigerede blokke). Når værktøjer bruges (eller du skal bevare den interne tilstand på tværs af værktøjskald), skal du sende tænkeblokke tilbage til API’et eller bruge signaturmekanismen, som dokumentationen beskriver. Denne mekanisme hjælper med at beskytte følsom intern ræsonnering, samtidig med at den tillader sikker fortsættelse af tankeprocessen, når det er nødvendigt.

Praktisk håndteringsmønster

Værktøjsbrug / fortsættelse: hvis din næste forespørgsel skal fortsætte den samme interne tilstand (f.eks. værktøjer blev kørt baseret på tænkningen), skal du inkludere den returnerede tænkeblok eller signatur, når du kalder API’et igen, så modellen kan dekryptere og fortsætte, hvor den slap.

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

Response: du kan modtage (a) en opsummeret offentlig output, (b) en krypteret signature eller redacted_thinking-blok eller (c) begge dele.

CometAPI tilbyder Claude 4.5 API’et til 20% af den officielle API-pris og kan også kaldes ved hjælp af Anthropic Messages. Du skal indhente en API-nøgle, før du begynder.

Eksempel 1 — simpel curl (ikke-streaming) med thinking aktiveret

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": "Design a robust data validation strategy for CSV imports, show tests + code."}
    ]
  }'

Svaret indeholder content-blokke. Inspicér hver blok og foretræk text-blokkene til endelig output; thinking-blokke indeholder modellens interne analy-seopsummering.

Eksempel 2 — Python: request, parse thinking- og text-blokke

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": "Explain how to do property-based testing in Python; include example code."}]
}

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

# Parse blocks
for block in resp.get("content", []):
    if block.get("type") == "thinking":
        thinking_summary = block.get("thinking")
        print("=== THINKING (summary) ===")
        print(thinking_summary[:1000])  # truncate for logs
        print("signature:", block.get("signature")[:64], "...")
    elif block.get("type") == "text":
        print("=== FINAL TEXT ===")
        print(block.get("text"))

Denne kode udtrækker og printer den opsummerede tænkning og det endelige svar. Hvis du skal bevare kontinuitet i agent-flows på flere ture, skal du inkludere de uændrede tænkeblokke i den næste forespørgsels messages-array (se næste eksempel).

Eksempel 3 — genbrug af tænkeblokke i et flerturn-flow (Python pseudo)

# After initial response (resp above):
# Add the assistant message including the thinking block back into the conversation
assistant_message = {
  "role": "assistant",
  "content": resp["content"]  # include raw content array (contains thinking + text blocks)
}

# Next user turn: ask follow-up and include previous assistant message
payload2 = {
  "model": "claude-opus-4-5",  # Opus preserves thinking blocks better across turns
  "max_tokens": 20000,
  "thinking": {"type": "enabled", "budget_tokens": 12000},
  "messages": [
    {"role": "user", "content": "Now adapt the validation logic for an avro pipeline."},
    assistant_message
  ]
}
r2 = requests.post(URL, headers=HEADERS, json=payload2)

Bevarelse af præcist uændrede tænkeblokke er kritisk ved værktøjsintegrerede eller lange agent-workflows. Opus 4.5 har forbedrede standarder for bevaring og caching af tænkeblokke.

Hvordan streamer jeg thinking-outputs og viser fremdrift i et UI?

Streaming-best practices

• Brug SDK’ernes streaming-endpoints (Python/TypeScript SDK’erne har stream-hjælpere). For langvarige eller højbudgetterede ræsonneringsjobs forhindrer streaming HTTP-timeouts og giver dig delvis tekst, mens modellen beregner. Typisk kode bruger en iterator over text_stream (Python) eller event-parsing (JS).
• Forvent nogle gange to-fase streams: modellen kan først producere synlige ræsonneringsstykker og derefter afslutte med svaret. Byg dit UI til at håndtere chunket indhold og vise “tænker…” vs. endeligt svar.
• Hvis API’et returnerer en signature_delta eller content_block_delta under streaming, skal du fange den og vedhæfte den til efterfølgende kald som krævet af specifikationen.

Hvis du skal vise mellemregninger af ræsonnering i et UI, så stream svaret. Serveren vil udsende thinking_delta-events efterfulgt af 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": "Walk me through debugging this failing unit test and propose fixes." } ]
  }'

Ved streaming skal du håndtere content_block_start, content_block_delta (som inkluderer thinking_delta og text_delta) og content_block_stop-events i rækkefølge. Det er sådan, du kan vise modellens trin-for-trin-ræsonnering, mens den sker.

Hvordan interagerer Claude Code med thinking mode? (terminal + VS Code)

Claude Code er den interaktive, agentiske kodningsterminal, der integrerer Messages API’et og værktøjsrunners. CLI/IDE-oplevelsen eksponerer tænkning på to måder:

• Globale / pr.-session indstillinger: Claude Code eksponerer et /config-indstillingspanel til at justere adfærd (hvordan agenten beder om tilladelser, om tænkeblokke skal bevares osv.). Brug den UI i stedet for at indtaste rå JSON, hvis du vil have en vedvarende adfærdsændring.
• Modelvalg og CLI-kommandoer: Du kan vælge claude-sonnet-4-5 eller claude-opus-4-5 som den aktive model i REPL; værktøjerne og thinking-adfærden følger derefter Messages API-semantikken. CHANGELOG’en og release-noterne angiver, at tænkning nu er aktiveret som standard for nogle Opus 4.5-implementeringer, og at thinking-konfigurationen er synlig via /config.

Praktisk flow i Claude Code:

1. Start et projekt i REPL’en.
2. Brug /config til at inspicere thinking-relaterede flag (bevarelse, ordrighed osv.).
3. Bed agenten om at køre en lang opgave — den vil producere thinking-indhold og, om nødvendigt, bede om tilladelse til at køre bestemte bash-trin. Bevar tænkeblokke, når du skal verificere eller genkøre beslutninger senere.

Installation og opsætning

Claude Code kræver Node.js og kan installeres globalt.

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

# Authenticate
claude-code --init

Aktivering af Thinking i terminalen

Claude Code understøtter forskellige flag og naturlige sprogtriggere til at styre dybden af dens ræsonnering.

Tips:

• Brug think/think harder, når du vil have agenten til at udforske alternative implementeringer.
• Når Claude Code udfører værktøjskald (køre tests, git-operationer), skal du bevare eventuelle thinking-blokke, hvis CLI/agenten returnerer dem; ellers kan agenten miste kontekst mellem trinene.

Fordele ved interleavet tænkning og blokbevarelse

For avancerede agentiske workflows introducerer Claude 4.5 to beta-funktioner, der væsentligt forbedrer flertursinteraktioner og værktøjsbrug: Interleaved Thinking og Thinking Block Preservation.

Interleaved Thinking (Beta)

Standardræsonnering sker én gang før output. Interleaved Thinking (aktiveret via interleaved-thinking-2025-05-14-headeren) tillader Claude at “tænke” mellem værktøjskald.

Forestil dig, at Claude debugger en server:

1. Think: "I should check the logs first."
2. Tool Call: read_file(logs.txt)
3. Think: "The logs show a database timeout. Now I need to check the connection pool settings."
4. Tool Call: read_file(db_config.yml)

Denne “kontinuerlige refleksion” sikrer, at modellen tilpasser sin strategi baseret på de data, den modtager fra værktøjer, fremfor at følge en rigid, foruddefineret plan.

Thinking Block Preservation

I flerturs-samtaler, især dem der involverer brug af værktøjer, er det kritisk at sende de tidligere thinking-blokke tilbage til API’et.

• Ræsonneringskontinuitet: Ved at modtage sine tidligere tanker bevarer Claude den logiske kontekst for sin rejse.
• Opus 4.5-optimering: I Claude Opus 4.5 er denne adfærd automatiseret. Modellen bevarer alle tidligere tænkeblokke i sin kontekst som standard, hvilket sikrer, at selv i sessioner på 30+ timer glemmer modellen ikke, hvorfor den traf bestemte arkitekturbeslutninger ti ture tidligere.

Best practices for brug af THINKING mode med Claude 4.5

Vælg den rigtige model og det rigtige budget til opgaven:

Brug Sonnet 4.5 til kodning og agentiske workflows, hvor du har brug for den bedste afvejning mellem hastighed, omkostning og stærke kodningsevner; brug Opus 4.5 til den dybeste ræsonnering og de største kontekstvinduer eller når du planlægger at køre lange autonome sessioner. Begge understøtter udvidet tænkning. Vælg budget_tokens proportionalt med opgavens kompleksitet (start småt til eksperimenter; hæv budgettet kun hvis du observerer materielle kvalitetsforbedringer).

Overvåg og kontroller omkostning og latenstid

Du bliver opkrævet for alle de thinking-tokens, Claude producerer, ikke den opsummerede output, du modtager. Det betyder, at lange interne overvejelser øger omkostningen, selv hvis du kun ser en kort opsummering. Spor tokenforbrug og overvej gradvis tuning (for eksempel: 2k → 8k → 32k), når du går fra udforskning til produktion.

Bevar tænkeblokke kun når nødvendigt

Tænkeblokke kan være kryptografisk signerede og bevares til senere verifikation og til interleavet værktøjsbrug. Undgå at ekkoe tænkeblokke i hver efterfølgende forespørgsel, medmindre dit workflow kræver, at modellen beholder sine tidligere interne overvejelser (for eksempel når en agent vil genkøre trin og har brug for de bevarede begrundelser). At bevare tænkning hele tiden øger kontekstvolumen og kan komplicere tokenregnskabet.

Hvornår du skal streame tænkning til brugere

Streamet tænkning er fremragende til udviklerværktøjer og undervisningsorienterede UI’er (vis “arbejde i gang”, mens modellen overvejer). Stream ikke rå tænkning til slutbrugere af forbrugerrettede produktionsapps uden at overveje sikkerhed og redigering: opsummeret tænkning findes netop af denne grund. Hvis du streamer, så giv UI-mekanismer, der markerer intern ræsonnering (f.eks. “Assistant reasoning — internal”), og styr om den endelige bruger ser den opsummerede eller den fulde ræsonnering.

Værktøjsbrug og interleaving

Når du kombinerer tænkning med værktøjer (kodekørsel, webhentning, lokale processer), skal du bruge designet med interleavet tænkning, når du har brug for, at modellen vælger værktøjer, kører dem og ræsonnerer over resultaterne i samme tur. Interleaving øger kompleksiteten (og kan kræve feature flags), men er kraftfuld til agentisk automatisering. Vær eksplicit om, hvilken tænkning du bevarer, og test hvordan modellen vælger værktøjer under en kørsel med thinking aktiveret.

Praktisk fejlfinding og driftsnoter

Almindelige fejl og hvad de betyder

• Ugyldig tænkning + tvungen værktøjsvalg: Hvis du anmoder om tænkning, men også tvinger særlige værktøjs-brugstilstande, der er inkompatible med tænkning, returnerer API’et en fejl — bland ikke tvungen tool_choice: {"type":"tool","name":"..."} med tænkning.
• Budget > max_tokens: For scenarier med interleavet tænkning er de effektive tokenregler anderledes — platformens dokumentation forklarer, hvornår budget_tokens kan overstige max_tokens. Læs afsnittet om “interleaved thinking” grundigt, før du tester store budgetter.
• Signaturvalidering: Hvis du bevarer tænkeblokke til senere kald, skal du inkludere den returnerede signature, så API’et kan verificere, at de kom fra Claude; dette forhindrer manipulation og holder kæden verificerbar.

Observabilitet og instrumentering

Log: (1) valg af model, (2) thinking.budget_tokens, (3) faktisk forbrug af thinking-tokens (du bliver faktureret for det), (4) streaming-latenser (tid til første thinking_delta) og (5) endelige teksttokens. Brug disse metrikker til at opbygge budgetter og SLO’er for brugerrettede flows.

Progressiv udrulning og mennesket-i-løkken

Rul modeller med thinking aktiveret ud bag feature flags. Start med en procentdel af udvikler- eller intern trafik, indsam-l fejl eller redigeringer, og iterér prompts og budgetter. For følsomme domæner kræv menneskelig gennemgang af outputs, der indeholder substantiel intern ræsonnering, før frigivelse.

Debugging-tips

• Start småt: aktiver lave budget_tokens og skaler op for at forstå inkrementelle forbedringer.
• Slå streaming til og log content_block_delta / signature-events for at forstå, hvornår modellen producerer tænkeblokke.
• Hvis du bruger Claude Code: tjek /config og projekt-niveau indstillinger; konsulter Claude Code changelog, hvis adfærden ikke matcher forventede standarder.

Konklusion:

Claude 4.5, kombineret med kraften i Extended Thinking og Claude Code CLI, repræsenterer det mest betydelige spring i udviklerproduktivitet siden opfindelsen af IDE’en. Ved at lade modellen “vise sit arbejde” og overveje komplekse problemer har Anthropic bevæget sig ud over “chatbot”-æraen og ind i “agent”-æraen.

Uanset om du integrerer Messages API’et i et tilpasset dev-værktøj eller bruger Claude Code til at håndtere dine daglige PR’er, er det essentielt at mestre Thinking Mode. Det giver den gennemsigtighed, der er nødvendig for tillid, og den ræsonneringsdybde, der er nødvendig for topkvalitet.

Udviklere kan få adgang til Claude 4.5 (Claude Sonnet 4.5 , Claude Haiku 4.5, Claude Opus 4.5) modellen via CometAPI. For at komme i gang skal du udforske modelkapabiliteterne i CometAPI i Playground og konsultere API-guiden for detaljerede instruktioner. Før adgang skal du sikre, at du er logget ind på CometAPI og har indhentet API-nøglen. CometAPI tilbyder en pris langt under den officielle pris for at hjælpe dig med integrationen.

Klar til at gå i gang?→ Gratis prøve af Claude 4.5!