Skip to content

De lange taak had geen ruimte meer

Een lange run van een AI-agent kan het contextvenster van het model overschrijden en halverwege stoppen. Zeven controles voor lange agentruns.

Een korte test bewijst dat een agent het werk kan doen. Hij bewijst niet dat de agent al het werk in één run kan doen.

Bij elke stap van een run stuurt de agent het model zijn instructies, de geschiedenis van de run tot dan toe, de beschrijvingen van zijn tools en elk resultaat dat die tools teruggaven. Het model kan per aanroep maar een vaste hoeveelheid tekst lezen. Die hoeveelheid is het contextvenster (context window), gemeten in tokens: kleine stukjes tekst. Een chat vult het venster bericht voor bericht. Een lange run kan het in een paar stappen vullen, omdat elk toolresultaat bij de geschiedenis komt die de volgende stap meestuurt (over de onderdelen van een agent leest u meer in Wat is een AI-agent?).

Twee meldingen van dit jaar laten zien wat er gebeurt als het werk groter wordt dan de ruimte.

Twee meldingen over lange runs

De stap die ruimte moest besparen, gebruikte de meeste. Een team meldde in augustus 2026 op de issuetracker van een agentframework dat een taak mislukte in hun taakplanner in productie, die een agent draaide op een clouddeployment. Het framework heeft een samenvattingsstap. Wordt de geschiedenis lang, dan vraagt het het model het oudere deel samen te vatten, zodat de run met minder ruimte verder kan. De melder las de code van het framework. De samenvattingsstap hoorde de geschiedenis eerst in te korten voordat hij die verstuurde, maar in de opzet die het framework bouwde, stond dat inkorten uit. Het verzoek om een samenvatting bevatte dus de hele geschiedenis, bijna twee keer zo groot als wat het model accepteert. Het model weigerde het met een foutmelding. In de versie die het team in productie draaide, ving niets die fout op, en de agent crashte.

Een andere gebruiker controleerde de code, onderschreef de analyse en bood een oplossing aan in een eigen kopie van het project. Drie weken later sloot een bijdrager aan het project (contributor) het issue als niet gepland. Volgens die bijdrager was de instelling bewust gekozen, en hoort de echte oplossing waarschijnlijk thuis in de manier waarop tokens worden geteld.

De foutmelding zei "intern". Een ontwikkelaar meldde in juni 2026 op het communityforum van een framework dat een gehoste agent, aangeroepen vanuit de eigen webapp, was gaan falen. Het had altijd gewerkt, en er was niets veranderd. De foutmelding noemde zichzelf een rate-limitfout en zei dat er een interne fout was opgetreden. De app gaf ook een serverfout terug, en de ontwikkelaar kon niet zien of de fout in de eigen code zat of op de server. Na drie dagen, en nadat de ontwikkelaar een trace van de run had gedeeld, vond een ervaren forumlid de oorzaak: de limiet van de modelprovider op het aantal tokens per minuut. Deze ene run vroeg een groot deel van die ruimte, en samen met eerdere aanroepen ging hij erover. Daarna kwam er geen reactie meer van de ontwikkelaar.

Dat is een andere limiet dan het contextvenster. Een contextvenster begrenst één aanroep. Een rate limit begrenst de tokens die een provider in een bepaalde periode accepteert, over alle aanroepen heen. Beide zijn limieten op omvang, en in beide meldingen was de omvang van het werk de oorzaak.

Wat de twee gemeen hebben

In beide gevallen liep de agent tegen een limiet aan waar korte tests nooit in de buurt kwamen. In beide vond het team de oorzaak pas door iets te lezen wat de foutmelding niet liet zien: de code van het framework in de eerste melding, de trace van de run in de tweede.

Elke run heeft een omvang waarbij hij stopt. De vraag is of u die vindt in een test of in productie.

Zeven controles voor lange agentruns

Deze controles gelden voor elk platform dat agents lange taken laat uitvoeren, ook het onze. Waar EpicStaff een antwoord heeft, staat dat onder de controle.

1. Weet wat er gebeurt bij de limiet

Past de volgende aanroep niet meer, dan kan een platform stoppen met een foutmelding, de oudere geschiedenis afknippen, of die vervangen door een samenvatting en doorgaan. Een foutmelding stopt het werk, maar iemand ziet het. Afknippen en samenvatten laten de run doorgaan, met minder van wat hij wist. Een samenvatting is ook een aanroep van het model, met een eigen limiet, zoals de eerste melding laat zien. Vraag wat uw platform doet, en wat er gebeurt als die stap ook faalt.

In EpicStaff: Wanneer de run van een agent groter wordt dan de limiet van het model, stopt die stap met een foutmelding.

2. Zoek uit of u de geschiedenis of de omvang van toolresultaten kunt begrenzen

Sommige platforms en frameworks laten een bouwer instellen hoeveel geschiedenis een stap meestuurt, of hoe lang een toolresultaat mag zijn voordat het wordt afgeknipt. Zoek uit of het uwe dat kan, waar die instelling zit en wat er gebeurt met het deel dat wegvalt. Is er geen zo'n instelling, dan moet de grens in de tools en in het ontwerp van de taak zitten.

3. Controleer of het runverslag de oorzaak noemt

