Hvordan bruke Thinking mode i Claude 4.5?

“Thinking mode” (også kalt utvidet tenkning, tenkning eller tenkeblokker) i Claude 4.5 er en eksplisitt, konfigurerbar driftstilstand som instruerer modellen til å bruke et separat budsjettert antall tokens på å generere intern, trinnvis resonnement (en “chain-of-thought”) før den leverer det endelige svaret. Den er designet for å forbedre ytelse på flertrinns resonnement, kompleks koding og agentiske arbeidsflyter, samt forskning, ved å bytte latens og token-kostnad mot dypere intern overveielse. Claude 4.5 eksponerer denne funksjonen på Messages API-nivå 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 cache- og token-regnskap-adferd du må håndtere når du bygger produksjonsarbeidsbelastninger.

What is Claude 4.5? (And which models should I care about?)

Claude 4.5 er Anthropic’s siste sett med Claude-modeller lansert som inkrementelle “4.5”-oppdateringer (for eksempel Sonnet 4.5 og Opus 4.5). Sonnet 4.5 er posisjonert som den beste balansen mellom intelligens, koding og agentisk ytelse for de fleste utviklere; Opus 4.5 fokuserer på svært høy-innsats resonnement og bevarer tenkeblokker for å forbedre flerturns-kontinuitet. Begge modellene støtter Claudes utvidede tenkning, selv om noe adferd (f.eks. oppsummert vs. full tenkning) varierer per modell.

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

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

Why this matters

• Koding & agenter: Sonnet 4.5 viser sterke gevinster på virkelige programvareoppgaver og langhorisont-kodearbeid—som gjør den til et naturlig valg for kodegenerering, kodeendring og autonome agentflyter.
• Utvidet tenkning & kontekst: Claude 4.5-familien er bygget for å resonnere med svært store interne notatflater (titalls tusen tokens eller mer), som muliggjør dypere flertrinns resonnement. Det endrer hvordan du designer promper, token-budsjetter og verktøysinteraksjoner.

What is Thinking Mode in Claude 4.5?

Tenkemodus (offisielt kalt "Utvidet tenkning") er en evne som lar modellen “vise arbeidet for seg selv” før den leverer en endelig utdata. I motsetning til standardmodeller som binder seg til et svar umiddelbart, bruker Claude 4.5 et dedikert resonnementrom for å utforske flere hypoteser, identifisere potensielle logiske feil og raffinere strategien sin.

The Anatomy of a Response

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

Key properties of thinking mode

• Enable by request: Du sender et thinking-objekt i API-kallet som {"type":"enabled","budget_tokens":10000} for å slå det på og gi modellen et internt token-budsjett for resonnement.
• Budgeting: budget_tokens begrenser modellens interne resonnementstokens. Mer budsjett => større potensial for dypt resonnement, men høyere kostnad og latens. I Claude 4-modeller faktureres tenkningstokens selv om du kun mottar en oppsummert visning.
• Summarization & redaction: For mange Claude 4-modeller ser brukeren en oppsummert versjon av tenkningsinnholdet; noe intern resonnement kan være sladdet (kryptert) av sikkerhetssystemer og returnert som redacted_thinking.
• Signatures & verification: Tenkeblokker inkluderer en ugjennomsiktig signature brukt til verifisering når tenkeblokker returneres til API-et (særlig nødvendig ved verktøybruk). Du bør behandle signaturen som ugjennomsiktig — ikke forsøk å parse den.
• Interleaved thinking with tools: Claude 4 støtter å innveve tenkning med verktøyutførelser (beta og flaggbasert i noen tilfeller). Dette er kraftig for agentisk arbeid (kjør verktøy, tenk, kjør et nytt verktøy osv.).

For praktiske eksempler og de mest oppdaterte parameterne er Anthropic’s Messages/Extended Thinking-dokumentasjon den kanoniske referansen.

How does the Messages API return thinking content

Summarized vs full thinking; encryption & signatures

