Wat is Auto Compact in Claude Code

Claude Code is de agentische programmeerassistent van Anthropic die een codebase kan lezen, bestanden kan bewerken, commando’s kan uitvoeren en kan integreren met tools in terminal-, IDE-, desktop- en browserworkflows. Omdat het werkt binnen een gedeeld contextvenster, lopen lange sessies uiteindelijk vol met chatgeschiedenis, bestanduitvoer en toolmeldingen. Claude Code beheert dit automatisch door de gespreksgeschiedenis te compacteren wanneer je de limiet nadert, en vroege instructies kunnen verloren gaan als ze alleen in de chatgeschiedenis staan.

Dat is in 2026 nog belangrijker omdat Anthropic Claude Code blijft sturen richting langere, meer autonome werkzaamheden. Op 25 maart 2026 publiceerde Anthropic “Claude Code auto mode: a safer way to skip permissions,” waarin staat dat gebruikers 93% van de toestemmingsprompts goedkeuren en auto mode wordt beschreven als een door een classifier aangestuurde middenweg tussen handmatige goedkeuring en onveilige permissie-overslag. Op 5 februari 2026 lanceerde Anthropic ook Claude Opus 4.6, met nadruk op sterker coderen, beter debuggen en langere agentische sessies. Die updates zijn niet hetzelfde als auto compact, maar ze laten de productrichting duidelijk zien: minder onderbrekingen, langere sessies en betrouwbaardere continuïteit.

CometAPI biedt momenteel toegang tot de Claude API tegen een lagere prijs dan de officiële API, bijvoorbeeld Claude Sonnet 4.6, Claude Opus 4.6, en de Claude 5.

Wat Auto-Compact werkelijk betekent in Claude Code

Auto Compact is een ingebouwd mechanisme voor contextoptimalisatie in Claude Code (de CLI/desktoptool van Anthropic) en het bredere Claude API-ecosysteem. Het grijpt automatisch in wanneer je gesprek het plafond van het contextvenster nadert—meestal rond 200.000 tokens voor topmodellen zoals Claude Opus 4 of Sonnet 4. De hooksdocumentatie is expliciet: PreCompact wordt geactiveerd vóór een compactie-operatie en de auto matcher betekent “auto-compact wanneer het contextvenster vol is.” De bijbehorende PostCompact hook wordt geactiveerd nadat compactie is voltooid en ontvangt de gegenereerde compact_summary.

Dat is belangrijk omdat compactie niet hetzelfde is als “memory”. Auto memory is Claude’s eigen notitiesysteem, terwijl compactie een sessiebeheermechanisme is dat de live gespreksstatus comprimeert. De memory-docs zijn duidelijk dat CLAUDE.md persistent is, auto memory wordt door Claude geschreven, en compactie is het moment waarop de gespreksgeschiedenis van de sessie wordt verkleind zodat het model kan blijven werken.

In plaats van een nieuwe chat af te dwingen (en geschiedenis kwijt te raken) of het model kritieke details te laten “vergeten”, doet Auto Compact het volgende:

1. Analyseert de volledige geschiedenis — identificeert kernonderdelen die het waard zijn om te behouden.
2. Genereert een beknopte samenvatting — van beslissingen, code-architectuur, opgeloste bugs, bestandsstatussen en volgende stappen.
3. Vervangt oudere berichten — door deze samenvatting (een “compactieblok” in API-termen).
4. Hervat naadloos — met de behouden context.

Kerngegevens (2026):

• Triggert drempel: Standaard ~95% capaciteit (of ~25% resterend). Sommige gebruikers melden een interne buffer die 20–45k tokens (~22,5% van de context) reserveert voor het compactieproces zelf.
• Prestatieverbetering: Sinds Claude Code v2.0.64 is compactie “onmiddellijk” in plaats van minuten te duren.
• Voorbeeld van tokenbesparing (uit Claude Agent SDK-benchmarks): Een workflow met 5 tickets daalde van 204k naar 82k inputtokens (58,6% reductie) met twee compactie-events.

Auto Compact is niet hetzelfde als /clear (wat alles wist) of eenvoudige truncatie. Het behoudt intelligent wat ertoe doet—recente code-diffs, architecturale keuzes, naamgevingsconventies—terwijl opgeloste debugloops en verkennende zijpaden worden gecondenseerd.