Faalt een lange run, dan moet het verslag zeggen dat een limiet op omvang de oorzaak was, in woorden die de dienstdoende collega 's nachts kan lezen. "Interne fout" stuurt mensen naar de verkeerde plek. Start bewust een run waarvan u weet dat hij te groot is, en lees wat het verslag laat zien. Wat een runverslag verder moet bevatten, leest u in De AI agent is klaar. Niemand kan zeggen wat hij deed.

In EpicStaff: De run wordt als mislukt gemarkeerd en toont de foutmelding van de provider.

4. Weet hoe groot één toolresultaat kan zijn

De meeste toolresultaten gaan in hun geheel naar het model, dus één heel groot resultaat kan de context op zichzelf vullen. Een tool die een bestand, een webpagina of een databasetabel leest, geeft terug wat hij vindt. Vraag voor elke tool hoe groot het resultaat kan worden op uw grootste echte gegevens, en of de tool minder kan teruggeven: één pagina met rijen, een lijst met treffers of een uittreksel in plaats van het hele document.

5. Controleer of een lange taak in stappen kan worden opgedeeld

Eén run die tweehonderd documenten leest, neemt elk eerder resultaat mee naar de volgende stap. Tien kleinere runs, of een flow waarvan de stappen alleen een kort resultaat doorgeven, beginnen elk met een kleine geschiedenis. Zoek uit of en hoe uw platform een taak laat opdelen, en wat er van de ene stap naar de volgende gaat. Ontwerp de taak dan zo dat geen enkele stap de hele klus hoeft te dragen.

6. Bepaal wie het tokengebruik per run bijhoudt

Het tokengebruik per run laat zien dat een taak groeit, lang voordat hij een limiet bereikt. Het verklaart ook de kosten. Wijs iemand aan die het per agent elke week leest, met een grens waarbij die persoon ingrijpt. Een run die twee keer zoveel tokens gebruikt als vorige maand, verdient een blik, ook als hij niet faalde.

In EpicStaff: EpicStaff legt per stap vast hoeveel tokens die stap gebruikte, en het totaal voor de run. Een bouwer stelt per agent het maximale aantal iteraties, toolaanroepen en opeenvolgende mislukkingen in; de agent stopt zodra hij er één bereikt.

7. Test vóór de livegang met de grootste echte invoer

Korte testinvoer bewijst de logica, niet de omvang. Draai de agent vóór de livegang één keer op de grootste echte invoer die hij zal tegenkomen: het langste document, het grootste klantdossier, de wachtrij van de drukste dag. Lees hoeveel tokens elke stap gebruikte, en hoe dicht de grootste stap bij de limiet van het model kwam. Herhaal de test als u het model, de tools of de instructies wijzigt. Meer over hoe u AI-agentworkflows test.

Omvang hoort in het ontwerp

Een lange taak heeft een omvang, net zo zeker als hij stappen heeft. Die omvang valt makkelijk buiten het ontwerp, omdat korte tests zonder slagen. Beide teams hierboven kwamen de omvang van hun werk in productie tegen, en beide hadden code of een trace nodig om die te zien.

Zet de omvang op de ontwerppagina: de grootste invoer, de tokens per stap, de limiet van het model en wat er bij die limiet gebeurt. Dan is de eerste run op volle omvang een test die u hebt gepland, geen storing.

Vragen & Antwoorden

Wat is het verschil tussen een contextvenster en een rate limit op tokens?

Een contextvenster is de grootste hoeveelheid tekst die een model in één aanroep kan lezen. Een rate limit is het grootste aantal tokens dat een provider in een bepaalde periode, vaak een minuut, van uw account accepteert, over alle aanroepen heen. Een lange run kan de eerste raken met één grote aanroep, en de tweede met veel aanroepen kort na elkaar. Ook de oplossing verschilt: kleinere aanroepen voor de eerste, minder of tragere aanroepen voor de tweede.

Hoe deel ik een lange taak van een AI-agent op in kleinere stappen?

Zoek een natuurlijke eenheid van werk: één document, één klant, één ticket. Laat één stap één eenheid afhandelen en een kort resultaat teruggeven, zoals een samenvatting of een paar velden. Laat een laatste stap de korte resultaten samenvoegen. Elke stap begint dan met een kleine geschiedenis, en een fout stopt één eenheid, niet de hele klus.

Waarom faalde mijn AI-agent op een echte taak terwijl alle tests slaagden?

De meeste tests gebruiken korte invoer en komen dus nooit in de buurt van de limiet van het model. Een echte taak kan langere documenten lezen, grotere toolresultaten krijgen en meer stappen nemen, en elke stap voegt iets toe aan de geschiedenis die de volgende meestuurt. Draai de agent één keer op uw grootste echte invoer en vergelijk het tokengebruik met dat van uw tests.

Wat gebeurt er als de run van een EpicStaff-agent groter wordt dan het contextvenster van het model?

Wanneer de run van een agent groter wordt dan de limiet van het model, stopt die stap met een foutmelding. De run wordt als mislukt gemarkeerd en toont de foutmelding van de provider. EpicStaff legt per stap vast hoeveel tokens die stap gebruikte, en het totaal voor de run.

Keep reading