Goedkoopste LLM voor AI-agents: 30 modellen gerangschikt op kosten per run

Als we de Tier D-modellen hieronder buiten beschouwing laten, is het goedkoopste model dat een tool-calling-agent kan draaien nu Claude Haiku 5.5, tegen $0.10 in / $0.50 uit per 1M tokens, of $0.0185 voor een referentie-uitvoering van 12 stappen; GPT-6 Luna kost hetzelfde. De grootste aanroep in deze uitvoering is 23,800 tokens, ruim onder de 100,000-token grens waar Haiku 5.5 $0.50 / $2.50 rekent. DeepSeek V4.1 Flash kost $0.027 buiten de piekuren ($0.15 / $0.60); tijdens de piekuren van DeepSeek kost het $0.30 / $1.20, of $0.054, en GPT-5.4 nano ($0.038) is goedkoper. V4.1 Flash verving V4 Flash, dat DeepSeek heeft stopgezet; de API-naam is deepseek-flash. Het goedkoopste model dat we onbeheerd in productie zouden draaien is Gemini 3.8 Flash ($0.75 / $3.75) of GPT-5.4 mini ($0.75 / $4.50) voor ongeveer $0.14 per uitvoering. Het goedkoopste vlaggenschipmodel is Claude Sonnet 5 ($2 / $10) voor $0.37. Prijzen zijn USD per 1M tokens uit onze catalogus per 2026-09-11; Claude Haiku 5.5 gecontroleerd op 2026-11-03 op de prijspagina van Anthropic. DeepSeek-prijzen gecontroleerd op 2026-10-27 op api-docs.deepseek.com; buiten de piekuren is de helft van het piektarief (piek is 01:00 tot 04:00 en 06:00 tot 10:00 UTC op weekdagen).

De referentie-uitvoering: een systeemprompt van 4,000 tokens plus tool-definities die bij elke stap worden verzonden, een toolresultaat van 1,500 tokens dat na elke stap wordt toegevoegd, 300 uitvoertokens per stap, 12 stappen. Omdat elke stap de volledige geschiedenis opnieuw verzendt, is de context bij stap k 4,000 + (k - 1) × 1,800 tokens, en de uitvoeringstotalen:

• Input tokens = 12 × 4,000 + 1,800 × 12 × 11 ÷ 2 = 48,000 + 118,800 = 166,800
• Output tokens = 12 × 300 = 3,600
• Run cost = 166,800 × (input rate ÷ 1,000,000) + 3,600 × (output rate ÷ 1,000,000)

Voor Claude Sonnet 5: $0.3336 + $0.036 = $0.3696. Invoer is 90% of meer van de uitvoering bij elk model, dus de rangschikking volgt de invoerprijs. De algemene formule voor N stappen staat in hoeveel kost het om een AI-agent te laten draaien.

Er zijn geen cache- of batchkortingen toegepast. Vermenigvuldig de laatste kolom met 1,000 voor een maandbudget bij 1,000 uitvoeringen. Claude Haiku 5.5 (uitgebracht op 7 oktober 2026) vervangt de legacy Claude Haiku 4.5, die nog steeds $1 / $5 kost, of $0.1848 per uitvoering, tien keer zoveel.

De spreiding van rang 1 tot rang 29 is 83×. Prompt-caching verkleint het zonder de volgorde te wijzigen: met cache-lezingen op ongeveer 10% van de lijst bij Anthropic en OpenAI en ongeveer 25% bij Gemini, daalt Sonnet 5 tot ongeveer $0.12 en Gemini 3.8 Flash tot ongeveer $0.06 per uitvoering. Live rijen staan op de modellenpagina.

Prijs is de makkelijke helft. Een agentmodel moet een tool-aanroep doen die overeenkomt met het schema, de juiste tool kiezen, stoppen wanneer klaar, en niet in een lus blijven hangen. De onderstaande niveaus zijn onze redactionele inschatting van hoeveel ondersteuning elk model nodig heeft in een productielus, geen benchmark; voer je eigen evaluatie uit op je eigen schema's voordat je je vastlegt.

