Chain of thought prompting i 2026: når det virker, når det gir bakslag

Chain of thought prompting (tankekjede-prompting) har et 2026-problem de fleste toppguidene hopper over: samme triks som gjorde modeller smartere tilbake i 2022, kan i dag stille gjøre en resonneringsmodell dårligere. Wei et al. introduserte det i 2022, og det løftet nøyaktigheten på vanskelig matematikk og logikk ved å få modellene til å vise resonneringsstegene sine. Det var en hake. Det slo først inn når modellene passerte rundt 100 milliarder parametere. Nå gjør o-serien og GPT-5-resonneringsmodellene den tenkingen internt, så å be dem "tenke steg for steg" ofte bare brenner tokens. Når bør du fortsatt bruke det, og når bør du droppe det?

Nøkkelpunkter:

• Chain of thought prompting viser modellens resonneringssteg og løfter nøyaktigheten på flertrinns matematikk, logikk og kode.
• Det er en emergent evne: den hjelper knapt små modeller, og resonneringsmodeller gjør det allerede internt.
• På o-serien, GPT-5-resonnering og Claudes extended thinking er manuell "tenk steg for steg" ofte overflødig.
• Bruk fortsatt manuell CoT på ikke-resonnerende og lokale åpen kildekode-modeller, eller når du trenger en etterprøvbar resonneringssti.

Hva er chain of thought prompting?

Chain of thought (CoT) prompting er en teknikk som ber en språkmodell jobbe seg gjennom et problem i eksplisitte mellomsteg før den gir et endelig svar. Introdusert av Wei et al. i 2022, forbedrer den nøyaktigheten på flertrinns matematikk, logikk og sunn fornuft-oppgaver, og den gjør modellens resonnering synlig.

Spør en vanlig modell om en tekstoppgave uten forvarsel, og den svarer ofte feil tall på sparket. Be den resonnere først, og sjansene stiger. Ta "En hylle har 3 esker med 7 bøker hver; jeg fjerner 5. Hvor mange er igjen?" Uten forvarsel svarer kanskje en liten modell "21". Legg til "La oss tenke steg for steg", og den skriver: 3 x 7 = 21, deretter 21 - 5 = 16. Samme modell, bedre svar, og du kan se hvor den eventuelt sporet av. CoT er ett verktøy i den bredere verktøykassen i vår guide til prompt engineering; dette innlegget zoomer helt inn på akkurat den.

Hvordan det fungerer (og hvorfor det først virket i stor skala)

CoT fungerer ved at modellen genererer en resonneringssti på naturlig språk, token for token, slik at hver mellomkonklusjon betinger den neste. Wei et al. (2022) fant at dette er en emergent evne: den hjelper knapt små modeller og gir bare store nøyaktighetsgevinster først når modellene passerer rundt 100 milliarder parametere.

Tenk på det som å vise utregningen i mattetimen. En modell forutsier ett token om gangen, og hvert ord den skriver, blir en del av inputen til neste ord. Når den skriver "21" som et mellomresultat, ligger det "21"-et nå i konteksten og styrer siste steg mot "16". Hopper den over stegene, må modellen hoppe rett til svaret uten noe å støtte seg på. Det rare er at denne fordelen først dukker opp i stor skala. I grunnleggerartikkelen fant Weis team at helt små modeller fikk nesten ingen løft, og noen ganger gjorde det verre. Det er derfor samme prompt som ryker på en lokal 7B-modell, kan forvandle en frontier-modell.

De tre variantene: zero-shot, few-shot og self-consistency

Det finnes tre hovedvarianter av CoT. Zero-shot CoT legger bare til "La oss tenke steg for steg" (Kojima et al., 2022). Few-shot CoT viser gjennomarbeidede resonneringseksempler først. Self-consistency (Wang et al., 2022) samler flere resonneringsstier og tar et flertallsvalg på svaret; den er den mest pålitelige og den dyreste av de tre.

Zero-shot er det late trylletrikset. Du legger til én setning, og modellen resonnerer uten noen eksempler. Kojima et al. viste at "La oss tenke steg for steg" alene gjør en stor modell til en anstendig zero-shot-resonnerer.

