Hvad er Auto Compact i Claude Code

Claude Code er Anthropic’s agentiske kodningsassistent, der kan læse en kodebase, redigere filer, køre kommandoer og integrere med værktøjer på tværs af terminal-, IDE-, desktop- og browser-workflows. Fordi den arbejder i et delt kontekstvindue, vil lange sessioner til sidst blive fyldt med chat-historik, filoutput og værktøjsstøj. Claude Code håndterer dette automatisk ved at kompaktere samtalehistorikken, når du nærmer dig grænsen, og tidlige instruktioner kan gå tabt, hvis de kun findes i chat-historikken.

Det betyder endnu mere i 2026, fordi Anthropic fortsætter med at skubbe Claude Code i retning af længere, mere autonomt arbejde. Den 25. marts 2026 offentliggjorde Anthropic “Claude Code auto mode: a safer way to skip permissions”, som siger, at brugere godkender 93% af tilladelsesforespørgsler og beskriver auto mode som en klassifikator-baseret mellemvej mellem manuel godkendelse og usikker omgåelse af tilladelser. Den 5. februar 2026 lancerede Anthropic også Claude Opus 4.6, med fokus på stærkere kodning, bedre debugging og længere agentiske sessioner. Disse opdateringer er ikke det samme som auto compact, men de viser produktretningen tydeligt: færre afbrydelser, længere sessioner og mere pålidelig kontinuitet.

CometAPI tilbyder i øjeblikket adgang til Claude API til en lavere pris end den officielle API, for eksempel Claude Sonnet 4.6, Claude Opus 4.6, og Claude 5.

Hvad auto-compact faktisk betyder i Claude Code

Auto Compact er en indbygget kontekstoptimeringsmekanisme i Claude Code (CLI/desktop-værktøjet fra Anthropic) og det bredere Claude API-økosystem. Den griber automatisk ind, når din samtale nærmer sig modellens kontekstvindues loft—typisk omkring 200.000 tokens for flagskibsmodeller som Claude Opus 4 eller Sonnet 4. Hooks-dokumentationen er eksplicit: PreCompact affyres før en komprimeringsoperation, og auto-matcher betyder “auto-compact, når kontekstvinduet er fyldt.” Den tilsvarende PostCompact-hook affyres efter komprimeringen er fuldført, og den modtager den genererede compact_summary.

Det er vigtigt, fordi komprimering ikke er det samme som “memory.” Auto memory er Claude’s egen notatsystem, mens komprimering er en sessionsstyringsmekanisme, der komprimerer den aktive samtaletilstand. Memory-dokumenterne er tydelige omkring, at CLAUDE.md er persistent, auto memory skrives af Claude, og komprimering er det tidspunkt, hvor sessionens samtalehistorik reduceres, så modellen kan fortsætte arbejdet.

I stedet for at tvinge en ny chat (og miste historik) eller lade modellen “glemme” kritiske detaljer, gør Auto Compact følgende:

1. Analyserer hele historikken — identificerer centrale elementer, der er værd at bevare.
2. Genererer en kortfattet opsummering — af beslutninger, kodearkitektur, løste fejl, filtilstande og næste skridt.
3. Erstatter ældre beskeder — med denne opsummering (en “komprimeringsblok” i API-termer).
4. Genoptager sømløst — med den bevarede kontekst.

Vigtige datapunkter (2026):

• Trigger-tærskel: Standard er ~95% kapacitet (eller ~25% tilbage). Nogle brugere rapporterer en intern buffer, der reserverer 20–45k tokens (~22,5% af konteksten) til selve komprimeringsprocessen.
• Ydelsesforbedring: Siden Claude Code v2.0.64 er komprimering “øjeblikkelig” i stedet for at tage minutter.
• Token-besparelseseksempel (fra Claude Agent SDK-benchmarks): Et 5-ticket workflow faldt fra 204k til 82k input tokens (58,6% reduktion) med to komprimeringshændelser.