• Tier A, onbeheerd draaien met normale validatie: Claude Opus 5, GPT-5.5, GPT-5.4, Gemini 3.1 Pro, Claude Sonnet 5. Consistente schema-naleving, goed stopgedrag, minste verspilde stappen.
• Tier B, onbeheerd draaien met strikte schema's: Claude Haiku 4.5 (nu legacy), GPT-5.4 mini, Gemini 3.8 Flash, GPT-5.3-Codex en Devstral 2 (coderingslussen), DeepSeek V4 Pro, Kimi K2.6, Qwen 3.8 Max, Grok 4.6, Mistral Large 3.
• Tier C, draaien met validatie, herpogingen en een escalatiepad: GPT-5.4 nano, Gemini 3.5 Flash Lite, DeepSeek V4.1 Flash, GLM 4.7, MiniMax M2.7, Qwen3 Coder 480B, Llama 4 Maverick, Codestral 2508, Mistral Medium 3.1. Verwacht misvormde argumenten, verkeerde toolkeuzes bij grote tool-sets en explosies van het aantal stappen bij open taken.
• Tier D, niet als planner: Llama 4 Scout, GLM 4.7 Flash, GPT-4.1 mini (vorige generatie). Geschikt voor eenmalige classificatie in een lus die door iemand anders wordt aangestuurd.

Het goedkoopste model dat dit nog betrouwbaar doet is Gemini 3.8 Flash of GPT-5.4 mini voor ongeveer $0.14 per uitvoering. Bij Anthropic is Claude Haiku 5.5 voor $0.0185 nu een tiende van de legacy Haiku 4.5's $0.185; totdat het een niveau heeft verdiend, gebruik je het als eerste poging achter een validator. Onder $0.10 per uitvoering koop je een model dat een supervisor nodig heeft, en de kosten van de supervisor horen bij je getal per taak.

De winnaar qua kosten per taak is bijna nooit een enkel model. Het is een Niveau C- of B-model als eerste poging, een validator die de tool-aanroep en het eindresultaat controleert, en een Niveau A-model dat alleen overneemt wanneer de goedkope poging faalt. Eén OpenAI-compatibele client via OpenRouter maakt de ladder een lijst van modelnamen (zie onze vergelijking tussen OpenRouter en directe API voor de routingmarge).

from openai import OpenAI
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=KEY)

LADDER = [  # (model, $ in per 1M, $ out per 1M)
    ("deepseek/deepseek-v4.1-flash", 0.30, 1.20),   # peak rate
    ("google/gemini-3.8-flash", 0.75, 3.75),
    ("anthropic/claude-sonnet-5", 2.0, 10.0),
]

def run_task(task, max_steps=12, budget_usd=0.60):
    spent = 0.0
    for model, p_in, p_out in LADDER:
        history = [{"role": "user", "content": task}]
        for _ in range(max_steps):
            r = client.chat.completions.create(model=model, messages=history,
                                               tools=TOOLS, max_tokens=2000)
            u = r.usage
            spent += (u.prompt_tokens * p_in + u.completion_tokens * p_out) / 1e6
            if spent > budget_usd:
                return None, spent                # hard cap: give up
            ok, done = apply_tool_calls(r, history)   # validate + execute
            if not ok:
                break                             # schema/tool failure: escalate
            if done and validate_result(history):
                return history[-1], spent         # success on this rung
    return None, spent

validate_result moet een goedkope deterministische controle zijn dat de taak daadwerkelijk is voltooid (tests slagen, het record bestaat, de JSON komt overeen), en spent wordt gedeeld over elke trede. Zonder een validator wast de ladder alleen maar fouten omhoog.

Kosten per succesvolle taak = kosten per run ÷ slagingspercentage, plus de escalatie- of herhalingskosten wanneer de run mislukt. Een uitgewerkt voorbeeld met illustratieve slagingspercentages (vervang ze door je eigen evaluatiecijfers):

Routing verslaat Sonnet 5 alleen op API-uitgaven. Tegen DeepSeek's piektarieven is de Gemini 3.8 Flash-ladder de goedkoopste van de twee. Drie dingen brengen het vlaggenschip terug naar de leiding. Miskosten: als een mislukte run een persoon nodig heeft om het op te merken en opnieuw uit te voeren, kost een foutpercentage van 55% bij de eerste poging meer in minuten dan de routing in dollars bespaarde. Stapeltelling: een goedkoop model dat 30 stappen nodig heeft ($0.293 op Gemini 3.5 Flash Lite) om te doen wat Sonnet 5 in 12 doet ($0.37) heeft zijn voordeel tenietgedaan. Bijwerkingen: wanneer een verkeerde toolaanroep een e-mail stuurt of naar productie schrijft, kan de validator dit niet ongedaan maken.