# Zero-shot CoT: append the trigger phrase. Best on non-reasoning models.
# Model names change fast, so treat the string below as a placeholder.
from openai import OpenAI
client = OpenAI()

prompt = (
    "Q: A shelf holds 3 boxes. Each box has 7 books. "
    "I remove 5 books. How many are left?\n"
    "A: Let's think step by step."
)

resp = client.chat.completions.create(
    model="your-non-reasoning-model",
    messages=[{"role": "user", "content": prompt}],
)
print(resp.choices[0].message.content)

Few-shot CoT går et steg lenger: du gir modellen to eller tre gjennomarbeidede eksempler, slik at den kopierer resonneringsmønsteret for ditt domene. Self-consistency er nøyaktighetsskruen. I stedet for å stole på én kjede, sampler du fem ved en høyere temperatur og lar dem stemme. Wang et al. fant at flertallssvaret som regel er riktig, selv når enkeltkjeder sporer av.

# Self-consistency: sample N reasoning paths, majority-vote the answer.
# More accurate, more expensive. Wang et al., 2022.
from collections import Counter

def self_consistency(prompt, n=5, temperature=0.7):
    answers = []
    for _ in range(n):
        resp = client.chat.completions.create(
            model="your-non-reasoning-model",
            messages=[{"role": "user", "content": prompt}],
            temperature=temperature,  # diversity across paths
        )
        answers.append(extract_final_answer(resp.choices[0].message.content))
    return Counter(answers).most_common(1)[0][0]  # majority vote

Vil du ha den resonneringen som ren JSON i stedet for fritekst? Kombiner CoT med mønstrene i vår guide til strukturerte utdata slik at et nedstrøms steg kan parse den.

2026-skiftet: resonneringsmodeller endret reglene

Resonneringsmodeller, altså OpenAIs o-serie og GPT-5-resonnering, Claudes extended thinking, og DeepSeek R1, gjør chain of thought internt før de svarer. OpenAIs egen veiledning sier eksplisitt at det er unødvendig å be disse modellene "tenke steg for steg", og at å be en resonneringsmodell resonnere mer, faktisk kan svekke ytelsen. Stillaset er allerede innebygd.

Dette er delen de eldre guidene later som ikke skjer. En resonneringsmodell produserer en privat tankekjede før den i det hele tatt viser deg et svar, så steg-for-steg-arbeidet du pleide å skrive for hånd, skjer nå under panseret. OpenAIs beste praksis for resonnering sier det rett ut: "Unngå chain-of-thought-prompter: Siden disse modellene resonnerer internt, er det unødvendig å be dem 'tenke steg for steg' eller 'forklare resonneringen din'." Deres o3/o4-mini-veiledning for prompting går et steg lenger: "Å be en resonneringsmodell resonnere mer, kan faktisk svekke ytelsen."

Anthropics extended thinking er den samme ideen gjort om til et produkt. Du gir Claude et tenkebudsjett i stedet for et steg-for-steg-manus, og de nyeste modellene bestemmer selv hvor dypt de tenker. På denne modellklassen justerer du reasoning_effort eller tenkebudsjettet, ikke ordlyden. For den åpne resonneringsmodell-siden, inkludert DeepSeek R1, se vår gjennomgang av Qwen vs DeepSeek vs GLM.

Når manuell CoT fortsatt hjelper, og når den gir bakslag

Manuell CoT hjelper fortsatt på ikke-resonnerende og små eller lokale åpen kildekode-modeller, eller når du trenger én bestemt resonneringsstruktur eller et etterprøvbart spor. Den gir bakslag på native resonneringsmodeller (overflødig og tregere), på enkle ett-stegs-oppgaver, og på latens- eller kostnadssensitive stier, hvor den bare brenner tokens uten nøyaktighetsgevinst.