Auto Compact er ikke det samme som /clear (som sletter alt) eller simpel trunkering. Den bevarer intelligent det, der er vigtigt—nylige code diffs, arkitektoniske valg, navngivningskonventioner—mens den kondenserer løste debug-sløjfer og eksplorative sidespring.

Hvorfor bruge Auto Compact i Claude Code?

Lange kodningssessioner er normen. En enkelt feature-implementering kan spænde over 50+ ture: planlægning, debugging, refaktorering, test. Uden komprimering vokser token-forbruget lineært, svarkvaliteten forringes, og omkostningerne stiger drastisk.

For udviklere er gevinsten mindre restart-friktion. I stedet for manuelt at kopiere en opsummering til en ny session, lader du Claude komprimere sessionen og fortsætte. Det er især nyttigt i fejlfinding, refaktorering på tværs af flere filer, test-drevne ændringer og review-tunge workflows, hvor samtalen kan blive meget lang. Claude Code-sessioner starter med et frisk kontekstvindue, så komprimering er en af de nøglemekanismer, der gør langvarigt arbejde praktisk.

Centrale fordele

• Ubegrænset sessionslængde: Fortsæt uendeligt uden at starte forfra.
• Omkostnings- og ydeeffektivitet: Reducerer input tokens dramatisk. Erfaringer fra den virkelige verden viser 50–60% besparelser i flerfasede workflows.
• Bedre fokus og stabilitet: Forhindrer “kontekst-overload”, hvor modellen hallucinerer eller glemmer tidligere begrænsninger.
• Bevarer institutionel viden: Nøglebeslutninger forbliver i konteksten selv efter hundreder af beskeder.
• Sømløs for agentiske workflows: Kritisk ved brug af tools, MCP-servere eller multi-agent-setup i Claude Code.

Hvornår bør du stole på auto compact?

Brug auto compact, når opgaven naturligt er langvarig: refaktorering på tværs af flere filer, fejlsøgningssessioner, der hopper mellem logs og kildekode, feature-implementering med gentagen verifikation, eller research, der kræver mange tool-kald. Anthropics dokumentation peger eksplicit på lange sessioner, hvor kontekstvinduet fyldes med irrelevant samtale, filindhold og kommandoer, og siger, at auto-komprimering bevarer vigtig kode og beslutninger, mens den frigør plads.

Den er mindre velegnet, når opgaven er kort, isoleret, eller kræver præcise, permanent bevarede instruktioner. Instruktioner fra tidligt i samtalen kan gå tabt efter komprimering, hvilket er grunden til, at projektsregler hører hjemme i CLAUDE.md, ikke i en engangsprompt, der kan blive komprimeret væk senere.

Hvornår skal den bruges (eller aktiveres):

• Altid slået til som standard for de fleste brugere — ideel til daglig kodning, store refaktoreringer eller eksplorative projekter.
• Langvarige opgaver — behandling af køer, datapipelines eller kodebaser med mange filer.
• Team-/enterprise-miljøer — hvor kontekstkontinuitet på tværs af sessioner er vigtig.
• Projekter med høj risiko — hvor tab af en enkelt arkitektonisk beslutning kan koste timer.

Hvornår bør du overveje at deaktivere (via /config):

• Du vil have hver eneste token af kontekst for ultrapræcis kontrol.
• Du foretrækker fuldt manuel styring (power users, der gemmer/genskaber planer via filer).

Seneste nyt (2025–2026): I marts 2025 forbedrede Anthropic Auto Compacts bevaringslogik, så opsummeringer blev smartere til at bevare “vigtig info samtidig med at token-forbruget reduceres.” I slutningen af 2025 blev triggeringen forfinet (nogle gange tidligere ved 64–75% brug for at undgå mislykkede komprimeringer). I starten af 2026 var der midlertidige bugs i web-/desktop-grænsefladerne (markeret som fixet midt i januar, men med sporadiske rapporter), mens CLI var stabil. Version 2.0.64 (februar 2026) gjorde komprimering øjeblikkelig, hvilket var en stor forbedring af udvikleroplevelsen.

Sådan bruger du Auto Compact i Claude Code: Trin-for-trin guide

