Welk Claude-model voor welke taak en hoe je ze laat samenwerken

Waarom één model voor alles je geld kost

Wie met Claude werkt, kiest al snel één model en gebruikt dat voor alles. Meestal het duurste, want dat voelt veilig. Elk bericht, elk bestand dat wordt gelezen, elke kleine herschrijving loopt dan tegen het hoogste tarief. Voor het meeste werk is dat niet nodig.

Het grootste deel van het werk in een AI-workflow is lezen, zoeken en samenvatten. Daar heb je geen topmodel voor nodig. Het zware model verdient zijn geld op een paar momenten: bij het bepalen van de aanpak en bij het controleren van het resultaat. In dit artikel leggen we uit wat de vier Claude-modellen doen, hoe je per taak kiest en hoe je ze in Claude Code zo laat samenwerken dat het zware model alleen aan de slag gaat als het echt wat toevoegt.

De vier modellen en waar ze goed in zijn

Anthropic brengt geen enkel "Claude 5" uit. Er zijn vier modellen naast elkaar, elk met een eigen rol en een eigen prijs. De prijzen hieronder zijn per miljoen tokens (invoer / uitvoer), in dollars, uit het modeloverzicht van Anthropic van september 2026. Ze veranderen regelmatig, dus kijk daar voor de actuele stand.

Een vuistregel die goed werkt: Haiku doet het bulkwerk, Sonnet het dagelijkse werk, Opus het zware denkwerk en Fable de uitzonderingen. In de Claude-app en in Claude Code kies je het model zelf. Op een Pro-abonnement is Sonnet 5 de standaard, op Max en Enterprise is dat Opus 5. Fable moet je altijd zelf aanzetten.

Zo kies je per taak

Stel jezelf per klus twee vragen: hoe erg is het als het antwoord half goed is en hoeveel volume gaat er doorheen.

• Veel volume, weinig risico. Honderd binnenkomende mails labelen, een map met offertes doorzoeken op een leverancier, tabellen omzetten. Dit is werk voor Haiku. Het is snel en een foutje is goedkoop te herstellen.
• Gewoon werk. Een brief herschrijven, een script maken, een spreadsheet analyseren, een voorstel opzetten. Begin met Sonnet. In de praktijk is dit het model dat je het vaakst nodig hebt.
• Zwaar denkwerk. Een contract van dertig pagina's beoordelen, een architectuur voor nieuwe software ontwerpen, een probleem dat je zelf ook nog niet doorgrondt. Hier verdient Opus zijn geld terug. Een fout in dit soort werk kost meer dan het prijsverschil.
• De uitzonderingen. Een agent die uren zelfstandig moet doorwerken, of een plan waar alles daarna op leunt. Dan Fable.

Nog een knop die vaak over het hoofd wordt gezien: de nieuwste modellen hebben een effort-instelling. Daarmee bepaal je hoe lang het model nadenkt voordat het antwoordt, van laag tot maximaal. Anthropic schrijft in de eigen documentatie dat effort bijstellen vaak een betere knop is dan van model wisselen. In hun metingen op onderzoekstaken leverde de middelste stand dezelfde kwaliteit voor ongeveer 70 tot 85 procent van de kosten van de standaardstand. Probeer dus eerst een lagere effort op het model dat je al gebruikt en wissel pas daarna van model.

Denk in rollen, niet in één gesprek

Hier zit de echte winst. In plaats van "welk model gebruik ik vandaag" verdeel je het werk in rollen en elke rol krijgt een passend model. Anthropic beschrijft twee manieren om modellen te combineren:

1. Een sterk model dat plant en delegeert. Het topmodel bepaalt de aanpak, verdeelt het werk in losse stukken en geeft die aan goedkope werkers. De werkers doen het zware lees- en zoekwerk en geven alleen een korte samenvatting terug. Het topmodel voegt de uitkomsten samen en controleert. Anthropic noemt dit orchestrator en workers.
2. Een goedkoop model dat om advies vraagt. Het goedkope model doet het werk en roept alleen bij een lastige beslissing een sterker model erbij, bijvoorbeeld als het vastloopt of een aanpak moet kiezen. Anthropic noemt dit executor en advisor.

In beide gevallen werkt je duurste model alleen als het het waard is. De rest loopt op modellen die een fractie kosten. In de metingen van Anthropic op onderzoekswerk dat te groot is voor één gesprek kostte de opzet met een topmodel boven goedkope werkers ongeveer de helft van een enkel topmodel, in een fractie van de doorlooptijd.

Twee gewoontes helpen daarbij, los van het model. Plan voordat je bouwt, want werk dat de verkeerde kant op gaat corrigeren kost veel tokens. En duw leeswerk naar een goedkope werker, zodat je hoofdgesprek licht blijft. Dat laatste is precies wat Anthropic in de orchestrator-opzet beschrijft: de werkers vangen het tokenzware zoekwerk op, zodat het gesprek van het topmodel kort blijft.

