greenai.guide

Home › Artikelen › Agentische AI en verspilde tokens

Artikel

Agentische AI en verspilde tokens

Bijgewerkt · 5 min. leestijd

In het kort

AI-agents voeren taken uit in veel stappen en roepen keer op keer modellen en tools aan, dus één verzoek kan vele malen meer tokens gebruiken dan een chat. Multi-agentsystemen vermenigvuldigen dat, en als agents in lussen belanden of langs elkaar heen praten, worden de tokens verspild. Budgetten, stappenlimieten, lusdetectie en modellen van de juiste maat houden agents nuttig zonder voor niets energie te verstoken.

Kernpunten

  • Een agent doet per taak veel modelaanroepen, dus het tokengebruik, en daarmee het energieverbruik, kan vele malen hoger liggen dan bij één chat.
  • Multi-agentsystemen vermenigvuldigen het tokengebruik nog eens, wat alleen loont bij taken die waardevol en complex genoeg zijn om het nodig te hebben.
  • Agents kunnen vastlopen in lussen of werk herhalen, waarbij ze tokens verbruiken zonder vooruitgang te boeken.
  • Harde limieten op stappen, tokens, tijd en uitgaven, plus monitoring die een vastgelopen run kan stoppen, zijn elementaire vangrails.
  • De juiste maat kiezen betekent één agent, een klein model of helemaal geen agent gebruiken als de taak dat toelaat.

AI-agents zijn systemen die in meerdere stappen naar een doel toewerken en daarbij zelf kiezen welke tools ze aanroepen en wat ze daarna doen. Ze kunnen boeken, zoeken, code schrijven, die testen en het opnieuw proberen. Die autonomie is nuttig, maar elke stap is weer een aanroep van een model, en de kosten lopen op op een manier die bij één chat niet voorkomt.

Wat maakt agents duur?

Een agent roept per taak vele keren een model aan, en elke aanroep bevat meestal de groeiende geschiedenis van de taak tot dan toe. Het tokengebruik, en dus het energieverbruik, groeit met elke stap, elke toolaanroep en elke nieuwe poging.

Een token is een stukje tekst, ruwweg een deel van een woord, dat een model leest of schrijft. Elk verwerkt token kost rekenwerk. In een chat levert één vraag één antwoord op. Bij een agent kan één verzoek tientallen modelaanroepen in gang zetten: plannen, zoeken, resultaten lezen, schrijven, controleren en herzien.

Anthropic beschreef dit in 2025 in een verslag over de bouw van zijn multi-agentsysteem voor onderzoek. Het meldde dat agents doorgaans ongeveer vier keer meer tokens gebruikten dan chatinteracties, en multi-agentsystemen ongeveer vijftien keer meer. Het ontdekte ook dat op zijn browsebenchmark het tokengebruik op zichzelf 80% van de variantie in prestaties verklaarde: de systemen deden het vooral beter omdat ze meer verbruikten.

Voor een moeilijke, waardevolle taak is dat een redelijke ruil. Voor een eenvoudige taak is het verspilling.

Is er bewijs over het energieverbruik van agents?

Vroeg onderzoek wijst dezelfde kant op. Kim, Shin, Chung en Rhu (2025) vergeleken agentische workflows met meerdere beurten met inferentie in één beurt, vanuit het oogpunt van de infrastructuur van datacenters. Ze ontdekten dat agents aanzienlijk meer energie gebruikten, dat de winst in nauwkeurigheid afnam naarmate er meer rekenkracht werd ingezet, en dat de infrastructuurkosten van het op deze manier opschalen van agents onhoudbaar zouden kunnen worden.

Gemeten cijfers voor echte toepassingen zijn nog schaars, omdat aanbieders ze zelden publiceren. Zie meten is het knelpunt.

Hoe verspillen agents tokens?

Door werk te doen dat de taak niet verder brengt. Veelvoorkomende patronen zijn:

  • Lussen. Een agent herhaalt dezelfde actie, of twee agents spelen een probleem steeds naar elkaar terug.
  • Overcontrole. Elke stap wordt beoordeeld door een extra modelaanroep, ook waar een eenvoudige test zou volstaan.
  • Opgeblazen context. Hele documenten, logboeken of tooluitvoer worden door alle latere stappen meegesleept.
  • Stormen van nieuwe pogingen. Een fout leidt tot herhaalde nieuwe pogingen, soms op steeds grotere modellen.
  • Overdelegatie. Een taak wordt over veel agents verdeeld terwijl één agent volstaan had.

Cemri en collega's (2025) analyseerden meer dan 1.600 geannoteerde traces van zeven multi-agentframeworks en vonden 14 verschillende manieren waarop deze systemen falen, ingedeeld in drie categorieën: problemen met hoe het systeem en de taak zijn gespecificeerd, slechte afstemming tussen agents, en het niet verifiëren van de taak. Elke manier van falen is ook een manier om tokens uit te geven zonder resultaat.

Een Britse sandpit (een verkennende werksessie) over groene AI in 2026, met wiskundigen, informatici en de industrie, besprak hetzelfde probleem: zwermen agents kunnen zichzelf klemzetten, elkaar betekenisloze uitvoer sturen en honderdduizenden tokens verstoken. De open onderzoeksvraag die daar naar voren kwam, is hoe u wiskundig en vroegtijdig kunt vaststellen dat een groep agents vastzit, zodat iemand of iets die kan stoppen.