Ulike Claude 4-modellversjoner håndterer tenkning forskjellig: nyere Claude 4-modeller (som Sonnet/Opus 4.5) returnerer ofte en oppsummert offentlig visning av det interne resonnementet, mens den fulle kladden kan være kryptert og kun tilgjengelig via et signature-felt (eller sladdede blokker). Når verktøy brukes (eller du trenger å bevare intern tilstand på tvers av verktøykall), må du sende tenkeblokker tilbake til API-et eller bruke signaturmekanismen dokumentasjonen beskriver. Denne mekanismen bidrar til å beskytte sensitiv intern tenkning samtidig som den tillater trygg fortsettelse av tankeprosessen når det er nødvendig.

Practical handling pattern

Verktøybruk / fortsettelse: hvis neste forespørsel må fortsette samme interne tilstand (f.eks. verktøy ble kjørt basert på tenkningen), inkluder den returnerte tenkeblokken eller signaturen når du kaller API-et igjen, 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 til 20% av den offisielle API-prisen, og den kan også kalles med Anthropic Messages. Du må skaffe en API-nøkkel før du starter.

Example 1 — simple curl (non-streaming) enabling thinking

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 prioriter text-blokker for endelig utdata; thinking-blokker inneholder modellens interne analysesammendrag.

Example 2 — Python: request, parse thinking and text blocks

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 trekker ut og skriver ut det oppsummerte resonnementet og det endelige svaret. Hvis du trenger å bevare kontinuitet i flerturns agentflyter, inkluder uendrede tenkeblokker i neste forespørsel sin messages-array (se neste eksempel).

Example 3 — reusing thinking blocks in a multi-turn 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)

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

How do I stream thinking outputs and show progress in a UI?

Streaming best practices

• Bruk SDK-endenpunktene for streaming (Python/TypeScript-SDKene har stream-hjelpere). For langvarige eller høybudsjett-resonneringsjobber forhindrer streaming HTTP-timeouts og gir deg delvis tekst mens modellen beregner. Typisk kode bruker en iterator over text_stream (Python) eller hendelsesparsing (JS).
• Forvent tofasede strømmer noen ganger: modellen kan først produsere synlige resonnementbiter, deretter fullføre med svaret. Bygg UI-et ditt for å håndtere innholdsfragmenter og for å vise “tenker…” vs. endelig svar-tilstander.
• Hvis API-et returnerer en signature_delta eller content_block_delta ved streaming, fang den og legg den ved påfølgende kall slik spesifikasjonen krever.

Hvis du trenger å vise mellomliggende resonnementfremdrift i et UI, stream 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 streaming, 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.

How does Claude Code interact with thinking mode?(terminal + VS Code)

Claude Code er den interaktive, agentiske kodingsterminalen 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 adferd (hvordan agenten ber om tillatelser, om tenkeblokker skal bevares, osv.). Bruk den UI-en i stedet for å skrive rå JSON hvis du vil gjøre vedvarende adferdsendringer.
• Modellvalg & CLI-kommandoer: Du kan velge claude-sonnet-4-5 eller claude-opus-4-5 som aktiv modell i REPL; verktøyene og tenkningsadferden følger deretter Messages API-semantikken. CHANGELOG og utgivelsesnotater indikerer at tenkning nå er aktivert som standard for noen Opus 4.5-deployeringer og at tenkningskonfigurasjon er eksponert gjennom /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 om å kjøre en lang oppgave — den vil produsere tenkningsinnhold og, om nødvendig, be om tillatelse til å kjøre spesifikke bash-trinn. Bevar tenkeblokker når du trenger å verifisere eller kjøre beslutninger på nytt senere.

Installation and Setup

Claude Code krever Node.js og kan installeres globalt.

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

# Authenticate
claude-code --init

Activating Thinking in the Terminal

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

Tips:

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

Benefits of Interleaved Thinking and Block Preservation

For avanserte agentiske arbeidsflyter introduserer Claude 4.5 to beta-funksjoner som betydelig forbedrer flerturns-interaksjoner og verktøybruk: Interleaved Thinking og Thinking Block Preservation.

Interleaved Thinking (Beta)

