Sådan bruger du thinking mode i claude 4.5

"Thinking mode" (også kaldet udvidet tænkning, tænkning eller tænkningsblokke) i Claude 4.5 er en eksplicit, konfigurerbar driftsmåte, der instruerer modellen i at bruge et separat budgetteret antal tokens på intern, trinvis ræsonnering (en “chain-of-thought”) før den afgiver det endelige svar. Den er designet til at forbedre ydeevnen på flertrinsræsonnering, kompleks kodning og agentiske workflows samt forskning ved at bytte latens og tokenomkostning for dybere intern overvejelse. Claude 4.5 udstiller denne funktionalitet på Messages API-niveau med eksplicitte parametre (f.eks. thinking / budget_tokens eller en effort/“interleaved-thinking”-header), bevarer og kan valgfrit kryptere tænkningsblokke til senere verifikation eller værktøjsbrug og introducerer cache- og tokenregnskabsadfærd, som du skal håndtere i produktionsarbejdslaster.

Hvad er Claude 4.5? (Og hvilke modeller skal jeg interessere mig for?)

Claude 4.5 er Anthropics seneste sæt 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-effort ræsonnering og bevarer tænkningsblokke for at forbedre kontinuiteten i flere omgange. Begge modeller understøtter Claudes udvidede tænkning, selvom noget adfærd (f.eks. sammenfattet vs. fuld tænkning) varierer mellem modellerne.

Ydelsesforbedringerne i Claude 4.5, især i Sonnet 4.5, ses tydeligst i benchmarken SWE-bench Verified, der 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 indgriben.

Hvorfor det er vigtigt

• Kodning & agenter: Sonnet 4.5 viser stærke forbedringer på virkelige softwareopgaver og langhorisont-kodningsarbejde—hvilket gør den til et naturligt valg for kodegenerering, kode-redigering og autonome agentflows.
• Udvidet tænkning & kontekst: Claude 4.5-familien er bygget til at ræsonnere med meget store interne notesblokke (titusinder af tokens eller mere), hvilket muliggør dybere flertrinsræsonnering. Det ændrer, hvordan du designer prompts, tokenbudgetter og værktøjsinteraktioner.

Hvad er Thinking Mode i Claude 4.5?

Thinking Mode (officielt betegnet "Extended Thinking") er en funktion, der lader modellen "vise sit arbejde" for sig selv, før den leverer en endelig output. I modsætning til standardmodeller, der straks forpligter sig til et svar, bruger Claude 4.5 et dedikeret ræsonneringsrum til at udforske flere hypoteser, identificere potentielle fejl i sin logik og finpudse sin strategi.

Opbygningen af et svar

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

Nøgleegenskaber ved tænkningstilstanden

