Hva er Auto Compact i Claude Code?

Claude Code er Anthropic sin agentbaserte kodeassistent som kan lese en kodebase, redigere filer, kjøre kommandoer og integrere med verktøy på tvers av terminal, IDE, skrivebordsapp og nettleser-arbeidsflyter. Fordi den arbeider i et delt kontekstvindu, fylles lange økter etter hvert opp med chathistorikk, filutdata og verktøystøy. Claude Code håndterer dette automatisk ved å komprimere samtalehistorikken når du nærmer deg grensen, og tidlige instruksjoner kan gå tapt hvis de kun finnes i chathistorikken.

Det er enda viktigere i 2026 fordi Anthropic fortsetter å presse Claude Code mot lengre, mer autonome arbeidsløp. 25. mars 2026 publiserte Anthropic “Claude Code auto mode: a safer way to skip permissions,” som sier at brukere godkjenner 93% av tillatelsespromptene og beskriver auto mode som et klassifiseringsbasert kompromiss mellom manuell godkjenning og usikker hopp-over-tilgang. 5. februar 2026 lanserte Anthropic også Claude Opus 4.6, med fokus på sterkere koding, bedre debugging og lengre agentbaserte økter. Disse oppdateringene er ikke det samme som auto compact, men de viser produktretningen tydelig: færre avbrudd, lengre økter og mer pålitelig kontinuitet.

CometAPI tilbyr for tiden tilgang til Claude API til lavere pris enn den offisielle API-en, for eksempel Claude Sonnet 4.6, Claude Opus 4.6, og Claude 5.

Hva Auto Compact faktisk betyr i Claude Code

Auto Compact er en innebygd kontekstoptimaliseringsmekanisme i Claude Code (CLI/desktop-verktøyet fra Anthropic) og i det bredere Claude API-økosystemet. Den griper automatisk inn når samtalen nærmer seg modellens kontekstvindutak – typisk rundt 200 000 token for flaggskipsmodeller som Claude Opus 4 eller Sonnet 4. Hooks-dokumentasjonen er eksplisitt: PreCompact trigges før en kompaktoperasjon, og auto-matcher betyr “auto-compact når kontekstvinduet er fullt.” Den tilsvarende PostCompact-hooken trigges etter at komprimeringen er fullført, og den mottar den genererte compact_summary.

Det er viktig fordi komprimering ikke er det samme som “memory.” Auto memory er Claude sitt eget notatsystem, mens komprimering er en økthåndteringsmekanisme som kondenserer den aktive samtaletilstanden. Memory-dokumentasjonen er tydelig på at CLAUDE.md er vedvarende, Auto memory skrives av Claude, og komprimering er øyeblikket hvor øktens samtalehistorikk reduseres for at modellen skal kunne fortsette å jobbe.

I stedet for å tvinge en ny chat (og miste historikk) eller la modellen “glemme” kritiske detaljer, gjør Auto Compact følgende:

1. Analyserer hele historikken — identifiserer kjerneelementer det er verdt å beholde.
2. Genererer et konsist sammendrag — av beslutninger, kodearkitektur, løste feil, filstatus og neste steg.
3. Erstatter eldre meldinger — med dette sammendraget (en “kompakteringsblokk” i API-termer).
4. Gjenopptar sømløst — med bevart kontekst.

Nøkkeldata (2026):

• Utløsningsgrense: Standard er ~95% kapasitet (eller ~25% igjen). Noen brukere rapporterer en intern buffer som reserverer 20–45k token (~22,5% av konteksten) til selve komprimeringsprosessen.
• Ytelsesforbedring: Siden Claude Code v2.0.64 er komprimering “øyeblikkelig” i stedet for å ta minutter.
• Token-besparelseseksempel (fra Claude Agent SDK-benchmarks): En 5-ticket arbeidsflyt gikk fra 204k til 82k input-token (58,6% reduksjon) med to komprimeringshendelser.

Auto Compact er ikke det samme som /clear (som sletter alt) eller enkel trunkering. Den bevarer intelligent det som er viktig — nylige kode-diff-er, arkitektoniske valg, navnekonvensjoner — samtidig som den kondenserer løste debugging-sløyfer og utforskende avstikkere.

Hvorfor bruke Auto Compact i Claude Code?

Lange kodeøkter er normalen. En enkel funksjon kan strekke seg over 50+ turer: planlegging, debugging, refaktorering, testing. Uten komprimering vokser token-bruken lineært, svarkvaliteten forringes, og kostnadene skyter i været.

