Hvordan bruker man tenkemodus i Claude 4.5?

“Thinking mode” (også kalt utvidet tenkning, tenkning eller tenkeblokker) i Claude 4.5 er en eksplisitt, konfigurerbar driftsmodus som instruerer modellen til å bruke et separat tokenbudsjett på å generere intern, trinnvis resonnement (en “tankerekke”) før den leverer det endelige svaret. Den er utformet for å forbedre ytelsen på flerstegsresonnement, kompleks koding og agentbaserte arbeidsflyter, samt forskning, ved å bytte økt ventetid og tokenskost mot dypere intern overveielse. Claude 4.5 eksponerer denne kapasiteten på Messages API-nivået med eksplisitte parametere (f.eks. thinking / budget_tokens eller en innsats-/“interleaved-thinking”-header), bevarer og kan valgfritt kryptere tenkeblokker for senere verifisering eller verktøybruk, og introduserer bufrings- og token-regnskapsatferd som du må håndtere når du bygger produksjonsbelastninger.

Hva er Claude 4.5? (Og hvilke modeller bør jeg bry meg om?)

Claude 4.5 er Anthropics nyeste sett med Claude-modeller, utgitt som inkrementelle “4.5”-oppdateringer (for eksempel Sonnet 4.5 og Opus 4.5). Sonnet 4.5 er posisjonert som den beste balansen av intelligens, koding og agentisk ytelse for de fleste utviklere; Opus 4.5 fokuserer på svært høyinnsats resonnement og bevarer tenkeblokker for å forbedre kontinuiteten over flere omganger. Begge modellene støtter Claudes utvidede tenkning, selv om noe atferd (f.eks. oppsummert vs. full tenkning) varierer mellom modeller.

Ytelsesforbedringene i Claude 4.5, særlig i Sonnet 4.5, er mest synlige i benchmarken SWE-bench Verified, som måler en AIs evne til å løse virkelige GitHub-issues.

Disse tallene indikerer at Claude 4.5 ikke bare er bedre til å skrive snutter; den er betydelig mer kapabel til å navigere hele filsystemer og utføre autonome oppgaver uten menneskelig inngripen.

Hvorfor dette er viktig

• Koding og agenter: Sonnet 4.5 viser sterke gevinster på programvareoppgaver i den virkelige verden og langhorisont-koding—noe som gjør den til et naturlig valg for kodegenerering, kodeendring og autonome agentflyter.
• Utvidet tenkning og kontekst: Modellene i Claude 4.5-familien er bygget for å resonnere med svært store interne notatblokker (titalls tusen tokens eller mer), som muliggjør dypere flerstegsresonnement. Det endrer hvordan du designer promter, tokenbudsjetter og verktøyinteraksjoner.

Hva er tenkemodus i Claude 4.5?

Tenkemodus (offisielt kalt "Extended Thinking") er en kapasitet som lar modellen “vise arbeidet sitt” for seg selv før den leverer en endelig utdata. I motsetning til standardmodeller som låser svaret umiddelbart, bruker Claude 4.5 en dedikert resonnementssone for å utforske flere hypoteser, identifisere potensielle feil i logikken, og raffinere strategien.

Anatomien til et svar

I en standardinteraksjon mottar modellen en prompt og begynner å generere svaret. I tenkemodus deles responsen i to distinkte blokker:

Nøkkel-egenskaper for tenkemodus

• Aktiveres på forespørsel: Du sender et thinking-objekt i API-kallet som {"type":"enabled","budget_tokens":10000} for å slå det på og gi modellen et internt tokenbudsjett for resonnement.
• Budsjettering: budget_tokens begrenser modellens interne resonnementstokens. Mer budsjett => dypere resonnementspotensial, men høyere kostnad og ventetid. I Claude 4-modeller blir tenkningstokens fakturert selv om du bare mottar en oppsummert visning.
• Oppsummering og redaksjon: For mange Claude 4-modeller ser brukeren en oppsummert versjon av tenkingsinnholdet; noe intern tenkning kan være redigert (kryptert) av sikkerhetssystemer og returneres som redacted_thinking.
• Signaturer og verifisering: Tenkeblokker inkluderer en ugjennomsiktig signature som brukes til verifisering når tenkeblokker sendes tilbake til API-et (særlig nødvendig ved bruk av verktøy). Du bør behandle signaturen som ugjennomsiktig—ikke forsøk å tolke den.
• Interlevert tenkning med verktøy: Claude 4 støtter å veksle mellom tenkeblokker og verktøykjøringer (beta og noen ganger flaggbasert). Dette er kraftig for agentisk arbeid (kjør verktøy, tenk, kjør et annet verktøy, osv.).