Waarom Auto Compact gebruiken in Claude Code?

Lange codeersessies zijn de norm. Een enkele feature-implementatie kan 50+ beurten beslaan: plannen, debuggen, refactoren, testen. Zonder compactie groeit het tokenverbruik lineair, neemt de responskwaliteit af en schieten kosten omhoog.

Voor ontwikkelaars is de opbrengst minder herstartmoeheid. In plaats van handmatig een samenvatting te kopiëren naar een nieuwe sessie, laat je Claude de sessie compacteren en ga je verder. Dat is vooral nuttig in bugfixing, refactors over meerdere bestanden, testgedreven wijzigingen en review-intensieve workflows waarin het gesprek erg lang kan worden. Claude Code-sessies beginnen met een fris contextvenster, dus compactie is een van de sleutelmechanismen die langlopend werk praktisch maken.

Kernvoordelen

• Onbeperkte sessielengte: Ga onbeperkt door zonder opnieuw te hoeven beginnen.
• Kost- en prestatie-efficiëntie: Vermindert inputtokens drastisch. Praktijkrapporten tonen 50–60% besparing in meerfasige workflows.
• Betere focus en stabiliteit: Voorkomt “context-overload” waarbij het model hallucineert of eerdere randvoorwaarden vergeet.
• Behoudt institutionele kennis: Belangrijke beslissingen blijven in context, zelfs na honderden berichten.
• Naadloos voor agentische workflows: Cruciaal bij gebruik van tools, MCP-servers of multi-agentopstellingen in Claude Code.

Wanneer kun je op Auto Compact rekenen?

Gebruik Auto Compact wanneer de taak van nature langlopend is: refactors over meerdere bestanden, debug-sessies die wisselen tussen logs en broncode, feature-implementatie met herhaalde verificatie, of onderzoek dat veel toolcalls vereist. De documentatie van Anthropic wijst expliciet op lange sessies waarin het contextvenster volloopt met irrelevante conversatie, bestandsinhoud en commando’s, en zegt dat auto-compactie belangrijke code en beslissingen behoudt terwijl ruimte wordt vrijgemaakt.

Het is minder geschikt wanneer de taak kort, geïsoleerd is, of precieze, permanent behouden instructies vereist. Instructies uit het begin van het gesprek kunnen na compactie verloren gaan; daarom horen projectregels in CLAUDE.md, niet in een wegwerp-prompt die later kan worden samengeperst.

Wanneer te gebruiken (of in te schakelen):

• Standaard altijd aan voor de meeste gebruikers — ideaal voor dagelijks coderen, grote refactors of verkennende projecten.
• Langlopende taken — verwerkingsqueues, datapijplijnen of codebases met meerdere bestanden.
• Team/enterprise-omgevingen — waar contextcontinuïteit over sessies heen belangrijk is.
• Projecten met hoge inzet — waar het verlies van één architectuurkeuze uren kan kosten.

Wanneer overwegen uit te schakelen (via /config):

• Je wilt elke token aan context voor ultranauwkeurige controle.
• Je verkiest volledig handmatig beheer (power users die plannen via bestanden opslaan/herstellen).

Laatste nieuws (2025–2026): In maart 2025 verbeterde Anthropic de bewaarlogica van Auto Compact, waardoor samenvattingen slimmer werden in het behouden van “belangrijke info terwijl het tokenverbruik wordt verminderd.” Eind 2025 werd het triggeren verfijnd (soms eerder bij 64–75% gebruik om mislukte compacties te voorkomen). Begin 2026 waren er tijdelijke bugs in de web-/desktopinterfaces (gemarkeerd als opgelost medio januari, maar met aanhoudende meldingen), terwijl de CLI stabiel bleef. Versie 2.0.64 (feb 2026) maakte compactie instant, een grote winst voor de ontwikkelaarservaring.

Auto Compact gebruiken in Claude Code: stapsgewijze gids