Zo stel je het in Claude Code in

Werk je met Claude Code, dan richt je dit in een kwartier in. Drie instellingen doen het meeste werk.

1. Plan met een zwaar model, bouw met een licht model. Claude Code heeft daar een kant-en-klare stand voor:

/model opusplan

In plan-modus gebruikt Claude Code dan Opus voor het nadenken over de aanpak. Zodra je het plan goedkeurt en het bouwen begint, schakelt het automatisch naar Sonnet. Je krijgt het denkwerk van het zware model en betaalt het lichte tarief voor het uitvoeren.

2. Geef werkers een eigen model. Subagents zijn kleine helpers die een deelklus in hun eigen geheugen doen en alleen de uitkomst teruggeven. Je maakt ze als een tekstbestand in de map .claude/agents/ van je project. In de kop bepaal je welk model de helper gebruikt:

---
name: zoeker
description: Zoekt in de code en documentatie en geeft een korte samenvatting terug. Gebruik voor uitzoekwerk.
tools: Read, Grep, Glob
model: haiku
---

Zoek gericht, lees niet meer dan nodig en geef een samenvatting van hooguit tien regels terug met bestandsnamen erbij.

Hetzelfde kan voor een controleur, alleen dan met een sterk model en meer denktijd:

---
name: controleur
description: Beoordeelt een plan of een stuk werk op fouten en gemiste gevallen voordat het wordt opgeleverd.
tools: Read, Grep, Glob
model: opus
effort: high
---

Je verandert niets. Je leest, zoekt naar fouten en ontbrekende gevallen en geeft een lijst met bevindingen terug, ernstigste eerst.

Claude Code kiest de helper vanzelf op basis van de beschrijving, of je vraagt er zelf om ("laat de zoeker eerst uitzoeken waar dit staat"). Het hoofdgesprek blijft schoon, want de tussenresultaten van het zoeken belanden niet in je eigen context.

3. Zet een standaardmodel voor alle helpers. Wil je dat elke helper standaard op een goedkoop model draait, tenzij je anders aangeeft, dan zet je één regel in .claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}

De ingebouwde helpers van Claude Code (zoals Explore voor het doorzoeken van een project) houden hun eigen instelling tenzij je die expliciet overschrijft. Dat is meestal prima.

Ook handig: met /effort low zet je voor een routineklus de denktijd omlaag en met /effort high weer omhoog als het spannend wordt. En begin een grote klus in plan-modus (Shift+Tab), zodat er eerst een plan ligt voordat er iets verandert.

Waar het misgaat

Anthropic beschrijft in de documentatie over kosten en intelligentie ook waar zo'n opzet de mist in gaat. Vier waarschuwingen die daaruit komen:

• Reken per afgeronde taak, niet per token. Anthropic adviseert om de kosten per opgeloste taak te meten en niet per aanvraag. Een goedkoper model dat meer beurten of herkansingen nodig heeft om de klus af te maken, is per saldo niet goedkoper.
• Op lage effort merkt een model niet meer dat het vastzit. Anthropic meet dat een goedkoop model dat op de standaardstand bij de meeste taken om advies vraagt, op lage effort bijna nooit meer om advies vraagt en dan slechter scoort dan alleen. Houd bij zo'n opzet in de gaten of de hulp nog wordt ingeroepen.
• Een enkel model op lagere effort wint vaak. Anthropic raadt aan om eerst de effort op je huidige model te verlagen, omdat dat het goedkoopste experiment is en de meeste toepassingen daar al uitkomen. Op een deel van de onderzoekstaken was het topmodel alleen op lage effort zelfs goedkoper dan een opzet met werkers. Bouw dus pas een combinatie als een enkel model op lagere effort je lat niet haalt.
• Wisselen kost ook wat. Claude bewaart de aanloop van een gesprek in een cache, zodat je daar niet elke beurt opnieuw voor betaalt. Anthropic wijst erop dat een wissel van model of effort die cache vanaf dat punt ongeldig maakt. Wissel dus bij voorkeur aan het begin van een klus.

En de belangrijkste tip uit de modelkeuze-gids van Anthropic: maak een kleine testset met je eigen taken. Pak tien echte opdrachten, laat ze door twee modellen of twee effort-standen doen en vergelijk. Vaak is het verschil kleiner dan je denkt en soms zit het precies op de plek waar je het niet had verwacht.

Hoe je je verbruik inzichtelijk maakt

Werk je op een abonnement (Pro, Max of Team), dan betaal je een vast bedrag en bestaat "kosten per taak" niet in euro's. De munt is je verbruikslimiet: een venster van vijf uur en een weekvenster, gedeeld met de chat-app. Duurder werken betekent eerder tegen die limiet aanlopen. De vraag is dus: hoe kom ik de week door zonder vast te lopen.