Claude Code er designet, så hver session begynder med et friskt kontekstvindue. Det er nyttigt, fordi hver ny opgave starter rent, og det gør det lettere at se, når en session bliver “støjende”. Det anbefales at bruge /clear mellem ikke-relaterede opgaver, så gammel kontekst ikke fortsat optager plads.

Trin 1: Tjek aktuel kontekststatus

Brug /context til at visualisere den aktuelle kontekstbelastning. Claude Codes indbyggede kommandoliste siger, at /context viser et farvet grid og fremhæver memory-bloat, optimeringsforslag og kapacitetsadvarsler. Det gør det til den hurtigste måde at se, om du nærmer dig punktet, hvor auto-komprimering sandsynligvis vil blive udløst.

I din Claude Code-session, skriv:

/context

Dette viser “Kontekst tilbage indtil auto-compact: XX%” — din realtids-progressbar.

Trin 2: Konfigurer Auto-Compact (valgfrit)

Når kontekstvinduet bliver fyldt, komprimerer Claude Code automatisk samtalen. Hooks-referencen mærker denne hændelse som auto, og den affyres, når kontekstvinduet er fuldt. I praksis “tænder” du ikke auto compact, men lader Claude Code gøre det, når det er nødvendigt.

/config

Naviger til “Auto-compact enabled” og slå til/fra. Standard er slået til. Du kan også justere relaterede indstillinger som brugen af MCP-servere for proaktivt at frigøre tokens.

Trin 3: Lad Auto-Compact køre automatisk

Når du rammer ~95%:

• Claude viser “Komprimerer vores samtale, så vi kan fortsætte med at chatte…” (eller lignende).
• Den kører i baggrunden og genoptager.
• Du vil se den nye opsummering øverst i konteksten.

Pro tip: Vent ikke til 0%. Komprimer manuelt tidligere for bedre resultater (se best practices nedenfor).

Trin 4: Brug hooks, hvis du vil automatisere det, der sker omkring komprimering

Claude Code eksponerer både PreCompact og PostCompact-hooks. Hook-referencen viser, at PreCompact kan detektere, om komprimering er manuel eller automatisk, og PostCompact modtager den genererede compact_summary. Det gør hooks velegnede til logging, revisionsspor, noter efter komprimering eller ekstern automatisering.

Et simpelt hook-mønster ser sådan ud:

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

Og det tilsvarende shell-script kan læse JSON-input fra stdin, fordi Claude Code kommando-hooks modtager JSON på den måde:

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

Dokumentationen bekræfter, at kommando-hooks modtager JSON via stdin, og at PostCompact inkluderer compact_summary, så dette mønster er i overensstemmelse med den aktuelle hook-model.

Trin 5: Manuel komprimering med præcision (anbefalet)

Brug /compact, når du vil have assistenten til at komprimere tråden med det samme. Du kan inkludere instruktioner, der former den opsummering, du vil bevare. Anthropics indbyggede kommandoside angiver /compact [instructions] som “Compact conversation with optional focus instructions,”

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

Det mønster er nyttigt lige før en overdragelse, før et branch-skift, eller før du beder Claude om at starte en ny fase af arbejdet.

Eksempler fra reel brug:

• Efter debugging: /compact bevar den løsning, vi fandt, fjern fejlsøgningsskridt
• Projektmilepæl: /compact fokusér på de nye feature-krav

API-niveau komprimering (avanceret – Python SDK & Messages API)

For tilpassede agenter eller scripts, brug de officielle komprimeringsværktøjer.