Wanneer betalen voor het vlaggenschip: als planner in een multi-agent systeem, bij elke stap met onomkeerbare bijwerkingen, en wanneer een mislukte run meer dan ongeveer $0.50 aan iemands tijd kost. Wanneer niet: bij de routinematige meerderheid van stappen, waar Tier B voor $0.14 met strikte schema's de juiste standaard is.

Elke agent-lus heeft vier limieten nodig, ongeacht het model:

• max_tokens per aanroep van 1.000 tot 4.000 voor tool-aanroepende beurten.
• Een harde stapbeperking van 12 tot 15 voor de meeste taaktypen, in je lus of via de turn limit van de SDK.
• Stopvoorwaarden: een vereiste 'finish'-tool, een afbreken bij herhaalde identieke tool-aanroepen, en een afbreken bij twee opeenvolgende toolfouten.
• Een per-run USD-budget berekend uit het usage-object na elke aanroep, gedeeld over escalatieniveaus zoals in het bovenstaande fragment.

Realistische per-run grenzen: ongeveer $0.10 voor een Tier C-lus, $0.30 voor Tier B, $1.00 voor Tier A, en $2.00 voor een run die helemaal mag escaleren. De AI-kostencalculator zet een maandelijks aantal runs om in een budgetlijn, en de handleidingen voor Claude agent API-kosten, OpenAI Agents SDK-kosten en Gemini agent API-kosten behandelen leveranciersspecifieke limieten en caching-syntax.

Rijen gelanceerd of herprijsd in september, berekeningen gebaseerd op dezelfde referentieloop (166.800 input, 3.600 output tokens), OpenRouter-sates gecontroleerd op 1 oktober 2026, geen caching of batch.

GPT-6 Luna kost $0.0185, ongeveer de helft van GPT-5.4 nano's $0.038 op dezelfde loop. Claude Opus 5.5 kost $0.74 en is goedkoper dan Claude Opus 5 ($0.92) of GPT-5.5 ($0.94) en staat op plek #1 in OpenRouter's Intelligence Index, waardoor het beide vervangt als de vlaggenschip-escalatietrap qua prijs. DeepSeek V4.1 Flash factureert op basis van tijdstip ($0.30 / $1.20 piek, $0.15 / $0.60 daluren op de eigen prijspagina van DeepSeek), dus plan niet-bewakerde loops in daluren. Mercury 2.5 (80% korting) en Gemini 3.8 Flash (50% korting) hebben een promotieprijs die kan eindigen.

We hebben de nieuwe lichtgewicht rijen (Mercury 2.5, GPT-6 Luna, DeepSeek V4.1 Flash en Claude Haiku 5.5 uit oktober tegen dezelfde $0.0185 als GPT-6 Luna) nog niet in de betrouwbaarheidstiers hierboven geplaatst. Voer ze eerst uit als Tier C-proefloop achter een validator, totdat je eigen evaluatie op je eigen toolschemas anders aangeeft.

OpenRouter's Batch API (POST https://openrouter.ai/api/v1/batches, live sinds september) factureert de meeste modellen tegen ongeveer 50% van de per-token prijs en levert resultaten binnen 24 uur. Het accepteert chat completions, Responses, Anthropic Messages en embeddings.

Het is niet geschikt voor de agent-lus zelf: elke stap hangt af van het vorige toolresultaat, en elke rondreis kan tot een dag duren. Het is geschikt voor het werk rondom de lus, waarbij elk item één verzoek is: nachtelijke evaluaties van de dagelijkse runs, beoordelen van transcripten, samenvatten van tooluitvoer, bulkclassificatie en backfills.

Batchtarieven per 1M: GPT-6 Luna $0.05 / $0.25, Gemini 3.8 Flash $0.375 / $1.875, GPT-6.1 Sol $1 / $5, Claude Opus 5.5 $2 / $10, GPT-6 Astra en Claude Fable 5.1 $5 / $25.

Rekenvoorbeeld: nachtelijk beoordelen van 1.000 voltooide runs met elk 1.000 input- en 200 outputtokens is 1M input plus 200K output. Dat kost $4.00 interactief of $2.00 in batch op GPT-6.1 Sol, $8.00 of $4.00 op Claude Opus 5.5, en $20 of $10 op GPT-6 Astra.