For utviklere er gevinsten mindre restart-tretthet. I stedet for å kopiere et sammendrag manuelt til en ny økt, lar du Claude komprimere økten og fortsetter. Det er spesielt nyttig i feilretting, refaktorering på tvers av flere filer, testdrevet endring og gjennomgangstunge arbeidsflyter der samtalen kan bli svært lang. Claude Code-økter starter med et friskt kontekstvindu, så komprimering er en av nøkkelmekanismene som gjør langtidsarbeid praktisk.

Kjernefordeler

• Ubegrenset øktlengde: Fortsett på ubestemt tid uten å starte på nytt.
• Kostnads- og ytelseseffektivitet: Reduserer input-token dramatisk. Reelle rapporter viser 50–60% besparelser i flerfase-arbeidsflyter.
• Bedre fokus og stabilitet: Forhindrer “kontekst-overbelastning” der modellen hallusinerer eller glemmer tidligere begrensninger.
• Bevarer institusjonell kunnskap: Viktige beslutninger forblir i kontekst selv etter hundrevis av meldinger.
• Sømløs for agentbaserte arbeidsflyter: Kritisk når du bruker verktøy, MCP-servere eller multi-agent-oppsett i Claude Code.

Når bør du stole på Auto Compact?

Bruk Auto Compact når oppgaven naturlig er langvarig: refaktorering på tvers av flere filer, feilrettingsøkter som veksler mellom logger og kildekode, funksjonsimplementering med gjentatt verifisering, eller research som krever mange verktøykall. Anthropic sin dokumentasjon peker eksplisitt på lange økter der kontekstvinduet fylles med irrelevant samtale, filinnhold og kommandoer, og sier at automatisert komprimering bevarer nøkkel-kode og beslutninger samtidig som den frigjør plass.

Den er mindre egnet når oppgaven er kort, isolert eller krever presise, permanent beholdte instruksjoner. Instruksjoner fra tidlig i samtalen kan gå tapt etter komprimering, og derfor hører prosjektsregler hjemme i CLAUDE.md, ikke i en prompt som kan bli komprimert bort senere.

Når du skal bruke (eller aktivere) det:

• Alltid på som standard for de fleste brukere — ideelt for daglig koding, store refaktoreringer eller utforskende prosjekter.
• Langvarige oppgaver — prosesseringskøer, datapipelines eller kodebaser med mange filer.
• Team-/enterprise-miljøer — der kontektskontinuitet på tvers av økter er viktig.
• Prosjekter med høy risiko — der tap av en eneste arkitekturavgjørelse kan koste mange timer.

Når du bør vurdere å deaktivere (via /config):

• Du vil ha hver eneste token av kontekst for ultrapresis kontroll.
• Du foretrekker full manuell håndtering (power-brukere som lagrer/gjenoppretter planer via filer).

Siste nytt (2025–2026): I mars 2025 forbedret Anthropic logikken i Auto Compact, slik at sammendragene ble smartere når det gjaldt å beholde “viktig info samtidig som token-bruken reduseres.” Mot slutten av 2025 ble triggingen raffinert (noen ganger tidligere ved 64–75% bruk for å unngå mislykkede komprimeringer). Tidlig i 2026 oppstod midlertidige feil i web-/skrivebordsgrensesnittene (markert som fikset i midten av januar, men med sporadiske rapporter), mens CLI forble stabil. Versjon 2.0.64 (februar 2026) gjorde komprimering øyeblikkelig, en stor forbedring for utvikleropplevelsen.

Hvordan bruke Auto Compact i Claude Code: Trinn-for-trinn-guide

Claude Code er designet slik at hver økt starter med et friskt kontekstvindu. Det er nyttig fordi hver ny oppgave starter rent, og det gjør det enklere å se når en økt blir støyende. Anbefal /clear mellom ikke-relaterte oppgaver slik at gammel kontekst ikke fortsetter å konsumere plass.

Trinn 1: Sjekk nåværende kontekststatus

Bruk /context for å visualisere nåværende kontekstbelastning. Claude Code sin innebygde kommandoliste sier at /context viser et farget rutenett og fremhever minneoppblåsing, optimaliseringsforslag og kapasitetsadvarsler. Det gjør det til den raskeste måten å se om du nærmer deg punktet der auto-komprimering sannsynligvis slår inn.

I Claude Code-økten din, skriv:

/context