Standardresonnement skjer én gang før utdata. Interleaved Thinking (aktivert via interleaved-thinking-2025-05-14-header) 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 innstillingen for forbindelsespool."
4. Verktøykall: read_file(db_config.yml)

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

Thinking Block Preservation

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

• Resonneringskontinuitet: Ved å motta sine tidligere tanker, opprettholder Claude den logiske konteksten for sin reise.
• Opus 4.5-optimalisering: I Claude Opus 4.5 er denne adferden automatisert. Modellen bevarer alle tidligere tenkeblokker i konteksten som standard, noe som sikrer at selv i økter som varer 30+ timer, “glemmer” ikke modellen hvorfor den tok bestemte arkitektoniske beslutninger ti turer tidligere.

Best practices for using THINKING mode with Claude 4.5

Choose the right model and budget for the task:

Bruk Sonnet 4.5 for koding og agentiske arbeidsflyter der du trenger den beste balansen mellom hastighet, kostnad og sterke kodeevner; bruk Opus 4.5 for det dypeste resonnementet og de største kontekstvinduene eller når du planlegger å kjøre 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).

Monitor and control cost & latency

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

Preserve thinking blocks only when necessary

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

When to stream thinking to users

Streamet tenkning er utmerket for utviklerverktøy og pedagogiske UI-er (vise “arbeid pågår” mens modellen overveier). Ikke stream rå tenkning til sluttbrukere av produksjonsrettede forbrukerapper uten å vurdere sikkerhet og sladding: oppsummert tenkning finnes nettopp av denne grunn. Hvis du streamer, tilby UI-mekanismer som merker intern tenkning (f.eks. “Assistentresonnering — intern”), og kontroller om den endelige brukeren ser den oppsummerte eller den fulle tenkningen.

Tool use and interleaving

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

Practical troubleshooting and operational notes

Common errors and what they mean

• Invalid thinking + forced tool choice: Hvis du ber om tenkning men også tvinger bestemte verktøybruksmodi som er inkompatible med tenkning, vil API-et returnere en feil — ikke bland forcing tool_choice: {"type":"tool","name":"..."} med tenkning.
• Budget > max_tokens: For innvevd tenkning varierer de effektive token-reglene — plattformdokumentasjonen forklarer når budget_tokens kan overstige max_tokens. Les seksjonen om “interleaved thinking” nøye før du tester store budsjetter.
• Signature validation: Hvis du bevarer tenkeblokker for senere kall, inkluder den returnerte signature slik at API-et kan verifisere at de kom fra Claude; dette hindrer manipulering og holder kjeden verifiserbar.

Observability & instrumentation

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

Progressive rollout & human-in-the-loop

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

Debugging tips

• Start smått: aktiver lav budget_tokens og skaler opp for å forstå trinnvise forbedringer.
• Slå på streaming og logg content_block_delta / signatur-hendelser for å forstå når modellen produserer tenkeblokker.
• Hvis du bruker Claude Code: sjekk /config og prosjekt-nivåinnstillinger; konsulter Claude Code-changelog hvis adferden ikke matcher forventede standarder.

Conclusion:

Claude 4.5, kombinert med kraften i Utvidet tenkning og Claude Code-CLI, representerer det mest betydelige spranget i utviklerproduktivitet siden oppfinnelsen av IDE-en. Ved å la modellen “vise arbeidet” og overveie komplekse problemer, har Anthropic beveget seg forbi “chatbot”-æraen og inn i “agentisk”-æraen.

Enten du integrerer Messages API i et tilpasset utviklerverktøy eller bruker Claude Code til å håndtere dine daglige PR-er, er det essensielt å mestre Tenkemodus. Det gir transparensen som trengs for tillit og resonneringsdybden som trengs for kvalitet.

Developers can access Claude 4.5(Claude Sonnet 4.5 , Claude Haiku 4.5, Claude Opus 4.5) model through CometAPI. To begin, explore the model capabilities of CometAPI in the Playground and consult the API guide for detailed instructions. Before accessing, please make sure you have logged in to CometAPI and obtained the API key. CometAPI offer a price far lower than the official price to help you integrate.

Ready to Go?→ Gratis prøve av Claude 4.5!