Beperkingen: één model en één endpointvorm per batch, alleen tekst, en elke batch draait op één provider (standaard het goedkoopste batch-endpoint dat je provider-allowlist, databeleid en BYOK-instellingen toestaan). xAI-modellen krijgen 20% korting in batch in plaats van de helft. Webzoekopdrachten en promptcaching worden tegen de gebruikelijke tarieven gefactureerd, dus het gecachte deel van een prompt wordt niet nogmaals gehalveerd.

OpenRouter's gehoste shell-server tool (openrouter:shell, of openrouter:bash voor de Anthropic-toolvorm; in bèta) laat elk tool-aanroepend model commando's uitvoeren in een gehoste Linux-container. Sandbox-tijd kost $0.0001 per actieve seconde, gefactureerd in de request.

• 10 actieve minuten: 600 × $0.0001 = $0.06
• 1 actief uur: 3.600 × $0.0001 = $0.36

Op een GPT-6 Luna 12-staps run ($0.0185) kost tien minuten shell-tijd meer dan drie keer de tokens. Op Claude Opus 5.5 ($0.74) voegt het ongeveer 8% toe. Bij goedkope modellen kan de sandbox, niet het model, de grootste post zijn: tel actieve seconden in het per-run budget, begrens de uitvoeringstijd van commando's, en laat geen langlopende processen actief binnen een request. De Files API ondersteunt tot 10 GiB per workspace, en workspace-beheerders kunnen server-tools uitschakelen.

De duurste fout van een goedkoop model is een verkeerde tool-aanroep met bijwerkingen. TypeSafe's Jev (typesafe/jev-1.13) is een beslissingsmodel op OpenRouter dat getypeerde vragen beantwoordt over een aanstaande tool-aanroep in plaats van tekst te schrijven: noul (ja/nee), choice (kies één optie) of score (een getal in een bereik), met waarschijnlijkheden en een betrouwbaarheidswaarde bij choice en score. Het kost $0.042 per 1M inputtokens met gratis output, en elke OpenRouter-sleutel werkt. OpenRouter publiceert kookboeken voor het reguleren van agent tool-aanroepen met Jev en voor het automatisch goedkeuren van toestemmingsprompts van codeeragenten (Claude Code, Codex, Cursor, OpenCode) met een controle op omkeerbaarheid.

Het patroon: voordat je elke tool-aanroep uitvoert, stuur je de aanstaande aanroep plus de minimale toestand die de vraag nodig heeft, en stel je bijvoorbeeld een noul-vraag "Is deze aanroep omkeerbaar?" en een score-vraag voor hoe goed het overeenkomt met het verzoek van de gebruiker. Voer automatisch uit bij een ja met een hoge score; escaliseer anders naar het vlaggenschipniveau of een persoon.

Kosten op de referentierun, uitgaande van 500 tokens toestand per controle en één controle per stap: 12 × 500 = 6.000 inputtokens × $0.042 per 1M = $0.00025 per run, ongeveer 1.4% van een GPT-6 Luna-run. Latentie is de grotere kostenpost: bij een mediaan van ongeveer 0.24 seconden voegen 12 opeenvolgende controles ongeveer 3 seconden per run toe.

Jev leest instructies letterlijk, dus houd rekenkunde, budgetvergelijkingen en datumscontroles in je eigen code. Het geeft geen uitleg, dus log zelf de aanstaande aanroep en Jev's getypeerde antwoord.

Goedkoopste model buiten Tier D dat überhaupt een agent uitvoert: Claude Haiku 5.5 of GPT-6 Luna voor $0.0185 per 12-step run, achter een validator; DeepSeek V4.1 Flash is $0.027 in daluren en $0.054 tijdens piekuren. Goedkoopste die wij onbemand zouden draaien met strikte schemas: Gemini 3.8 Flash of GPT-5.4 mini voor ongeveer $0.14. Bij Anthropic: probeer eerst Haiku 5.5 achter een validator voordat je tien keer zo veel betaalt voor het verouderde Haiku 4.5. Wie moet er vlaggenschapstarieven per stap betalen: teams waarvan tool calls neveneffecten hebben of waarvan fouten echte tijd kosten. Wie niet: iedereen met een validator en een routinematige taakmix. Goedkoopste manier om het resultaat te krijgen: eerst caching, standaard Tier B, een Tier C-proefloop achter een validator, en een gedeeld budget per run.