Claude Code is zo ontworpen dat elke sessie begint met een fris contextvenster. Dat is nuttig omdat elke nieuwe taak schoon start, en het maakt het ook makkelijker om te zien wanneer een sessie lawaaierig wordt. Aanbevolen: /clear tussen niet-gerelateerde taken zodat verouderde context geen ruimte blijft innemen.

Stap 1: Controleer de huidige contextstatus

Gebruik /context om de huidige contextbelasting te visualiseren. De ingebouwde commandolijst van Claude Code zegt dat /context een gekleurde grid toont en memory-bloat, optimalisatiesuggesties en capaciteitswaarschuwingen highlight. Dat is de snelste manier om te zien of je het punt nadert waarop auto-compactie waarschijnlijk wordt geactiveerd.

Typ in je Claude Code-sessie:

/context

Dit toont “Context left until auto-compact: XX%” — je voortgangsbalk in realtime.

Stap 2: Configureer Auto-Compact (optioneel)

Wanneer het contextvenster vol raakt, compacteert Claude Code het gesprek automatisch. De hooksreferentie labelt deze gebeurtenis als auto, en hij wordt geactiveerd wanneer het contextvenster vol is. In de praktijk “schakel” je Auto Compact niet zozeer in, maar laat je Claude Code het doen wanneer nodig.

/config

Navigeer naar “Auto-compact enabled” en zet aan/uit (true/false). Standaard is ingeschakeld. Je kunt ook gerelateerde instellingen bijstellen, zoals het gebruik van MCP-servers, om proactief tokens vrij te maken.

Stap 3: Laat Auto-Compact automatisch draaien

Wanneer je ~95% bereikt:

• Claude geeft weer: “Compacting our conversation so we can keep chatting…” (of iets soortgelijks).
• Het draait op de achtergrond en hervat.
• Je ziet de nieuwe samenvatting bovenaan de context.

Pro tip: Wacht niet tot 0%. Compacteer handmatig eerder voor betere resultaten (zie best practices hieronder).

Stap 4: Gebruik hooks als je wilt automatiseren wat er rond compactie gebeurt

Claude Code stelt zowel PreCompact als PostCompact hooks bloot. De hookreferentie laat zien dat PreCompact kan detecteren of compactie handmatig of automatisch is, en PostCompact ontvangt de gegenereerde compact_summary. Daarmee zijn hooks zeer geschikt voor logging, audit-trails, notities na compactie of externe automatisering.

Een eenvoudige hookpattern ziet er zo uit:

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

En het bijbehorende shellscript kan de JSON-invoer van stdin lezen, omdat Claude Code command-hooks JSON op die manier ontvangen:

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

De docs bevestigen dat command-hooks JSON via stdin ontvangen, en dat PostCompact compact_summary bevat, dus dit pattern is in lijn met het huidige hookmodel.

Stap 5: Handmatige compactie met precisie (aanbevolen)

Gebruik /compact wanneer je wilt dat de assistent de thread nu comprimeert. Je kunt instructies toevoegen die de samenvatting vormen die je wilt behouden. De ingebouwde commandopagina van Anthropic noemt /compact [instructions] “Compact conversation with optional focus instructions,”

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

Dat patroon is nuttig vlak vóór een overdracht, vóór een branchswitch, of voordat je Claude vraagt een nieuwe fase van het werk te starten.

Voorbeelden uit de praktijk:

• Na het debuggen: /compact behoud de oplossing die we vonden, verwijder debugstappen
• Projectmijlpaal: /compact focus op de nieuwe feature-eisen

Compactie op API-niveau (geavanceerd – Python SDK & Messages API)

Voor maatwerkagents of scripts gebruik je de officiële compactietools.