Her er et ekte eksempel fra vår egen virksomhet. 12-agent-pipelinen som skrev dette innlegget, kjører på Claude-modeller, og vi ber bevisst aldri disse agentene "tenke steg for steg", fordi modellene allerede resonnerer internt, og det ville bare lagt til støy. Det vi håndskriver, er derimot rigide, gjennomsøkbare resonneringsstillaser. Valideringsagenten vår kjører en fast 100-poengs rubrikk (50 kvalitet, 50 SEO) pluss åtte sekvensielle portkontroller. Oversetteragenten følger en fast sjekkliste: matche kildens H2-antall, kjøre en diakritikk-grep som må returnere mer enn null, og holde seg innenfor et linjetallsbånd på 80 til 120 prosent. Publiseringsagenten kjører kontroller før og etter publisering som regex-sjekker publishedAt-datotiden, og deretter spør CMS-et for å bekrefte at kroppen ikke er tom.

Ingenting av dette handler om mer tenking. Det er en fast, etterprøvbar sti vi kan inspisere og grepe, som er akkurat "manuell CoT hjelper fortsatt"-tilfellet. Vi la til de kontrollene av en grunn: en dato-uten-klokkeslett-verdi i publishedAt skjulte en gang stille et helt innlegg fra bloggindeksen vår, så den rigide stegrekkefølgen finnes nå for å stoppe modellen fra å hoppe over en verifisering. Ett ærlig forbehold: dette er en driftsobservasjon, ikke en benchmark. Vi har ikke kjørt en kontrollert nøyaktighets-A/B-test på "tenk steg for steg" mot ingen instruks, så behandle det som en lekse om struktur og etterprøvbarhet, ikke et talleksempel.

Kjører du lokale modeller der manuell CoT fortsatt lønner seg? Vår oversikt over de beste åpen kildekode-LLM-ene i 2026 dekker feltet. Og hvis du noen gang viser fram en modells tankekjede til brukere, behandle det som utrygg output; vår guide om å forhindre prompt injection forklarer hvorfor.

Den skjulte kostnaden: tokens, latens og regningen din

CoT er ikke gratis. Hvert resonneringssteg er output-tokens du betaler for, og lengre genereringer øker latensen. Resonneringsmodeller fakturerer skjulte reasoning-tokens på toppen av det synlige svaret. På høyvolum- eller sanntidsendepunkter kan tvungen steg-for-steg-output stille multiplisere kostnaden, så budsjetter for det eller begrens det med reasoning_effort.

Hvert "steg 1, steg 2, steg 3" modellen skriver, er output-tokens, og output-tokens er den dyre typen. En kjede som er fem ganger lengre enn selve svaret, koster omtrent fem ganger så mye på det kallet, og strømmer tilbake tregere. Resonneringsmodeller legger til en vri: de fakturerer reasoning-tokens for den interne tenkingen du aldri ser, så et kort sluttsvar kan skjule en lang, betalt kjede. På et lavvolum-endepunkt er det støy; på et høytrafikk-endepunkt kryper det raskt oppover. To vaner holder det fornuftig. Cache de stabile delene av konteksten din, slik at du ikke betaler for å lese dem på nytt igjen (vår guide til prompt caching viser hvordan), og mål om de ekstra tokenene faktisk kjøper nøyaktighet før du ruller ut CoT overalt. Vår guide til LLM-evaluering dekker den målingen, slik at du ikke betaler for resonnering som ikke flytter poengsummen.

Slik bruker du CoT i 2026: en beslutningssjekkliste

Først, identifiser modellklassen din. På en resonneringsmodell, hopp over manuell CoT og juster i stedet reasoning_effort eller tenkebudsjettet. På en ikke-resonnerende eller lokal modell, legg til zero-shot "La oss tenke steg for steg", oppgrader til few-shot for domeneoppgaver, og legg til self-consistency bare når nøyaktighet betyr mer enn token-kostnad.

Her er hele beslutningen i fem steg:

1. Identifiser modellklassen din. Resonneringsmodell eller ikke? Det ene faktumet avgjør alt under.
2. På en resonneringsmodell, ikke skriv CoT for hånd. Juster i stedet reasoning_effort eller tenkebudsjettet, og la modellen resonnere internt.
3. På en ikke-resonnerende eller lokal modell, legg til zero-shot "La oss tenke steg for steg." Det er én linje og gratis å prøve.
4. For domenespesifikke oppgaver, oppgrader til few-shot CoT med to eller tre gjennomarbeidede eksempler. Legg til self-consistency bare når nøyaktighet slår token-kostnad.
5. Hvis du eksponerer resonneringen, mål den med evalueringer og behandle den synlige kjeden som utrygg output.