• Aktiveres efter 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 begrænser modellens interne ræsonneringstokens. Mere budget => større potentiale for dybere ræsonnering, men højere omkostning og latens. I Claude 4-modeller faktureres tænknings-tokens, selv hvis du kun modtager en sammenfattet visning.
• Sammenfatning & tilsløring: For mange Claude 4-modeller ser brugeren en sammenfattet version af tænkningen; noget intern ræsonnering kan være tilsløret (krypteret) af sikkerhedssystemer og returneres som redacted_thinking.
• Signaturer & verifikation: Tænkningsblokke inkluderer en ugennemsigtig signature, der bruges til verifikation ved returnering af tænkningsblokke til API'et (især nødvendigt ved brug af værktøjer). Du bør behandle signaturen som ugennemsigtig—forsøg ikke at parse den.
• Indflettet tænkning med værktøjer: Claude 4 understøtter indfletning af tænkningsblokke med værktøjskørsler (beta og flagbaseret i nogle tilfælde). Dette er stærkt til agentisk arbejde (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

Sammenfattet vs. fuld tænkning; kryptering & signaturer

Forskellige Claude-modelversioner håndterer tænkning forskelligt: nyere Claude 4-modeller (som Sonnet/Opus 4.5) returnerer ofte en sammenfattet offentlig visning af den interne ræsonnering, mens den fulde notesblok kan være krypteret og kun tilgængelig via et signature-felt (eller tilslørede blokke). Når værktøjer bruges (eller du skal bevare den interne tilstand på tværs af værktøjsopkald), skal du videregive tænkningsblokke tilbage til API'et eller bruge den signaturmekanisme, som dokumentationen beskriver. Denne mekanisme hjælper med at beskytte sensitiv intern ræsonnering samtidig med, at en sikker fortsættelse af tankeprocessen tillades, når det er nødvendigt.

Praktisk håndteringsmønster

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

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

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

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

Eksempel 1 — simpel curl (ikke-streaming), der aktiverer tænkning

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 vil indeholde content-blokke. Inspicer hver blok og foretræk text-blokke til den endelige output; thinking-blokke indeholder modellens interne analysersammenfatning.

Eksempel 2 — Python: request, parse tænknings- og tekstblokke

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 udskriver den sammenfattede tænkning og det endelige svar. Hvis du skal bevare kontinuitet i fleromgangs-agentflows, inkluder de uændrede tænkningsblokke i næste requests messages-array (se næste eksempel).

Eksempel 3 — genbrug af tænkningsblokke i et fleromgangsflow (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ænkningsblokke er kritisk ved værktøjsintegrerede eller lange agent-workflows. Opus 4.5 har forbedrede standarder for bevarelse af tænkningsblokke og caching.

Hvordan streamer jeg tænkningsoutput og viser fremdrift i en UI?

Bedste praksis for streaming

• Brug SDK-streamingendpoints (Python/TypeScript-SDK'erne har stream-hjælpere). Til langvarige eller høj-budget 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 din UI til at håndtere chunket indhold og til at vise “tænker…” vs. endeligt svar.
• Hvis API'et returnerer en signature_delta eller content_block_delta under streaming, fang det og vedhæft det til efterfølgende kald som krævet af specifikationen.

Hvis du skal vise mellemliggende ræsonneringsfremskridt i en UI, skal du streame 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 tænkningstilstanden? (terminal + VS Code)

Claude Code er den interaktive, agentiske kodningsterminal, der integrerer Messages API og værktøjsløbere. 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ænkningsblokke bevares osv.). Brug den UI i stedet for at indtaste rå JSON, hvis du vil have en vedvarende adfærdsændring.
• Modelvalg & CLI-kommandoer: Du kan vælge claude-sonnet-4-5 eller claude-opus-4-5 som aktiv model i REPL; værktøjerne og tænkningens adfærd følger derefter Messages API-semantikken. CHANGELOG'en og release-noterne indikerer, at tænkning nu er aktiveret som standard for nogle Opus 4.5-udrulninger, og at tænkningens konfiguration er synlig via /config.

Praktisk forløb i Claude Code:

1. Start et projekt i REPL.
2. Brug /config til at inspicere tænkning-relaterede flag (bevarelse, verbositet osv.).
3. Bed agenten om at køre en lang opgave—den vil producere tænkning og, hvis nødvendigt, bede om tilladelse til at køre bestemte bash-trin. Bevar tænkningsblokke, 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 tænkning i terminalen

Claude Code understøtter forskellige flag og naturlige sprogtrigger 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øjsopkald (kører tests, git-operationer), bevar eventuelle thinking-blokke, hvis CLI/agenten returnerer dem; ellers kan agenten miste kontekst mellem trin.

Fordele ved indflettet tænkning og blokbevarelse

For avancerede agentiske workflows introducerer Claude 4.5 to beta-funktioner, der væsentligt forbedrer fleromgangsinteraktioner og værktøjsbrug: Indflettet tænkning og Bevarelse af tænkningsblokke.

Indflettet tænkning (Beta)

Standardræsonnering sker én gang før output. Indflettet tænkning (aktiveret via interleaved-thinking-2025-05-14-headeren) tillader Claude at "tænke" mellem værktøjsopkald.

Forestil dig, at Claude debugger en server:

1. Tænk: "I should check the logs first."
2. Værktøjsopkald: read_file(logs.txt)
3. Tænk: "The logs show a database timeout. Now I need to check the connection pool settings."
4. Værktøjsopkald: read_file(db_config.yml)

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

Bevarelse af tænkningsblokke

I fleromgangssamtaler, især dem der involverer værktøjsbrug, er det kritisk at videregive tidligere thinking-blokke tilbage til API'et.

• Ræsonneringskontinuitet: Ved at modtage sine tidligere tanker bevarer Claude den logiske kontekst af sin rejse.
• Opus 4.5-optimering: I Claude Opus 4.5 er denne adfærd automatiseret. Modellen bevarer alle tidligere tænkningsblokke i sin kontekst som standard, hvilket sikrer, at selv i sessioner, der varer 30+ timer, glemmer modellen ikke, hvorfor den traf visse arkitektoniske beslutninger ti omgange tilbage.

Bedste praksis for brug af TÆNKNINGstilstand med Claude 4.5

Vælg den rigtige model og det rette 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 kodeevner; 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 ved eksperimenter; øg budgettet kun, hvis du observerer materielle kvalitetsforbedringer).

Overvåg og kontroller omkostning & latens

Du bliver faktureret for de fulde tænknings-tokens, Claude genererer, ikke den sammenfattede output, du modtager. Det betyder, at lange interne overvejelser øger omkostningen, selv hvis du kun ser en kort sammenfatning. Spor tokenforbrug og overvej gradvis tuning (for eksempel: 2k → 8k → 32k), når du går fra udforskning til produktion.

Bevar tænkningsblokke kun når det er nødvendigt

Tænkningsblokke kan være kryptografisk signerede og bevaret til senere verifikation og til indflettet værktøjsbrug. Undgå at ekko tænkningsblokke i hver efterfølgende request, medmindre dit workflow kræver, at modellen bevarer sin tidligere interne overvejelse (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 uddannelses-UI'er (der viser “arbejde i gang”, mens modellen overvejer). Stream ikke rå tænkning til slutbrugere af produktionsorienterede forbrugerapps uden at overveje sikkerhed og tilsløring: sammenfattet tænkning findes netop af den grund. Hvis du streamer, giv UI-mekanismer, der markerer intern ræsonnering (f.eks. “Assistent-ræsonnering — intern”), og styr om den endelige bruger ser den sammenfattede eller den fulde ræsonnering.

Værktøjsbrug og indfletning

Når du kombinerer tænkning med værktøjer (kodekørsel, web-fetch, lokale processer), brug designet for indflettet 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 omgang. Indfletning øger kompleksiteten (og kan kræve feature-flags), men er kraftfuldt til agentisk automatisering. Vær eksplicit om, hvilken tænkning du bevarer, og test hvordan modellen vælger værktøjer under en tænkning-aktiveret kørsel.

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 bestemte værktøjsbrugsmodi, der er inkompatible med tænkning, returnerer API'et en fejl—kombinér ikke tvunget tool_choice: {"type":"tool","name":"..."} med tænkning.
• Budget > max_tokens: For indflettede tænkning-scenarier er de effektive tokenregler anderledes—platformsdokumenterne forklarer, hvornår budget_tokens kan overstige max_tokens. Læs afsnittet om “interleaved thinking” nøje, før du tester store budgetter.
• Signaturvalidering: Hvis du bevarer tænkningsblokke til senere kald, inkluder den returnerede signature, så API'et kan verificere, at de stammer fra Claude; det forhindrer manipulation og holder kæden verificerbar.

Observability og instrumentering

Log: (1) model-valg, (2) thinking.budget_tokens, (3) faktisk forbrug af tænknings-tokens (du faktureres for det), (4) streaminglatens (tid til første thinking_delta) og (5) endelige teksttokens. Brug disse metrikker til at bygge budgetter og SLO'er for brugerrettede flows.

Progressiv udrulning & menneske-i-loop

Rul tænkningsaktiverede modeller ud bag feature-flags. Start med en procentdel af udvikler- eller intern trafik, indsamle fejl eller tilsløringer og iterér prompts og budgetter. For følsomme domæner kræv menneskelig gennemgang af outputs, der inkluderer substantiel intern ræsonnering, før frigivelse.

Fejlfindingsråd

• Start småt: aktiver lav budget_tokens og skalér op for at forstå gradvise forbedringer.
• Slå streaming til og log content_block_delta / signatur-events for at forstå, hvornår modellen producerer tænkningsblokke.
• Hvis du bruger Claude Code: tjek /config og projekt-niveau indstillinger; konsulter Claude Code-changelog'et, 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 betydningsfulde 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 den “agentiske” æra.

Uanset om du integrerer Messages API i et skræddersyet 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 transparens, der er nødvendig for tillid, og den ræsonneringsdybde, der er nødvendig for excellence.

Udviklere kan få adgang til Claude 4.5 (Claude Sonnet 4.5 , Claude Haiku 4.5, Claude Opus 4.5) gennem CometAPI. For at komme i gang kan du udforske modelkapabiliteterne i CometAPI i Playground og konsultere API-guiden for detaljerede instruktioner. Før du 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!