For praktiske eksempler og de mest oppdaterte parameterne er Anthropics Messages/Extended Thinking-dokumenter den kanoniske referansen.

Hvordan returnerer Messages API tenkeinnhold

Oppsummert vs. full tenkning; kryptering og signaturer

Forskjellige Claude 4-modellversjoner håndterer tenkning ulikt: nyere modeller (som Sonnet/Opus 4.5) returnerer ofte en oppsummert offentlig visning av det interne resonnementet, mens hele notatblokken kan være kryptert og kun tilgjengelig via et signature-felt (eller redigerte blokker). Når verktøy brukes (eller du trenger å bevare intern tilstand på tvers av verktøykall), må du sende tenkeblokkene tilbake til API-et eller bruke signaturmekanismen som dokumentasjonen beskriver. Denne mekanismen bidrar til å beskytte sensitiv intern tenkning samtidig som den tillater trygg videreføring av tankeprosessen ved behov.

Praktisk håndteringsmønster

Verktøybruk / videreføring: Hvis neste forespørsel må fortsette samme interne tilstand (f.eks. verktøy ble kjørt basert på tenkingen), inkluder de returnerte tenkeblokkene eller signaturen når du kaller API-et på nytt, slik at modellen kan dekryptere og fortsette der den slapp.

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

Response: du kan motta (a) en oppsummert offentlig utdata, (b) en kryptert signature eller redacted_thinking-blokk, eller (c) begge.

CometAPI tilbyr Claude 4.5-API-et til 20% av den offisielle API-prisen, og det kan også kalles via Anthropic Messages. Du må skaffe en API-nøkkel før du begynner.

Eksempel 1 — enkel curl (ikke-strømmende) med tenkning aktivert

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."}
    ]
  }'

Responsen vil inneholde content-blokker. Inspiser hver blokk og bruk text-blokker for endelig utdata; thinking-blokker inneholder modellens interne analysesammendrag.

Eksempel 2 — Python: forespørsel, parse tenking og tekstblokker

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 koden ekstraherer og skriver ut den oppsummerte tenkingen og det endelige svaret. Hvis du trenger å bevare kontinuitet i fleromgangs agentflyter, inkluder uendrede tenkeblokker i neste forespørsels messages-array (se neste eksempel).

Eksempel 3 — gjenbruk av tenkeblokker i en fleromgangs flyt (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)

Å bevare nøyaktig uendrede tenkeblokker er kritisk ved verktøyintegrerte eller lange agentarbeidsflyter. Opus 4.5 har forbedrede standarder for bevaring og caching av tenkeblokker.

Hvordan kan jeg strømme tenkeutdata og vise fremdrift i et UI?

Beste praksis for strømming

• Bruk SDK-endenepunkter for strømming (Python/TypeScript-SDK-ene har strømmehjelpere). For langvarige eller høyt budsjetterte resonnementjobber forhindrer strømming HTTP-timeouts og gir deg deltekst mens modellen beregner. Typisk kode bruker en iterator over text_stream (Python) eller hendelsesparsing (JS).
• Forvent av og til tofasede strømmer: Modellen kan først produsere synlige resonnementsbiter, og deretter fullføre med svaret. Bygg UI-et ditt for å håndtere oppstykket innhold og vise tilstandene “tenker …” vs. endelig svar.
• Hvis API-et returnerer en signature_delta eller content_block_delta ved strømming, fang den og legg den ved påfølgende kall i henhold til spesifikasjonen.

Hvis du trenger å vise mellomliggende resonnement i et UI, strømm responsen. Serveren vil sende thinking_delta-hendelser etterfulgt av text_delta-hendelser.

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 strømming, håndter content_block_start, content_block_delta (som inkluderer thinking_delta og text_delta), og content_block_stop-hendelser i rekkefølge. Slik kan du vise modellens trinnvise resonnement mens det skjer.

Hvordan samspiller Claude Code med tenkemodus? (terminal + VS Code)

Claude Code er den interaktive, agentiske kodeterminalen som integrerer Messages API og verktøykjørere. CLI/IDE-opplevelsen eksponerer tenkning på to måter:

• Globale / per-økt-innstillinger: Claude Code eksponerer et /config-innstillingspanel for å justere atferd (hvordan agenten ber om tillatelser, om tenkeblokker skal bevares, osv.). Bruk denne UI-en i stedet for å skrive rå JSON hvis du ønsker en vedvarende atferdsendring.
• Modellvalg og CLI-kommandoer: Du kan velge claude-sonnet-4-5 eller claude-opus-4-5 som aktiv modell i REPL; verktøyene og tenkningsatferden følger da Messages API-semantikken. CHANGELOG og utgivelsesnotater indikerer at tenkning nå er aktivert som standard for noen Opus 4.5-distribusjoner, og at tenkningskonfigurasjon eksponeres via /config.

Praktisk flyt i Claude Code:

1. Start et prosjekt i REPL.
2. Bruk /config for å inspisere tenkningsrelaterte flagg (bevaring, verbositet, osv.).
3. Be agenten kjøre en lang oppgave—den vil produsere tenkeinnhold og, ved behov, be om tillatelse til å kjøre bestemte bash-trinn. Bevar tenkeblokkene når du trenger å verifisere eller kjøre beslutninger på nytt senere.

Installasjon og oppsett

Claude Code krever Node.js og kan installeres globalt.

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

# Authenticate
claude-code --init

Aktivere tenkning i terminalen

Claude Code støtter ulike flagg og naturlige språk-utløsere for å kontrollere resonnementsdyp.

Tips:

• Bruk think/think harder når du vil at agenten skal utforske alternative implementeringer.
• Når Claude Code utfører verktøykall (kjører tester, git-operasjoner), bevar eventuelle thinking-blokker hvis CLI/agenten returnerer dem; ellers kan agenten miste kontekst mellom trinn.

Fordeler med interlevert tenkning og blokkbevaring

For avanserte agentiske arbeidsflyter introduserer Claude 4.5 to beta-funksjoner som vesentlig forbedrer fleromgangsinteraksjoner og verktøybruk: Interlevert tenkning og bevaring av tenkeblokker.

Interlevert tenkning (beta)

Standard resonnement skjer én gang før utdata. Interlevert tenkning (aktivert via headeren interleaved-thinking-2025-05-14) lar Claude “tenke” mellom verktøykall.

Tenk deg at Claude feilsøker en server:

1. Tenk: "Jeg bør sjekke loggene først."
2. Verktøykall: read_file(logs.txt)
3. Tenk: "Loggene viser en database-timeout. Nå må jeg sjekke innstillingene for tilkoblingspoolen."
4. Verktøykall: read_file(db_config.yml)

Denne “kontinuerlige refleksjonen” sikrer at modellen tilpasser strategien basert på dataene den mottar fra verktøy, i stedet for å følge en rigid, forhåndsdefinert plan.

Bevaring av tenkeblokker

I fleromgangssamtaler, spesielt de som involverer verktøybruk, er det kritisk å sende forrige thinking-blokker tilbake til API-et.

• Kontinuitet i resonnement: Ved å motta sine tidligere tanker, opprettholder Claude den logiske konteksten for reisen sin.
• Opus 4.5-optimalisering: I Claude Opus 4.5 er denne atferden automatisert. Modellen bevarer alle tidligere tenkeblokker i konteksten som standard, slik at selv i økter som varer 30+ timer, “glemmer” ikke modellen hvorfor den tok visse arkitekturvalg ti omganger tidligere.

Beste praksis for bruk av THINKING-modus med Claude 4.5

Velg riktig modell og budsjett for oppgaven:

Bruk Sonnet 4.5 for koding og agentiske arbeidsflyter der du trenger den beste avveiningen mellom hastighet, kostnad og sterke kodeevner; bruk Opus 4.5 for det dypeste resonnementet og de største kontekstvinduene eller når du planlegger lange autonome økter. Begge støtter utvidet tenkning. Velg budget_tokens proporsjonalt med oppgavens kompleksitet (start smått for eksperimenter; øk budsjettet kun hvis du observerer materielle kvalitetsforbedringer).

Overvåk og kontroller kostnad og ventetid

Du blir belastet for alle tenkningstokens Claude produserer, ikke den oppsummerte utgaven du mottar. Det betyr at lang intern overveielse øker kostnaden selv om du bare ser en kort oppsummering. Spor tokenbruk og vurder gradvis tuning (for eksempel: 2k → 8k → 32k) når du går fra utforskning til produksjon.

Bevar tenkeblokker bare når nødvendig

