# ChatGPT-modellen vergelijken: welk GPT-6-model kies je voor welke taak?

OpenAI heeft drie GPT-6-modellen naast elkaar: Astra, Sol en Luna. Het duurste model voor alles inzetten kost je geld en tijd, terwijl veel werk prima door een lichter model kan. Zo kies je per taak en zo laat je de modellen samenwerken in ChatGPT en Codex.

Gepubliceerd: 2026-10-25 · Studio Vaart · https://vaart.studio/kennisbank/blog/chatgpt-modellen-vergelijken

## Waarom één model voor alles je geld kost

Wie met ChatGPT of Codex werkt, kiest al snel één model en één stand en gebruikt die voor alles. Vaak de zwaarste, want dat voelt veilig. Elke vraag, elk bestand dat wordt gelezen en elke kleine aanpassing loopt dan tegen het hoogste tarief of gaat af van je verbruikslimiet. Voor werk dat steeds terugkomt of dat je precies kunt omschrijven, is dat niet nodig.

Zulk werk, zoals mails sorteren, gegevens uit documenten halen of een vaste controle uitvoeren, doet een lichter model net zo goed. Het sterkste model zet je in waar het verschil maakt: bij de aanpak bepalen, bij complex werk en bij het controleren van het resultaat. In dit artikel leggen we uit wat de GPT-6-modellen doen, hoe je per taak kiest en hoe je ze in Codex zo laat samenwerken dat elk model doet waar het goed in is. Werk je met Claude? Dan lees je hetzelfde verhaal in [welk Claude-model voor welke taak](https://vaart.studio/kennisbank/blog/welk-claude-model-voor-welke-taak).

## De drie modellen en waar ze goed in zijn

In september bracht OpenAI de GPT-6-familie uit: drie modellen naast elkaar, elk met een eigen rol en een eigen prijs. Alle drie zijn het denkende modellen (reasoning models): ze denken na voordat ze antwoorden en jij bepaalt hoe lang. Kleine mini- en nano-versies zoals bij GPT-5 zijn er in deze generatie niet meer, die rol neemt Luna over. De prijzen hieronder zijn per miljoen tokens (invoer / uitvoer), in dollars, van de prijspagina van OpenAI van oktober 2026. Ze veranderen regelmatig, dus kijk daar voor de actuele stand.

| Model | Prijs per miljoen tokens (in / uit) | Waar je het voor gebruikt |
| --- | --- | --- |
| GPT-6 Luna | $0,10 / $0,50 | Volumewerk: sorteren, labelen, gegevens eruit halen, kleine precieze aanpassingen. Snel en heel goedkoop. |
| GPT-6.1 Sol | $2 / $10 | Het dagelijkse werkpaard: technisch werk, teksten, analyses en projecten waar de kosten meetellen. Het model achter ChatGPT. |
| GPT-6 Astra | $10 / $50 | De bovengrens: grote projecten met veel context, grondige analyses en werk met strenge eisen. |

Alle drie kunnen ruim een miljoen tokens aan context aan. Gaat je vraag over meer dan 272.000 tokens, dan rekent OpenAI voor die hele vraag een hoger tarief: de invoer kost het dubbele, de uitvoer anderhalf keer zoveel. Van Sol bestaan twee versies. GPT-6.1 Sol kwam op 29 september uit en is de opvolger van GPT-6 Sol van een week eerder, voor dezelfde prijs en met een goedkopere cache.

OpenAI omschrijft Luna als het voordeligste model en Astra als het krachtigste. Voor GPT-6.1 Sol is het advies om het te overwegen voor complexe projecten waar de kosten meetellen en het naast Astra op dezelfde taak te testen. Een vuistregel die daarbij past: Luna doet het bulkwerk, Sol vrijwel al het andere en Astra het werk waar een fout duur is.

## Wat je kiest in ChatGPT

In ChatGPT kies je niet tussen drie modellen. Je kiest GPT-6 en met een schuif hoe lang het mag nadenken: Instant, Medium, High of Extra High. Die standen draaien allemaal op Sol. De stand Pro draait op Astra. Een automatische stand die zelf bepaalt hoeveel denkwerk een vraag nodig heeft, is er op Plus en Pro niet. Op Instant blijft ChatGPT op Instant, ook als je vraag lastig is. Wat je kiest, is dus wat je krijgt.

- **Plus** kan in de chat tot en met High.
- **Pro, Business en Enterprise** krijgen ook Extra High en Pro, met een beperkt aantal Pro-berichten per week of per maand.
- **Codex en Work** (de agent die zelfstandig taken uitvoert) bieden Luna, Sol en, afhankelijk van je abonnement, Astra. Op Plus krijg je Astra daar wel, in de chat niet.

Voor dagelijks werk in ChatGPT is Medium een goede standaard. Merk je dat het antwoord te oppervlakkig is of dat er stappen worden overgeslagen, zet de schuif dan een stand hoger. Een korte vraag of een snelle herschrijving doe je op Instant.

## 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. OpenAI geeft in zijn gids voor modelkeuze zelf een reeks combinaties van model en denktijd. Vertaald naar de praktijk:

- **Veel volume, weinig risico.** Honderd binnenkomende mails labelen, gegevens uit facturen halen, een tabel omzetten. Dit is werk voor Luna op een lage stand. Het is snel en een foutje is goedkoop te herstellen. Moet Luna informatie uit meerdere bronnen bij elkaar zoeken of taken rangschikken, zet de denktijd dan hoger.
- **Gewoon werk.** Een voorstel opzetten, een script schrijven, een spreadsheet analyseren, een rapport waar je nog een paar keer aan schaaft. GPT-6.1 Sol op medium is hier de standaard.
- **Zwaar denkwerk.** Een groot project waarvoor het model veel context moet overzien, een analyse met strenge eisen, een beslissing op basis van bronnen die elkaar tegenspreken. Begin met Sol op een hogere stand. Haalt dat je lat niet, dan is Astra aan de beurt.
- **Opvallend:** OpenAI noemt Astra op een lage stand juist voor schrijfwerk dat de feiten en nuance van een bron moet bewaren, zoals een tekst inkorten of herschrijven voor een andere doelgroep.

Het advies van OpenAI zelf: test met dezelfde invoer en houd de lichtste instelling die je kwaliteitslat haalt.

## De knop die je vaak vergeet: denktijd

Met de **reasoning effort** bepaal je hoe lang het model nadenkt voordat het antwoordt. De standen lopen van none (niet nadenken) via low, medium en high tot xhigh en max. Niet elk model kent elke stand: Luna kan helemaal zonder denken, GPT-6.1 Sol begint bij low. Medium is de standaard en volgens OpenAI de juiste stand voor de meeste toepassingen.

- **none en low** voor werk waar snelheid telt en weinig te overwegen valt, zoals classificeren of een simpele aanpassing.
- **medium** als kwaliteit en betrouwbaarheid ertoe doen en de taak planning en oordeel vraagt.
- **high** voor lastig denkwerk, complexe foutopsporing en diepgaande planning.
- **xhigh** alleen als je in je eigen tests een duidelijk voordeel ziet dat de extra wachttijd en kosten waard is. Dat is letterlijk het advies van OpenAI.

Twee dingen om te weten. De denkstappen worden gerekend als uitvoer, het duurste deel van de prijs. Ze nemen ook ruimte in het geheugen van het model in. Een hogere stand kost dus echt meer. En OpenAI schrijft dat de denktijd een knop is om bij te stellen, niet de belangrijkste manier om kwaliteit terug te halen. Is een antwoord slecht, kijk dan eerst naar je opdracht en de context die je meegeeft. Probeer daarna een andere stand op het model dat je al gebruikt en wissel pas als laatste van model.

## Denk in rollen

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. In Codex doe je dat op twee manieren:

1. **Een hoofdgesprek met helpers.** Het hoofdgesprek houdt de regie op een sterk model, verdeelt het werk en zet helpers in op een licht model. De helpers doen het lees- en zoekwerk in hun eigen geheugen en geven alleen hun uitkomst terug. Het hoofdgesprek voegt alles samen en controleert.
2. **Vaste klussen als skill.** Werk dat steeds terugkomt, leg je vast als skill: een vaste opdracht met vaste stappen die je met één aanroep start. Een klus die zo goed omschreven is, kan vaak op een lichter model of een lagere denkstand.

In beide gevallen werkt je duurste model alleen waar het iets toevoegt. De rest loopt op modellen die een fractie kosten.

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 helper, zodat je hoofdgesprek licht blijft.

## Zo stel je het in Codex in

Codex is de programmeeragent van OpenAI, in de terminal, in je editor en in ChatGPT. Ook voor ander werk dan programmeren is het een handige plek om modellen te laten samenwerken. De instellingen staan in `~/.codex/config.toml`.

**1. Kies een standaardmodel en een denktijd.** Twee regels zijn genoeg. Met `plan_mode_reasoning_effort` geef je de planfase een eigen, hogere stand, terwijl het bouwen op medium blijft:

```
model = "gpt-6.1-sol"
model_reasoning_effort = "medium"
plan_mode_reasoning_effort = "high"
```

Tijdens een sessie wissel je met `/model` van model en denktijd. Voor één opdracht kan het ook bij het starten, bijvoorbeeld `codex -m gpt-6-luna`.

**2. Geef helpers een eigen model.** Codex kan subagents inzetten: helpers die een deelklus in hun eigen geheugen doen en alleen de uitkomst teruggeven. Je maakt ze als een los bestand in de map `.codex/agents/` van je project. Een helper voor uitzoekwerk op Luna ziet er zo uit:

```
name = "zoeker"
description = "Zoekt in de code en documentatie en geeft een korte samenvatting terug."
model = "gpt-6-luna"
model_reasoning_effort = "low"
developer_instructions = """
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 sterker model en meer denktijd:

```
name = "controleur"
description = "Beoordeelt een plan of een stuk werk op fouten en gemiste gevallen."
model = "gpt-6.1-sol"
model_reasoning_effort = "high"
developer_instructions = """
Je verandert niets. Je leest, zoekt naar fouten en ontbrekende
gevallen en geeft een lijst met bevindingen terug, ernstigste eerst.
"""
```

**3. Zeg wanneer Codex ze moet inzetten.** Codex start helpers als je erom vraagt ("laat de zoeker eerst uitzoeken waar dit staat") of als een instructie in je project dat zegt. Zet daarom in het bestand `AGENTS.md` in de hoofdmap van je project een regel als "Laat uitzoekwerk altijd door de zoeker doen en laat de controleur meekijken voordat je iets oplevert." Codex leest dat bestand bij elke sessie.

**4. Zet een standaard voor alle helpers.** Wil je dat elke helper standaard op een licht model draait, tenzij je anders aangeeft, dan zet je dit in je `config.toml`:

```
[agents]
default_subagent_model = "gpt-6-luna"
default_subagent_reasoning_effort = "low"
```

Let op: geef je een helper alleen een model en geen denktijd, dan neemt hij de stand van het hoofdgesprek over. Die stand bestaat niet altijd voor het andere model. Zet ze dus altijd allebei.

Wil je dit samen met je team inrichten? In een [OpenAI workshop](https://vaart.studio/diensten/inspireren-leren/ai-workshops) zetten we ChatGPT en Codex op met jullie eigen werk: de juiste modellen en denktijd, subagents, `AGENTS.md` en skills. Wat je team bouwt, blijft in jullie eigen omgeving staan.

## Waar het misgaat

Uit de documentatie van OpenAI komen drie waarschuwingen waar je in de praktijk tegenaan loopt:

- **Reken per afgeronde taak, niet per token.** Een lichter model dat meer pogingen nodig heeft om de klus af te maken, is per saldo niet goedkoper. Hetzelfde geldt voor een hoge denkstand op een simpele klus: de denkstappen worden als uitvoer betaald.
- **Helpers kosten ook tokens.** OpenAI schrijft dat werken met subagents meer tokens gebruikt dan hetzelfde werk door één agent. Het loont bij veel lees- en zoekwerk dat je hoofdgesprek anders vol zou zetten. Voor een kleine klus is één model op een lagere stand vaak goedkoper.
- **Wisselen kost ook wat.** OpenAI bewaart het begin van een gesprek in een cache, zodat je daar niet elke beurt opnieuw de volle prijs voor betaalt. Een wissel van model, denktijd, tools of uitvoerlengte maakt die cache ongeldig. Wissel dus bij voorkeur aan het begin van een klus.

En de belangrijkste tip: maak een kleine testset met je eigen taken. Pak tien echte opdrachten, laat ze door twee modellen of twee denkstanden 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 met een ChatGPT-abonnement (Plus, Pro of Business), dan betaal je een vast bedrag. De munt is je verbruikslimiet. Codex en Work delen één limiet per periode van vijf uur, met daarnaast soms een weeklimiet. Op Pro is er op dit moment geen limiet per vijf uur.

Hoe zwaar een model op die limiet drukt, laat OpenAI zelf zien. Op Plus is de schatting per vijf uur in Codex: 5 tot 45 berichten met Astra, 15 tot 160 met GPT-6.1 Sol en 350 tot 3.000 met Luna. Wie alles op Astra doet, zit dus snel aan de limiet.

- **In Codex** toont `/status` hoeveel je nog over hebt. Op [chatgpt.com/codex/settings/usage](https://chatgpt.com/codex/settings/usage) zie je je limieten en wanneer ze weer aanvullen.
- **De snelle stand** (Fast) is handig als je haast hebt, maar gebruikt 2,5 keer zoveel van je limiet voor hetzelfde werk.
- **Betaal je per token via de API**, dan toont het dashboard de kosten per project en per API-key. Je kunt er ook een harde maandgrens instellen.

Lange gesprekken die nooit worden opgeschoond zijn een bekende verbruiker, omdat elke nieuwe vraag de hele geschiedenis meestuurt. Begin voor een nieuwe klus dus een nieuw gesprek.

## Test het met een skill

Wil je weten welk model of welke stand een terugkerende taak het goedkoopst goed doet, leg de taak dan vast als skill. Een skill is een map met 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 een testmap buiten je projecten, zodat er geen projectinstructies meelezen. Zet daarin de offerte die je wilt laten controleren en maak `.agents/skills/offerte-check/SKILL.md`. Zet er geen model of denktijd in, zodat je die van buitenaf kunt variëren. Schrijf wel precies op wat een goed resultaat is, want daar toets je straks op:

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

Lees `offerte.pdf`. Controleer of prijs, geldigheidsduur, levertijd en betaalvoorwaarden erin staan. Geef alleen een lijst van wat ontbreekt. Noem niets wat niet in de offerte staat.
```

**2. Draai de skill per instelling.** Met `codex exec` voert Codex een opdracht uit zonder gesprek. Met `--json` krijg je per run een verslag terug, inclusief het aantal tokens. Dit script draait elke combinatie van drie modellen en drie denkstanden drie keer, telkens in een schone kopie van je testmap. Het verbruik per run komt in een spreadsheet:

```
echo "model,effort,run,invoer,uit_cache,uitvoer" > verbruik.csv
for model in gpt-6-luna gpt-6.1-sol gpt-6-astra; do
  for effort in low medium high; do
    for run in 1 2 3; do
      map="runs/$model-$effort-$run"
      rm -rf "$map" && cp -R testmap "$map"
      codex exec --json --ephemeral --ignore-user-config --skip-git-repo-check \
        -C "$map" -m $model -c model_reasoning_effort=$effort \
        -o "$PWD/$map/antwoord.md" '$offerte-check Controleer offerte.pdf' \
        | jq -r --arg m $model --arg e $effort --arg r $run \
          'select(.type=="turn.completed") | [$m, $e, $r,
            .usage.input_tokens, .usage.cached_input_tokens,
            .usage.output_tokens] | @csv' \
        >> verbruik.csv
    done
  done
done
```

Met `$offerte-check` in de opdracht roep je de skill bij naam aan. Zet de opdracht tussen enkele aanhalingstekens, anders maakt de terminal er een lege tekst van. Door `--ignore-user-config` en `--ephemeral` tellen je eigen instellingen en eerdere sessies niet mee. Elke instelling draait drie keer, omdat een model niet elke keer precies hetzelfde doet. De eerste run valt bovendien vaak duurder uit, omdat het vaste begin van de opdracht daarna uit de cache komt. Ontbreekt er een regel in de spreadsheet, dan ging die run mis.

**3. Reken het om naar kosten.** Codex geeft tokens terug, geen bedragen. Het getal voor invoer bevat de tokens uit de cache al, dus trek die eraf en reken ze tegen het lagere cachetarief. Werk je met een API-key, gebruik dan de prijzen uit de tabel bovenaan. Op een abonnement gebruik je de tarieven in credits die OpenAI publiceert. Per miljoen tokens (invoer / uit cache / uitvoer) is dat 2,5 / 0,25 / 12,5 credits voor Luna, 50 / 2,5 / 250 voor GPT-6.1 Sol en 250 / 25 / 1.250 voor Astra. Zo zie je hoeveel zwaarder de ene run op je limiet drukt dan de andere.

**4. Beoordeel de uitkomsten.** Lees per run `antwoord.md` en zet in de spreadsheet of het resultaat goed was. Bij een vaste controle als deze kun je ook Codex laten beoordelen: laat één vast model op een hoge stand elk antwoord naast je eigen lijst leggen van wat erin hoort. Gebruik daarvoor steeds hetzelfde model, zodat de beoordelaar niet per run verschilt. Kies daarna de lichtste instelling die alle drie de keren goed was. Vaak is dat een lichter model of een lagere stand dan je nu gebruikt.

Test met een opdracht van echte omvang, zoals een offerte van een paar pagina's. Bij een heel kleine taak zegt het verschil weinig. Op een abonnement tellen de runs mee voor je limiet: negen instellingen keer drie runs zijn 27 opdrachten, waarvan een deel op Astra. Kies dus 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 lichtste model dat die stap betrouwbaar aankan: het uitlezen van een document hoeft niet op hetzelfde model als de eindbeoordeling. 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 die keuzes niet alleen maken? In een [AI consultancy-traject](https://vaart.studio/diensten/strategie/ai-consultancy) kijken we op vaste momenten met je mee: waar AI in jullie processen het verschil maakt, welke tools en modellen daarbij passen en hoe je dat zo inricht dat het betaalbaar blijft. [Plan een gesprek](https://vaart.studio/contact) als je dit wilt bespreken.

## Bronnen

Prijzen en instellingen in dit artikel komen uit de documentatie van OpenAI, stand oktober 2026:

- [Modellen](https://developers.openai.com/api/docs/models), [prijzen](https://developers.openai.com/api/docs/pricing) en [modelkeuze](https://developers.openai.com/api/docs/guides/model-selection)
- [Reasoning](https://developers.openai.com/api/docs/guides/reasoning) (denktijd) en [prompt caching](https://developers.openai.com/api/docs/guides/prompt-caching)
- [GPT-6 en andere modellen in ChatGPT](https://help.openai.com/en/articles/20001354-gpt-6-and-other-models-in-chatgpt)
- Codex: [modellen](https://learn.chatgpt.com/docs/models), [configuratie](https://learn.chatgpt.com/docs/config-file/config-reference), [subagents](https://learn.chatgpt.com/docs/agent-configuration/subagents), [AGENTS.md](https://learn.chatgpt.com/docs/agent-configuration/agents-md), [skills](https://learn.chatgpt.com/docs/build-skills) en [verbruik](https://learn.chatgpt.com/docs/pricing)

## Een OpenAI workshop voor je team

Een dagdeel of dag waarin je team zelf met ChatGPT en Codex aan de slag gaat, op jullie eigen werk. Modelkeuze, denktijd en Codex inrichten: wat je leert, gebruik je de volgende dag.

- Voorbereidend gesprek en een programma op maat
- Minimaal een dagdeel, tot 12 deelnemers
- Bij jou op locatie of op een gehuurde locatie
- Alles wat je team bouwt, blijft in jullie eigen omgeving

[Bekijk AI workshops](https://vaart.studio/diensten/inspireren-leren/ai-workshops). Vanaf € 1000 exclusief btw per workshop.