Selve utløserfrasen bor vanligvis i systempromptet ditt. Vår oversikt over systemprompt-eksempler viser hvor den hører hjemme og hvordan du bør formulere den.

# On a reasoning model, don't hand-write CoT. Tune the effort instead.
# Param names and levels change per provider and version, so check current docs.
resp = client.responses.create(
    model="your-reasoning-model",
    reasoning={"effort": "medium"},   # e.g. low | medium | high
    input="Prove that the square root of 2 is irrational.",
)

# Anthropic equivalent: an extended-thinking budget.
# budget_tokens MUST be less than max_tokens.
# thinking = {"type": "enabled", "budget_tokens": 4000}

Å koble dette inn i en produksjonsstack er mer kronglete enn et blogginnlegg-eksempel får det til å se ut som. Vil du heller slippe å justere resonneringsbudsjetter og evalueringsrigger selv, bygger teamet vårt disse pipelinene fra ende til ende. Se AI-integrasjon eller ta kontakt.

Ofte stilte spørsmål

Er chain of thought prompting fortsatt relevant i 2026?

Ja, men jobben har krympet. På ikke-resonnerende og små eller lokale åpen kildekode-modeller løfter manuell CoT fortsatt nøyaktigheten på flertrinnsoppgaver. På resonneringsmodeller er den stort sett overflødig. Den sterkeste gjenværende bruken er å tvinge fram én fast, etterprøvbar resonneringssti du kan inspisere.

Fungerer chain of thought prompting på resonneringsmodeller som GPT-5, o3 eller Claude?

Disse modellene resonnerer allerede internt, så manuell CoT er som regel overflødig og noen ganger skadelig. OpenAIs dokumentasjon sier at det er unødvendig å be dem "tenke steg for steg", og at å be dem resonnere mer "kan faktisk svekke ytelsen". Juster resonneringsinnsatsen i stedet for å skrive steg.

Hva er zero-shot chain of thought prompting?

Zero-shot CoT betyr å legge til en utløserfrase, vanligvis "La oss tenke steg for steg", uten å gi noen gjennomarbeidede eksempler først. Kojima et al. (2022) viste at dette alene gjør en stor modell til en anstendig resonnerer. Det er den billigste CoT-varianten: én linje, ingen eksempelkuratering, raskt å teste.

Hva er self-consistency i chain of thought prompting?

Self-consistency, fra Wang et al. (2022), sampler flere uavhengige resonneringskjeder ved en høyere temperatur, og tar deretter et flertallsvalg på sluttsvaret. Det er den mest nøyaktige CoT-varianten fordi feilaktige kjeder sjelden er enige, men du betaler for hver sampla sti, så den er også den dyreste.

Hva er forskjellen mellom chain of thought og few-shot prompting?

Few-shot prompting viser modellen eksempler på input-output-par. Chain of thought fokuserer på resonneringen mellom input og output. De kombineres godt: few-shot CoT gir gjennomarbeidede eksempler som inkluderer resonneringsstegene, slik at modellen kopierer resonneringsmønsteret ditt, ikke bare svarformatet ditt.

Chain of thought vs prompt chaining vs tree of thought: hva er forskjellen?

Chain of thought resonnerer inne i én enkelt prompt. Prompt chaining deler en oppgave over flere separate modellkall og sender output videre. Tree of thought utforsker flere resonneringsgrener og beskjærer de svake. CoT er én lineær sti; de to andre legger til ekstern struktur rundt modellen.

Hvem oppfant chain of thought prompting?

Chain of thought prompting ble introdusert av Jason Wei og kolleger hos Google i 2022-artikkelen "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." Kojima et al. la senere til zero-shot CoT, og Wang et al. la til self-consistency, begge også i 2022.

Fungerer chain of thought prompting for kodegenerering?

Ja, på ikke-resonnerende modeller. Å be modellen planlegge logikken før den skriver kode, fanger opp kantfeller og reduserer feil på komplekse oppgaver. På resonneringsmodeller skjer planleggingen internt, så en enkel instruks fungerer vanligvis bedre enn et håndskrevet "resonner steg for steg"-prefiks.