Dette viser “Kontekst igjen til auto-compact: XX%” — din sanntids fremdriftslinje.

Trinn 2: Konfigurer Auto-Compact (valgfritt)

Når kontekstvinduet blir fullt, komprimerer Claude Code samtalen automatisk. Hooks-referansen merker denne hendelsen som auto, og den trigges når kontekstvinduet er fullt. I praksis “slår du ikke på” Auto Compact — du lar Claude Code gjøre det når det trengs.

/config

Naviger til “Auto-compact enabled” og veksle true/false. Standard er enabled. Du kan også justere relaterte innstillinger som MCP-serverbruk for proaktivt å frigjøre token.

Trinn 3: La Auto-Compact kjøre automatisk

Når du treffer ~95%:

• Claude viser “Compacting our conversation so we can keep chatting…” (eller lignende).
• Den kjører i bakgrunnen og gjenopptar.
• Du vil se det nye sammendraget øverst i konteksten.

Profftips: Ikke vent til 0%. Komprimer manuelt tidligere for bedre resultater (se beste praksis nedenfor).

Trinn 4: Bruk hooks hvis du vil automatisere hva som skjer rundt komprimering

Claude Code eksponerer både PreCompact og PostCompact hooks. Hook-referansen viser at PreCompact kan oppdage om komprimering er manuell eller automatisk, og PostCompact mottar den genererte compact_summary. Det gjør hooks til en sterk løsning for logging, revisjonsspor, notater etter komprimering eller ekstern automatisering.

Et enkelt hook-mønster ser slik ut:

{  "hooks": {    "PostCompact": [      {        "matcher": "auto",        "hooks": [          {            "type": "command",            "command": "./scripts/save-compact-summary.sh"          }        ]      }    ]  }}

Og det tilhørende shell-skriptet kan lese JSON-inndata fra stdin, fordi Claude Code-kommandohooks mottar JSON på den måten:

#!/usr/bin/env bashset -euo pipefailjq -r '.compact_summary // empty' \  | sed 's/^/[compact] /' \  >> .claude/compact-log.txt

Dokumentasjonen bekrefter at kommandohooks mottar JSON via stdin, og at PostCompact inkluderer compact_summary, så dette mønsteret er på linje med gjeldende hook-modell.

Trinn 5: Manuell komprimering med presisjon (anbefalt)

Bruk /compact når du vil at assistenten skal komprimere tråden akkurat nå. Du kan inkludere instruksjoner som former sammendraget du vil bevare. Anthropic sin side for innebygde kommandoer lister /compact [instructions] som “Compact conversation with optional focus instructions,”

/compact keep the auth flow decisions, the current test plan, and the open TODOs

Dette mønsteret er nyttig rett før overlevering, før et branch-bytte, eller før du ber Claude starte en ny fase av arbeidet.

Eksempler fra virkelig bruk:

• Etter feilsøking: /compact behold løsningen vi fant, fjern feilrettingsstegene
• Prosjektmilepæl: /compact fokuser på kravene til den nye funksjonen

Komprimering på API-nivå (avansert – Python SDK & Messages API)

For tilpassede agenter eller skript, bruk de offisielle komprimeringsverktøyene.

Claude Agent Python SDK-eksempel (automatisk for verktøybrukende arbeidsflyter):

from anthropic import Anthropic

client = Anthropic()

runner = client.beta.messages.tool_runner(
    model="claude-opus-4-6",
    max_tokens=4096,
    tools=your_tools,
    messages=messages,
    compaction_control={
        "enabled": True,
        "context_token_threshold": 100000,  # or lower for aggressive compaction
        "model": "claude-haiku-4-5",        # cheaper summarizer
        "summary_prompt": """Create a focused summary preserving:
1. COMPLETED TASKS and key outcomes
2. CURRENT STATE and open items
3. NEXT STEPS
Wrap in <summary></summary> tags."""
    }
)

Oppdag komprimeringshendelser:

if curr_msg_count < prev_msg_count:
    print(f"Compaction occurred! Messages reduced from {prev_msg_count} to {curr_msg_count}")
```<grok-card data-id="f4afb5" data-type="citation_card" data-plain-type="render_inline_citation" ></grok-card>

**Full Messages API (beta, 2026)** – krever header:
```bash
curl https://api.anthropic.com/v1/messages \
  --header "anthropic-beta: compact-2026-01-12" \
  --data '{
    "model": "claude-opus-4-6",
    "messages": [...],
    "context_management": {
      "edits": [{
        "type": "compact_20260112",
        "trigger": {"type": "input_tokens", "value": 150000},
        "pause_after_compaction": true
      }]
    }
  }'

