AI-agenten draaien zonder verrassingen op de rekening: tokenkosten in toom houden

AI-agenten zijn verleidelijk eenvoudig om aan te zetten: je geeft ze een doel, ze roepen zelf tools aan, lezen documenten en werken stap voor stap een taak af. Tot de rekening binnenkomt. Een agent die in een lus draait, stuurt bij elke beurt zijn volledige context opnieuw mee, en daarmee lopen de tokenkosten van AI-agenten harder op dan de meeste teams verwachten. Een proof of concept dat een paar euro per dag kostte, blijkt in productie ineens honderden euro's per week te verstoken.

Deze gids is voor ondernemers en teams die AI niet meer alleen uitproberen, maar echt in productie draaien: van een MKB-bedrijf met één klantenservice-assistent tot een afdeling van een grotere organisatie met tientallen agents. Je hoeft geen machine learning-engineer te zijn. Wat je nodig hebt is een vaste werkwijze om te zien waar je geld heen gaat, en de juiste knoppen om het terug te draaien zonder je AI dommer te maken.

Wat je nodig hebt

• Toegang tot je provider-dashboard. De Anthropic Console, het OpenAI-platform of het dashboard van welke aanbieder je ook gebruikt. Hier zet je facturatielimieten en zie je je verbruik per dag en per model.
• Een observability- of logging-laag. Een tool die per aanroep bijhoudt hoeveel tokens (en dus euro's) je verstookt, en die je kunt uitsplitsen per feature of gebruiker. Open source-opties als Langfuse en Helicone werken goed; in een notendop volstaat zelfs een eigen logregel per request.
• Optioneel: een AI-gateway. Een proxy als LiteLLM waar je al je AI-verkeer doorheen stuurt. Hiermee zet je harde budgetlimieten af die geen enkele provider-dashboard je geeft.
• Een uur tijd om je huidige verbruik te bekijken voordat je iets verandert. Zonder nulmeting weet je straks niet wat je hebt bespaard.

In zes stappen je AI-rekening onder controle

Tokenkosten beheers je in een vaste volgorde: meet eerst waar je geld precies heen gaat, zet daarna harde budgetlimieten zodat een ontspoorde agent je niet kan ruïneren, en verlaag pas dan de kosten per aanroep met caching, slimme model-routering en context-hygiëne. Geen giswerk, geen verrassingen op je factuur.

Werk de stappen in deze volgorde af:

Stap 1: Meet waar je tokens heen gaan

Begin nooit met besparen voordat je weet waar de kosten zitten. Open eerst je provider-dashboard en bekijk het verbruik per model en per dag. Bijna altijd blijkt een handvol agents of features verantwoordelijk voor het leeuwendeel van de rekening.

Zet daarna een observability-laag op die elke aanroep logt met het aantal input- en output-tokens. Een tool als Langfuse haalt het exacte verbruik uit het antwoord van de provider, of leidt de kosten af uit de modelprijzen, en kan dat vervolgens uitsplitsen per gebruiker, feature of tag. Pas als je per feature ziet wat hij kost, kun je gericht ingrijpen in plaats van overal tegelijk te knijpen.

Let specifiek op drie dingen: hoe lang je gemiddelde prompt is (input-tokens), hoeveel de agent terugschrijft (output-tokens, die twee tot vijf keer duurder zijn dan input), en hoe vaak een agent een taak in meerdere beurten herhaalt.

Stap 2: Zet harde budgetlimieten

Een meting voorkomt nog niets. De volgende stap is een plafond dat de kosten daadwerkelijk afkapt.

Op provider-niveau stel je in het dashboard een maandelijkse uitgavenlimiet in, plus een e-mailwaarschuwing bij bijvoorbeeld 50% en 80% van dat bedrag. Dat is je vangnet, maar het werkt grof: het geldt voor je hele account en grijpt pas in als de maand al grotendeels op is.

Voor echte controle stuur je je verkeer door een gateway als LiteLLM en geef je elke agent, elk team of elke klant een eigen virtuele sleutel met een eigen budget. Je maakt een sleutel aan met een veld als max_budget (in dollars) en een budget_duration zoals 30d of 24h. Je kunt zelfs meerdere vensters stapelen, bijvoorbeeld 10 dollar per dag én 100 dollar per maand. Zodra een sleutel zijn limiet overschrijdt, blokkeert LiteLLM de aanroep met een budget-exceeded-fout in plaats van stilletjes door te factureren. Met tpm_limit en rpm_limit begrens je daarnaast het aantal tokens en aanroepen per minuut, zodat een vastgelopen agent niet in een paar minuten je hele dagbudget opmaakt.

Het opzetten van zo'n leverancier-onafhankelijke gateway heeft een tweede voordeel: al je kosten lopen door één punt, dus je meting uit stap 1 en je limieten uit stap 2 zitten op dezelfde plek.

Stap 3: Zet prompt caching aan

Veel agents sturen bij elke aanroep dezelfde grote systeemprompt, dezelfde instructies en hetzelfde document opnieuw mee. Daar betaal je telkens de volle prijs voor, terwijl er niets aan verandert.

Prompt caching lost dat op. Je markeert het stabiele, herhaalde deel van je prompt, en de provider bewaart het tijdelijk. Een herschrijving naar de cache kost bij Anthropic eenmalig 1,25 keer de normale inputprijs (voor een venster van vijf minuten), maar elke volgende keer dat de cache wordt gelezen, betaal je nog maar 10% van de inputprijs, een korting van 90%. Vanaf de tweede aanroep verdien je de investering dus al terug.

De volgorde is cruciaal: zet alles wat vast staat (systeemprompt, instructies, vaste documenten) vooraan, en alles wat per aanroep verschilt (de vraag van de gebruiker, een tijdstempel) achteraan. Eén byte verschil ergens vooraan, zoals een ingebakken datum, en de hele cache erna vervalt. Controleer in je logs of je daadwerkelijk cache-treffers krijgt; staan die op nul, dan zit er een wisselend element in je vaste deel.

Stap 4: Routeer op taakcomplexiteit

De duurste fout is je zwaarste model voor alles gebruiken. Niet elke taak heeft het meest capabele (en duurste) model nodig. Een vraag classificeren of een label toekennen kan prima met een klein, snel model; complex redeneren over code vraagt het grote.

De prijsverschillen zijn fors. Voor Claude bijvoorbeeld:

Routeer je taken naar het lichtste model dat de klus aankan:

Een agent die honderd inkomende e-mails per dag classificeert, draait op het kleine model voor een fractie van de prijs van het grote. Pas een afgebakende taak als mail automatisch labelen en routeren is precies het soort werk dat naar het goedkope model mag. Wil je een gevoel voor de echte verschillen, kijk dan eens naar wat AI per miljoen tokens kost bij cloud-API versus open-weight.

Stap 5: Snoei in je context en gebruik batches

Hoe meer je meestuurt, hoe meer je betaalt. Twee snelle winsten:

Snoei de context. Stuur niet de hele gesprekshistorie of het complete document mee als de agent maar een deel nodig heeft. Vat oudere beurten samen, of haal met een zoekstap alleen de relevante passages op. Bij lange, lopende agents loont een vaste context-opschoning: gooi verouderde tool-resultaten weg voordat ze elke beurt opnieuw meereizen.

Gebruik de Batch-API voor uitgesteld werk. Taken die niet binnen seconden klaar hoeven (een nachtelijke verwerking, een bulk-classificatie, een set rapporten) verwerk je asynchroon met 50% korting op zowel input als output. Dat is gratis geld voor alles wat geen realtime-antwoord nodig heeft.

Stap 6: Zet alerts en herhaal

Kostenbeheersing is geen eenmalig project. Zet een wekelijkse of dagelijkse waarschuwing die afgaat als het verbruik boven een drempel komt, en plan elke maand een kort moment om je dashboard uit stap 1 opnieuw te bekijken. Nieuwe agents, een groeiend gebruik of een aangepaste prompt kunnen de verhoudingen zomaar omgooien. Je hebt nu het meetpunt en de knoppen; het kost je een kwartier per maand om bij te sturen.

Valkuilen

• Te vroeg optimaliseren. Caching en routering bouwen voordat je hebt gemeten, is gokken. Eerst meten, dan snijden.
• Cache die stilletjes mist. Een ingebakken datetime.now() of een wisselend ID vooraan in je prompt breekt elke cache-treffer zonder foutmelding. Controleer je cache-leesstatistieken.
• Het grote model als luie standaard. Het is verleidelijk om alles naar je beste model te sturen "voor de zekerheid". Dat is meestal de grootste verborgen kostenpost.
• Alleen op het provider-dashboard leunen. Dat plafond geldt voor je hele account en grijpt te laat in. Per-agent-budgetten in een gateway vangen een ontspoorde agent op het moment zelf.
• Goedkoper model verwarren met goedkoper resultaat. Een goedkoper model dat de taak niet aankan en drie keer opnieuw moet proberen, is duurder dan het dure model in één keer. Test de kwaliteit, niet alleen de prijs per token. Dat geldt ook als bedrijven voor goedkopere inferentie uitwijken naar open source en Chinese modellen: goedkoop per token is pas een besparing als de uitkomst klopt.

Kant-en-klaar vs. maatwerk

De vraag is niet óf je kosten beheerst, maar hoe ver je het automatiseert.

Kant-en-klaar is het provider-dashboard met een maandlimiet en wat alerts. Je bent in tien minuten klaar en het kost niets extra. Voor een klein team met één of twee agents is dit vaak genoeg: je hebt een vangnet en je ziet je verbruik. De grens is dat je geen onderscheid kunt maken tussen agents, geen harde realtime-stop hebt, en bij een fout pas achteraf ingrijpt.

Maatwerk is een eigen gateway met per-agent-budgetten, caching-regels, model-routering en een observability-laag die per feature uitsplitst. Het kost opzetwerk en onderhoud, maar je krijgt er precieze controle voor terug: elke agent een eigen plafond, automatische routering naar het goedkoopste passende model, en kosten die je per klant of project kunt doorbelasten.

De praktische middenweg voor de meeste groeiende teams: begin met het dashboard-vangnet vandaag, en bouw de gateway zodra je een tweede of derde agent in productie zet en de rekening serieus begint te tellen. Welke AI-agents nú al echt werken voor het MKB bepaalt vanzelf wanneer dat moment komt.

Kostenbeheersing bij AI is uiteindelijk geen boekhoudkwestie maar een ontwerpkwestie. Een agent die je niet kunt meten, kun je niet sturen; een agent zonder budget is een open kraan. De teams die hier rustig over zijn, zijn niet degenen met het kleinste model of de scherpste onderhandelde prijs, maar degenen die hun verbruik kennen, hun limieten hard hebben gezet en elke aanroep naar het lichtste model sturen dat de klus klaart. Doe dat, en AI wordt een voorspelbare regel op je begroting in plaats van een verrassing aan het eind van de maand.