Claude Agent Python SDK-voorbeeld (automatisch voor tool-gebruikende 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."""
    }
)

Detecteer compactie-events:

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>

Volledige Messages API (beta, 2026) – vereist 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
      }]
    }
  }'

De API retourneert een compactieblok dat je moet meegeven in toekomstige calls. Aangepaste instructies en pauzeren geven volledige controle over budgeting (bijv. een totale tokenlimiet van 3M afdwingen over sessies).

Als je de Claude API van CometAPI gebruikt, verander de message header naar "https://api.cometapi.com/v1/messages\\".

Auto-Compact vs Manual Compact vs Clear: vergelijkingstabel

Best practices voor Claude Code Auto Compact (Pro tips van ontwikkelaars)

Compacteer proactief

De derde regel is om compactie te gebruiken als een reset, niet als een kruk. Als de thread vol staat met doodlopende paden, vraag Claude om te compacten met een duidelijke instructie over wat belangrijk is: huidige doelstelling, gekozen aanpak, falende tests en open vragen. In de praktijk maakt dat de samenvatting veel nuttiger dan de systeemcompactie blind te laten gebeuren en te hopen op het beste.

Houd je duurzame instructies kort.

Anthropic zegt dat bestanden van meer dan 200 regels de naleving kunnen verminderen, dus grote beleidsblokken zijn meestal slechter dan beknopte, goed afgebakende regels. Gebruik .claude/rules/ voor bestandstype- of pad-specifiek gedrag, en gebruik @path-imports wanneer je rijkere ondersteunende details nodig hebt zonder de hoofd-instructiefile op te blazen.
Eerst tokens vrijmaken — Schakel ongebruikte MCP-servers uit met /mcp of @server-name disable vóór compacteren.

Combineer met CLAUDE.md

Zie CLAUDE.md als de bron van waarheid voor alles wat je door een lange sessie heen wilt laten overleven. CLAUDE.md wordt opnieuw gelezen na /compact, wat het de juiste plek maakt voor buildcommando’s, codeerconventies en de persistente regels die je nooit wilt verliezen. Auto memory is ook nuttig, maar het is een ander systeem met een andere bedoeling.

Overige tips

Monitor via /context — Houd het gebruik waar mogelijk onder 70–80%.

Voor API-gebruikers — Stel lagere drempels in (bijv. 50k–100k) en gebruik goedkopere summarizermodellen zoals Haiku.

Alleen uitschakelen indien nodig — De meeste ontwikkelaars raden na de verbeteringen van 2025 aan om Auto-Compact aan te houden.

Test compactie — Eerst in niet-kritieke sessies om te zien hoe jouw specifieke workflow wordt samengevat.

Impact in de praktijk: Ontwikkelaars melden 2–3x langere productieve sessies en minder “Claude vergat wat we aan het doen waren”-momenten.

Veelvoorkomende problemen & troubleshooting (editie 2026)

• Auto-compact triggert niet: Controleer web/desktop vs CLI; sommige bugs van jan. 2026 zijn verholpen maar verifieer je versie.
• Context kwijt na compactie: Gebruik de volgende keer handmatige /compact met expliciete instructies.
• Oneindige loops of 102% gebruik: Zeldzaam; herstart de sessie of gebruik /clear als laatste redmiddel.
• Langzame compactie: Issue vóór v2.0.64—update Claude Code.
• API-fouten met compactieblok: Voeg altijd de volledige compactiecontentblock toe in vervolgcalls.

Conclusie

Auto compact is een van de belangrijkste verborgen mechanismen in Claude Code omdat het lange codeersessies bruikbaar houdt zonder te dwingen om elke keer opnieuw te beginnen wanneer het contextvenster vol raakt. De praktische regel is simpel: laat auto compact het overflow-probleem afhandelen, gebruik /compact wanneer je controle wilt, sla duurzame richtlijnen op in CLAUDE.md, en gebruik /clear of /rewind wanneer de sessiestructuur verandert. Die combinatie geeft je de beste balans tussen continuïteit, controle en snelheid in lange Claude Code-workflows.

Auto Compact in Claude Code vertegenwoordigt een sprong in praktische AI-geassisteerde ontwikkeling. Door het 200k-token contextvenster intelligent te beheren, elimineert het de grootste frictie in langvorm coderen: geheugen tekort. Met instant prestaties (2026), rijke configuratie-opties en krachtige API-uitbreidingen is het nu een volwassen, in de praktijk beproefde feature die dagelijks door duizenden ontwikkelaars wordt gebruikt.

Actiestappen voor vandaag:

1. Open Claude Code en voer /config uit — bevestig dat Auto-Compact is ingeschakeld.
2. Probeer een handmatige /compact met instructies voor je huidige project.
3. Verken de Python SDK of Messages API voor geautomatiseerde agents in CometAPI.