API-et returnerer en komprimeringsblokk som du må sende med i fremtidige kall. Tilpassede instruksjoner og pause gir full kontroll over budsjettering (f.eks. håndheve en 3M total token-kvote på tvers av økter).

If you are using the Claude API of CometAPI, change the message header to "https://api.cometapi.com/v1/messages\\".

Auto-Compact vs Manual Compact vs Clear: Sammenligningstabell

Beste praksis for Claude Code Auto Compact (profftips fra utviklere)

Komprimer proaktivt

Den tredje regelen er å bruke komprimering som en “reset”, ikke en krykke. Hvis tråden er full av blindveier, be Claude komprimere med en klar instruksjon om hva som er viktig: nåværende mål, valgt tilnærming, feilede tester og uløste spørsmål. I praksis gjør det sammendraget langt mer nyttig enn å la systemet komprimere blindt og håpe på det beste.

Hold varige instruksjoner korte.

Anthropic sier at filer over 200 linjer kan redusere etterlevelse, så store policyblokker er vanligvis verre enn konsise, godt avgrensede regler. Bruk .claude/rules/ for filtype- eller sti-spesifikk atferd, og bruk @path-importer når du trenger rikere støtteinformasjon uten å blåse opp hovedinstruksjonsfilen.
Free tokens first — Deaktiver ubrukte MCP-servere med /mcp eller @server-name disable før komprimering.

Kombiner med CLAUDE.md

Behandle CLAUDE.md som kilden til sannhet for alt du vil skal overleve en lang øktCLAUDE.md leses på nytt etter /compact, noe som gjør det til riktig sted for byggekommandoer, kodekonvensjoner og vedvarende regler du aldri vil miste. Auto memory er også nyttig, men det er et annet system med et annet formål.

Andre tips

Overvåk via /context — Hold bruken under 70–80% når det er mulig.

For API-brukere — Sett lavere terskler (f.eks. 50k–100k) og bruk billigere summeringsmodeller som Haiku.

Deaktiver kun ved behov — De fleste utviklere anbefaler nå å holde Auto-Compact på etter forbedringene i 2025.

Test komprimering — Først i ikke-kritiske økter for å se hvordan din spesifikke arbeidsflyt blir oppsummert.

Reell effekt: Utviklere rapporterer 2–3x lengre produktive økter og færre “Claude glemte hva vi holdt på med”-øyeblikk.

Vanlige problemer & feilsøking (2026-utgaven)

• Auto-compact trigges ikke: Sjekk web/desktop vs CLI; noen feil fra januar 2026 ble fikset, men verifiser versjonen.
• Tapt kontekst etter komprimering: Bruk manuell /compact med eksplisitte instruksjoner neste gang.
• Uendelige løkker eller 102% bruk: Sjeldent; start økten på nytt eller bruk /clear som siste utvei.
• Langsom komprimering: Problem før v2.0.64 — oppdater Claude Code.
• API-feil med komprimeringsblokker: Append alltid hele komprimeringsinnholdsblokken i oppfølgingskall.

Konklusjon

Auto compact er en av de viktigste skjulte mekanismene i Claude Code fordi den gjør lange kodeøkter brukbare uten at du må starte på nytt hver gang kontekstvinduet fylles. Den praktiske regelen er enkel: la auto compact håndtere overløp, bruk /compact når du vil ha kontroll, lagre varig veiledning i CLAUDE.md, og bruk /clear eller /rewind når øktstrukturen endres. Den kombinasjonen gir deg den beste balansen mellom kontinuitet, kontroll og hastighet i lange Claude Code-arbeidsflyter.

Auto Compact i Claude Code representerer et sprang i praktisk AI-assistert utvikling. Ved å håndtere kontekstvinduet på 200k token intelligent, eliminerer den det største friksjonspunktet i langform-koding: å gå tom for minne. Med øyeblikkelig ytelse (2026), rik konfigurasjon og kraftige API-utvidelser er det nå en moden, slagtestet funksjon som brukes av tusenvis av utviklere daglig.

Tiltak i dag:

1. Åpne Claude Code og kjør /config — bekreft at Auto-Compact er aktivert.
2. Prøv en manuell /compact med instruksjoner for ditt nåværende prosjekt.
3. Utforsk Python SDK eller Messages API for automatiserte agenter i CometAPI.