LLM-kostenbeheersing voor Agents: 5 richtlijnen om uitgaven te beperken

Een gezonde 12-staps agent-run op Claude Sonnet 5 kost ongeveer $0,39. Dezelfde agent die vastzit in een 200-staps lus kost ongeveer $74, omdat de context elke stap met 1.800 tokens groeit en elke stap alles opnieuw verzendt: in totaal 36,7 miljoen invoertokens. Op Claude Opus 5 of GPT-5.5 kost dezelfde lus ongeveer $185. Vijf beveiligingen stoppen dit: max_tokens per aanroep, een stap limiet per run, een expliciete stopconditie, een per-run dollar budget berekend uit de usage-velden van elke respons, en een dagelijkse limiet in de vendor console.

De eerste drie zijn elk één regel. De vierde is de 30-regelige runner hieronder. De vijfde is een console-instelling. Voer ze alle vijf uit, omdat elke beveiliging een fout opvangt die de anderen missen.

Agenten falen meestal niet door één enorme respons te produceren. Ze falen door steeds een kleine, ogenschijnlijk redelijke stap te herhalen. De faalmodi die we het vaakst zien:

• Een tool die een foutmelding retourneert die het model behandelt als een prompt om het opnieuw te proberen, met dezelfde argumenten, voor altijd
• Een 'controleer je werk'-instructie die het model uitvoert door de hele taak opnieuw uit te voeren
• Een zoektool die elke aanroep iets andere resultaten geeft, waardoor het model nooit het gevoel heeft klaar te zijn
• Twee agenten die een taak heen en weer geven, waarbij elk denkt dat de ander verantwoordelijk is voor de afronding
• Een stop_reason van max_tokens die de luscode behandelt als 'opnieuw aanroepen' in plaats van 'er is iets mis'

Geen van deze ziet er duur uit bij stap 5. Ze worden duur bij stap 80, wanneer de context 147.000 tokens is en elke stap meer kost dan de eerste twintig samen. De mechanica van die groei staat in [hoeveel kost het om een AI-agent te laten draaien](/guides/how-much-does-an-ai-agent-cost-to-run).

Referentie-trace: 4.000-token prefix, 500-token taak, elke stap voegt een 300-token toolcall en een 1.500-token resultaat toe. Input bij stap k is 4.500 + 1.800 × (k − 1). Opgeteld over 200 stappen: 200 × 4.500 + 1.800 × 19.900 = 36.720.000 invoertokens. Output is 200 × 300 = 60.000 tokens. Context bij stap 200 bedraagt 362.700 tokens, wat past in een 1M-window; een 200K-model zoals het legacy Claude Haiku 4.5 zou rond stap 109 een fout geven, wat een onbedoelde limiet is, geen plan.

Zeventien keer zoveel stappen, ruwweg 190 keer de kosten. Met prompt caching (cache-leesbewerkingen liggen rond 10% van het standaardtarief, schrijfbewerkingen rond 125% bij Anthropic) wordt de Sonnet 5-lus 362.700 × $2.50 + 36.357.300 × $0.20 + $0.60 = ongeveer $8.78. Caching is zeker de moeite waard, zoals [prompt caching for AI agents](/guides/prompt-caching-for-ai-agents) aantoont, maar 22 keer een gezonde run blijft een rekening die je opmerkt. DeepSeek V4.1 Flash, API-naam deepseek-flash, verving V4 Flash, dat door DeepSeek is gepensioneerd. DeepSeek-rijen gebruiken piektarieven; buiten piekuren kost het de helft. DeepSeek-prijzen gecontroleerd op 2026-10-27 via api-docs.deepseek.com.

1. max_tokens per aanroep. Stem het af op de stap, niet op het plafond van het model. Een toolaanroepende stap heeft 512 tot 2.048 tokens nodig; een eindrapport heeft misschien 4.000 nodig. Een enkele ontsnapte 32.000-token respons op Opus 5 is 32.000 × $25 = $0,80 op zichzelf, en het blijft dan in de context voor elke volgende stap.

2. Maximum aantal stappen per run. Kies een getal uit je traces: de p95 van succesvolle runs plus een marge. Voor de meeste tool-lussen is dat 15 tot 30. Een run die de limiet bereikt, moet luid falen, niet stilletjes teruggeven wat het had.

3. Een expliciete stopconditie. Geef het model een finish of report tool en beëindig de lus wanneer deze wordt aangeroepen of wanneer stop_reason end_turn is. Detecteer ook degeneratieve voortgang: dezelfde tool met dezelfde argumenten twee keer achter elkaar aangeroepen is een lus, en de run moet worden afgebroken.

4. Een per-run USD budget op basis van usage. Elke respons rapporteert invoer, gecachte en uitvoer tokens. Vermenigvuldig met de tarieven van het model, accumuleer, en breek af wanneer het totaal de limiet overschrijdt. Dit is de enige beveiliging waarvan de drempel in de eenheid is waar je echt om geeft.

5. Een dagelijkse accountlimiet in de vendor console. Anthropic en OpenAI laten je uitgavenlimieten instellen per workspace of project met meldingen; Google Cloud-budgetten waarschuwen en kunnen worden aangesloten om uitgaven te stoppen. Dit is de vangnet voor de bug waar je nog niet aan hebt gedacht.