Claude Agent Python SDK-eksempel (automatisk for tool-brugende workflows):

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."""
    }
)

Registrer komprimeringshændelser:

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>

Fulde Messages API (beta, 2026) – kræver header:

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’en returnerer en komprimeringsblok, som du skal sende med i fremtidige kald. Tilpassede instruktioner og pausering giver fuld kontrol over budgettering (f.eks. håndhæv et samlet token-loft på 3M på tværs af sessioner).

Hvis du bruger Claude API via CometAPI, ændr message-headeren til "https://api.cometapi.com/v1/messages\\".

Auto-Compact vs Manual Compact vs Clear: Sammenligningstabel

Best practices for Claude Code Auto Compact (pro tips fra udviklere)

Komprimer proaktivt

Brug komprimering som et reset, ikke en krykke. Hvis tråden er fuld af blindgyder, bed Claude om at komprimere med en klar instruktion om, hvad der betyder noget: nuværende mål, valgt tilgang, fejlede tests og uløste spørgsmål. I praksis gør det opsummeringen langt mere nyttig end at lade systemet komprimere blindt og håbe på det bedste.

Hold dine vedvarende instruktioner korte.

Anthropic siger, at filer over 200 linjer kan reducere efterlevelse, så store politikblokke er normalt dårligere end korte, velafgrænsede regler. Brug .claude/rules/ til filtype- eller sti-specifik adfærd, og brug @path-imports, når du har brug for rigere supplerende detaljer uden at gøre hovedinstruktionsfilen oppustet.
Frigør tokens først — Deaktiver ubrugte MCP-servere med /mcp eller @server-name disable før komprimering.

Kombinér med CLAUDE.md

Behandl CLAUDE.md som kilde til sandhed for alt, du vil have til at overleve en lang session. CLAUDE.md genlæses efter /compact, hvilket gør det til det rigtige sted for build-kommandoer, kodningskonventioner og de vedvarende regler, du aldrig vil miste. Auto memory er også nyttigt, men det er et andet system med et andet formål.

Andre tips

Monitorér via /context — Hold forbruget under 70–80% når det er muligt.

For API-brugere — Sæt lavere tærskler (f.eks. 50k–100k) og brug billigere opsummeringsmodeller som Haiku.

Deaktiver kun når nødvendigt — De fleste udviklere anbefaler nu at holde Auto-Compact slået til efter forbedringerne i 2025.

Test komprimering — Først i ikke-kritiske sessioner for at se, hvordan netop dit workflow bliver opsummeret.

Reel effekt: Udviklere rapporterer 2–3x længere produktive sessioner og færre “Claude glemte, hvad vi lavede”-øjeblikke.

Almindelige problemer & fejlfinding (2026-udgave)

• Auto-compact udløses ikke: Tjek web/desktop vs CLI; nogle bugs fra jan 2026 blev fixet, men verificér version.
• Tabt kontekst efter komprimering: Brug manuel /compact med eksplicitte instruktioner næste gang.
• Uendelige løkker eller 102% forbrug: Sjældent; genstart sessionen eller brug /clear som sidste udvej.
• Langsom komprimering: Problem før v2.0.64—opdatér Claude Code.
• API-fejl med komprimeringsblokke: Tilføj altid hele komprimeringsindholdsblokken i opfølgende kald.

Konklusion

Auto compact er en af de vigtigste skjulte mekanismer i Claude Code, fordi den holder lange kodningssessioner brugbare uden at tvinge dig til at genstarte, hver gang kontekstvinduet fyldes. Den praktiske regel er enkel: lad auto compact håndtere overflow, brug /compact, når du vil have kontrol, gem varig vejledning i CLAUDE.md, og brug /clear eller /rewind, når sessionens struktur ændrer sig. Den kombination giver den bedste balance mellem kontinuitet, kontrol og hastighed i lange Claude Code-workflows.

Auto Compact i Claude Code repræsenterer et spring i praktisk AI-assisteret udvikling. Ved intelligent at håndtere kontekstvinduet på 200k tokens eliminerer den den største friktion i langformskodning: at løbe tør for “hukommelse”. Med øjeblikkelig performance (2026), rige konfigurationsmuligheder og kraftfulde API-udvidelser er det nu en moden, gennemtestet funktion, der bruges af tusindvis af udviklere dagligt.

Handlingstrin i dag:

1. Åbn Claude Code og kør /config — bekræft, at Auto-Compact er slået til.
2. Prøv en manuel /compact med instruktioner på dit aktuelle projekt.
3. Udforsk Python SDK eller Messages API for automatiserede agenter i CometAPI.