• `/usage` in Claude Code toont je plan-balkjes en een uitsplitsing over de laatste 24 uur of 7 dagen: welk deel naar subagents, skills en MCP-servers ging, met een waarschuwing zodra lange context of cache-missers meer dan tien procent van je verbruik uitmaken.
• Het sessieblok in `/usage` geeft een bedrag in dollars tegen lijstprijs. Voor abonnees is dat geen factuur, maar als vergelijkingsmaat is het juist bruikbaar: dezelfde taak op twee modellen en je ziet het verschil. Het bedrag reset bij /clear.
• In de Claude-app zie je alleen een percentage onder Instellingen, Verbruik. Meer dan het percentage noteren voor en na een klus zit er niet in.
• Betaal je per token via de API, dan toont de Console het verbruik per werkruimte en bevat elk antwoord de tokenaantallen. Anthropic adviseert per afgeronde taak te rekenen: totale kosten gedeeld door het aantal taken dat in één keer goed was.

Volgens de documentatie van Claude Code loopt verbruik vooral op door lange sessies die nooit worden geleegd, omdat elke vraag de hele geschiedenis meestuurt. En door een pauze langer dan een uur, waarna de cache koud is en alles opnieuw wordt verwerkt. /clear tussen losse klussen is daarmee de goedkoopste maatregel die er is.

Test het met een skill

Wil je weten welk model of welke effort-stand een terugkerende taak het goedkoopst goed doet, dan meet je dat het makkelijkst door de taak vast te leggen als skill. Een skill is een tekstbestand met een vaste opdracht, dus elke run krijgt precies dezelfde omschrijving en dezelfde invoer. Dat maakt de vergelijking eerlijk.

1. Leg de taak vast. Maak .claude/skills/offerte-check/SKILL.md en zet model en effort er bewust niet in, zodat je die van buitenaf kunt variëren:

---
name: offerte-check
description: Controleert een offerte op ontbrekende onderdelen en geeft een korte lijst terug.
---

Lees `test/offerte.pdf`. Controleer of prijs, geldigheidsduur, levertijd en betaalvoorwaarden erin staan. Geef alleen een lijst van wat ontbreekt.

2. Draai de skill in een lus. Claude Code kan een skill zonder gesprek uitvoeren en geeft dan per run de geschatte kosten terug. Dit script doet dat voor drie modellen en drie effort-standen en schrijft elke run als regel weg:

for model in haiku sonnet opus; do
  for effort in low medium high; do
    CLAUDE_CODE_EFFORT_LEVEL=$effort claude -p "/offerte-check" \
      --model $model --output-format json \
      | jq -r "[\"$model\",\"$effort\",.total_cost_usd,.num_turns,.duration_ms] | @csv" \
      >> verbruik.csv
  done
done

Draai de reeks twee keer en gebruik de tweede. De eerste run per model schrijft de vaste basiscontext van Claude Code naar de cache en betaalt daarvoor; latere runs lezen die goedkoop terug. Zonder die tweede ronde lijkt de eerste stand per model altijd de duurste. Haiku 4.5 kent geen effort-standen, dus die hoef je maar één keer te draaien.

3. Beoordeel en vergelijk. Open verbruik.csv, zet er per regel achter of het resultaat in één keer goed was en deel de kosten door het aantal goede uitkomsten. De instelling met de laagste kosten per goed resultaat wint. Vaak is dat een lichter model of een lagere stand dan je nu gebruikt.

Twee dingen om te weten. De bedragen zijn schattingen tegen de lijstprijs van Anthropic, geen factuur; als vergelijkingsmaat kloppen ze wel. En de vaste basiscontext weegt bij een kleine taak zwaarder dan de taak zelf, dus test met een opdracht van echte omvang, zoals een document van tien pagina's. Op een abonnement tellen de runs mee voor je verbruikslimiet, dus kies een rustig moment.

Kort samengevat

Voor één persoon is dit een handige besparing. Voor een bedrijf dat een proces automatiseert, is "welk model bij welke stap" een ontwerpkeuze. Elke stap krijgt het goedkoopste model dat die stap betrouwbaar aankan: het lezen van een document hoeft niet op hetzelfde model als de eindbeoordeling. In de metingen van Anthropic scheelt dat de helft of meer, zonder dat de kwaliteit inlevert waar het telt. En omdat de modellen snel veranderen, bouw je zo dat het model een instelling is. Komt er iets beters of goedkopers, dan wissel je dat om zonder verbouwing.

Wil je dat je team dit zelf leert toepassen? In een AI training laten we zien hoe de modellen werken, wat ze kosten en hoe je ze in het eigen werk inzet. Daarna kun je het zelf. Plan een gesprek als je dit wilt bespreken.

Bronnen

Alle prijzen, cijfers en instellingen in dit artikel komen uit de documentatie van Anthropic, stand september 2026:

• Modeloverzicht en prijzen
• Choosing the right model
• Optimizing for cost and intelligence (effort-metingen, orchestrator en advisor, waarschuwingen)
• Claude Code: modelkeuze en effort
• Claude Code: subagents
• Claude Code: verbruik en kosten
• Claude Code: skills en headless-modus