SDK-clients proberen standaard snelheidslimieten en serverfouten opnieuw, meestal twee of drie pogingen met exponentiële backoff. Een afgewezen verzoek wordt over het algemeen niet in rekening gebracht, maar een verzoek dat na generatie een time-out heeft, wordt vaak wel in rekening gebracht, en een herhaling op applicatieniveau van een stap stuurt de hele context opnieuw.

Bij stap 100 van de referentielus is de context 4.500 + 99 × 1.800 = 182.700 tokens. Eén poging op Sonnet 5 ongecached is 182.700 × $2 = $0,37; drie pogingen zijn $1,10 voor nul vooruitgang. Gecached is elke poging ongeveer $0,04. Twee regels volgen: behoud het aantal herhalingen van de SDK, wikkel het nooit in je eigen herhalingslus, en als je een mislukte run opnieuw moet starten, reken het dan af tegen hetzelfde per-run budget in plaats van een nieuwe te beginnen.

Deze Python-runner stuurt een Claude-tool-loop en stopt wanneer de dollarlimiet of de stap-limiet wordt bereikt. Dezelfde opzet werkt op OpenAI met responses.create en usage.input_tokens_details.cached_tokens.

from anthropic import Anthropic

PRICES = {"claude-sonnet-5": (2.0, 2.5, 0.2, 10.0)}  # $/1M: input, cache write, cache read, output

class BudgetedRunner:
    def __init__(self, model, system, tools, budget_usd, max_steps=25):
        self.client, self.model, self.system, self.tools = Anthropic(), model, system, tools
        self.budget, self.max_steps, self.spent = budget_usd, max_steps, 0.0

    def cost(self, u):
        i, w, r, o = PRICES[self.model]
        return (u.input_tokens * i + (u.cache_creation_input_tokens or 0) * w
                + (u.cache_read_input_tokens or 0) * r + u.output_tokens * o) / 1e6

    def run(self, messages, execute_tool):
        for step in range(1, self.max_steps + 1):
            resp = self.client.messages.create(model=self.model, max_tokens=1024,
                system=self.system, tools=self.tools, messages=messages)
            self.spent += self.cost(resp.usage)   # e.g. 24,300 in × $2 + 300 out × $10 = $0.052
            if self.spent > self.budget:
                raise RuntimeError(f"budget ${self.budget} exceeded at step {step}: ${self.spent:.3f}")
            messages.append({"role": "assistant", "content": resp.content})
            if resp.stop_reason != "tool_use":
                return resp, self.spent
            results = [{"type": "tool_result", "tool_use_id": b.id,
                        "content": execute_tool(b.name, b.input)}
                       for b in resp.content if b.type == "tool_use"]
            messages.append({"role": "user", "content": results})
        raise RuntimeError(f"step cap {self.max_steps} hit after ${self.spent:.3f}")

Stel budget_usd in op basis van je traces: drie keer de mediane succesvolle run is een redelijk begin. Voor de Sonnet 5-referentierun is dat ongeveer $1,20, die de 200-stappen-loop bij stap 24 zou bereiken, ongeveer $73 voordat de console het zou opmerken.

Een budget stopt één run. Waarschuwingen vertellen je dat runs het nodig zijn gaan hebben.

• Log de kosten per run, niet per aanroep, met het model, het stap-aantal en de stopreden
• Tag elke run met de functie of klant die deze heeft getriggerd, zodat een piek een eigenaar heeft
• Waarschuw op de p99-kosten per run en op het aandeel runs dat de stap-limiet of het budget heeft bereikt; beide samen stijgen duidt op een nieuwe faalmodus, niet een drukke dag
• Stem wekelijks af tegen het gebruiksrapport van de leverancier, omdat een runner-bug die tokens ondertelt zelf een wegloper is

Als je routeert via OpenRouter, geven per-sleutel kredietlimieten je een tweede, leverancier-onafhankelijke limiet; de afwegingen staan in [OpenRouter vs direct API](/compare/openrouter-vs-direct-api).

Beveiligingsmaatregelen begrenzen de schade; modelkeuze bepaalt de helling. Voor een goed gespecificeerde lus verandert DeepSeek V4.1 Flash ($0.30 / $1.20) de 200-staps ramp in een ergernis van $11 en Gemini 3.8 Flash ($0.75 / $3.75) in $28. Naar onze ervaring zijn beide betrouwbaar bij gestructureerde tool-aanroepen wanneer de taak duidelijk is, en het artikel over [Gemini agent API kosten](/guides/gemini-agent-api-cost) behandelt de Gemini-kant.

Betaal voor Claude Sonnet 5, GPT-5.4 of een vlaggenschip wanneer de taak dubbelzinnig is of de lus lang is, omdat dit de runs zijn waarbij een goedkoop model het meest waarschijnlijk afdwaalt en afdwalen is wat de bovenstaande tabel prijst. Wat je ook kiest, de bovenstaande runner werkt ongewijzigd; alleen de PRICES-rij verschilt. Prijs je eigen trace in de [calculator](/calculator) en raadpleeg [Claude agent API kosten](/guides/claude-agent-api-cost) voor de per-leverancier gebruikersvelden.