Tenkeblokker kan være kryptografisk signert og bevart for senere verifisering og interlevert verktøybruk. Unngå å ekko-tenke blokker i hver påfølgende forespørsel med mindre arbeidsflyten din krever at modellen beholder tidligere interne overveielser (for eksempel når en agent skal kjøre trinn på nytt og trenger bevarte begrunnelser). Å bevare tenking hele tiden øker kontekstvolumet og kan komplisere tokenregnskapet.

Når du bør strømme tenkning til brukere

Strømmet tenkning er utmerket for utviklerverktøy og opplærings-UI-er (vise “arbeid pågår” mens modellen overveier). Ikke strøm rå tenkning til sluttbrukere av produksjonsrettede forbrukerapper uten å vurdere sikkerhet og redigering: oppsummert tenkning finnes nettopp av denne grunn. Hvis du strømmer, tilby UI-fasiliteter som merker intern tenkning (f.eks. “Assistant reasoning — intern”), og kontroller om sluttbrukeren ser den oppsummerte eller fulle tenkingen.

Verktøybruk og interleaving

Når du kombinerer tenkning med verktøy (kodekjøring, web-henting, lokale prosesser), bruk designet for interlevert tenkning når du trenger at modellen skal velge verktøy, kjøre dem og resonnere på resultater i samme omgang. Interleaving øker kompleksiteten (og kan kreve funksjonsflagg) men er kraftig for agentisk automatisering. Vær eksplisitt om hvilken tenking du bevarer, og test hvordan modellen velger verktøy under en kjøring med tenking aktivert.

Praktisk feilsøking og operasjonelle merknader

Vanlige feil og hva de betyr

• Ugyldig tenkning + tvunget verktøyvalg: Hvis du ber om tenkning men også tvinger bestemte verktøybruk-moduser som er inkompatible med tenkning, vil API-et returnere en feil—ikke bland tvungen tool_choice: {"type":"tool","name":"..."} med tenkning.
• Budsjett > max_tokens: For scenarier med interlevert tenkning er de effektive tokenreglene annerledes—plattformdokumentene forklarer når budget_tokens kan overstige max_tokens. Les delen om “interlevert tenkning” nøye før du tester store budsjetter.
• Signaturvalidering: Hvis du bevarer tenkeblokker for senere kall, inkluder den returnerte signature slik at API-et kan verifisere at de kommer fra Claude; dette forhindrer manipulering og holder kjeden verifiserbar.

Observabilitet og instrumentering

Logg: (1) model-valg, (2) thinking.budget_tokens, (3) faktisk forbruk av tenkningstokens (du blir fakturert for dem), (4) strømmelatenser (tid til første thinking_delta), og (5) endelige teksttokens. Bruk disse målene til å bygge budsjetter og SLO-er for brukerrettede flyter.

Progressiv utrulling og menneske-i-løkken

Rull ut tenkning-aktiverte modeller bak funksjonsflagg. Start med en prosentandel av utvikler- eller intern trafikk, samle feil eller redigeringer, og iterer promter og budsjetter. For sensitive domener, krev menneskelig gjennomgang av utdata som inkluderer betydelig intern tenkning før utgivelse.

Feilsøkingstips

• Start smått: aktiver lav budget_tokens og skalér opp for å forstå inkrementelle forbedringer.
• Slå på strømming og logg content_block_delta / signaturhendelser for å forstå når modellen produserer tenkeblokker.
• Hvis du bruker Claude Code: sjekk /config og prosjekt-nivåinnstillinger; se Claude Code-changelog hvis atferden ikke samsvarer med forventede standarder.

Konklusjon:

Claude 4.5, kombinert med kraften i Extended Thinking og Claude Code CLI, representerer det største spranget i utviklerproduktivitet siden oppfinnelsen av IDE-en. Ved å la modellen “vise arbeidet sitt” og overveie komplekse problemer, har Anthropic gått forbi “chatbot”-æraen og inn i “agentisk” æra.

Enten du integrerer Messages API i et egendefinert utviklerverktøy eller bruker Claude Code til å håndtere dine daglige PR-er, er mestring av tenkemodus essensielt. Det gir åpenheten som trengs for tillit og resonnementdybden som kreves for fremragende resultater.

Utviklere kan få tilgang til Claude 4.5 (Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.5) gjennom CometAPI. For å begynne, utforsk modellegenskapene til CometAPI i Playground og konsulter API-guiden for detaljerte instruksjoner. Før du får tilgang, må du sørge for at du er innlogget på CometAPI og har fått en API-nøkkel. CometAPI tilbyr en pris langt lavere enn den offisielle prisen for å hjelpe deg å integrere.

Klar til å starte?→ Gratis prøve av Claude 4.5!