Is dit commercieel net zo belangrijk als voor het milieu?

Ja; kosten en energie stijgen samen. Gartner voorspelde in juni 2025 dat meer dan 40% van de projecten met agentische AI tegen eind 2027 wordt stopgezet, door oplopende kosten, onduidelijke bedrijfswaarde of ontoereikende risicobeheersing. Verspilde tokens dragen rechtstreeks bij aan de eerste van die oorzaken.

Welke vangrails houden agents in toom?

Harde limieten, monitoring en een manier om te stoppen. Dit zijn elementaire technische maatregelen, en de meeste agentframeworks ondersteunen er een aantal.

Vangrail Wat ze doet
Stappenlimiet Begrenst het aantal modelaanroepen in een run. De OpenAI Agents SDK heeft bijvoorbeeld een instelling max_turns die een run stopt als die wordt overschreden.
Budget voor tokens of uitgaven Stopt een run of schaalt hem op wanneer die een vastgestelde kostengrens passeert.
Tijdslimiet Beëindigt runs die veel langer duren dan verwacht.
Lusdetectie Signaleert herhaalde acties of bijna identieke berichten tussen agents.
Externe waarnemer Een apart, goedkoop proces of een mens die de voortgang volgt en de run kan stoppen: de "rode knop".
Context inkorten Vat oude geschiedenis samen of laat die vallen, zodat elke aanroep minder tokens leest.

Limieten moeten veilig falen: als een budget op is, moet de agent stoppen en melden wat hij heeft, niet stilletjes opnieuw proberen.

Wat betekent een agent van de juiste maat?

Het minst uitgebreide systeem gebruiken dat de klus klaart. Loop deze lijst van boven naar beneden af voordat u een multi-agentsysteem bouwt:

  1. Geen agent. Kan een vast script, een zoekopdracht of één modelaanroep het doen?
  2. Eén aanroep met tools. Eén goed geformuleerde modelaanroep die een tool kan gebruiken, is vaak genoeg.
  3. Eén agent. Eén agent met een stappenlimiet.
  4. Meerdere agents, alleen voor taken die breed, waardevol en echt parallel zijn.

Gebruik binnen elk van deze opties kleine modellen voor eenvoudige deeltaken zoals classificatie, extractie en opmaak, en bewaar grote modellen voor het moeilijke redeneerwerk. Er is wel een addertje: een model dat te klein is, kan falen en een nieuwe run op een groter model afdwingen, en in een lange keten kan één fout latere stappen doen ontsporen. De drempel bepalen is een ontwerpkeuze die het testen waard is. Zie het juiste model kiezen en orkestratie boven generatie.

Wat nu?

  • Log voor elke agent die u laat draaien het aantal tokens per voltooide taak, inclusief nieuwe pogingen en mislukte runs.
  • Stel voor elke agent limieten in voor stappen, tokens, tijd en uitgaven voordat hij in productie gaat.
  • Voeg lusdetectie toe en een manier waarop een mens een run kan stoppen.
  • Begin met het eenvoudigste ontwerp dat werkt, en voeg pas agents toe als de taak erom vraagt.
  • Stuur eenvoudige deeltaken naar kleine modellen. Zie AI efficiënt gebruiken.
  • Koopt u agentische tools, vraag leveranciers dan hoe ze het tokengebruik beperken en rapporteren: zie duurzame inkoop van AI.

Veelgestelde vragen

Wat is agentische AI?

AI-systemen die in meerdere stappen een doel nastreven en zelf beslissen welke tools ze aanroepen en wat ze daarna doen, in plaats van één prompt te beantwoorden. Ze roepen per taak vaak vele keren een taalmodel aan.

Waarom gebruiken AI-agents zoveel tokens?

Bij elke stap gaat de groeiende geschiedenis van de taak terug naar het model, en agents kunnen tools aanroepen, hun eigen werk controleren en het opnieuw proberen. Multi-agentsystemen sturen ook berichten tussen agents heen en weer, en elk bericht kost tokens.

Hoe voorkom ik dat een AI-agent tokens verspilt?

Stel limieten in voor het aantal stappen, tokens, tijd en uitgaven; detecteer lussen en herhaalde acties; gebruik kleine modellen voor eenvoudige deeltaken; en zorg dat een mens een run kan stoppen.

Bronnen

  1. How we built our multi-agent research system, Anthropic (2025)
  2. Why do multi-agent LLM systems fail?, Cemri et al. (2025)
  3. The cost of dynamic reasoning: demystifying AI agents and test-time scaling from an AI infrastructure perspective, Kim, Shin, Chung and Rhu, HPCA 2026 (2025)
  4. Gartner predicts over 40% of agentic AI projects will be canceled by end of 2027, Gartner (2025)
  5. Running agents (max_turns), OpenAI Agents SDK documentation (2025)

Doe mee

Help de impact van AI op de planeet te verkleinen

Ontvang ongeveer eens per maand nieuwe gidsen, financieringsoproepen en vermeldingen per e-mail. Of voeg uw product, cursus, promotieplaats of onderzoek toe aan de gidsen.

Geen tracking. Met één klik afmelden. Andere manieren om mee te doen · Privacy