Je agents laten processen achter.
AgentsRoom vindt ze.
Een AI-coderingsagent start een echt systeemproces voor elke tool die hij aanroept. De meeste zijn binnen seconden klaar. Sommige nooit, en die houden gigabytes geheugen gegijzeld zonder ook maar één CPU-cyclus te gebruiken.
De procesbewaker loopt de kindprocessen van je agents na, markeert de processen die niet meer opschieten, noemt de verantwoordelijke agent, en beëindigt ze met één klik. Er wordt niets achter je rug om afgesloten.
Waar de bewaker echt naar kijkt: de processen die één agent startte, en welke daarvan gestopt zijn met werken.
Een AI-coderingsagent is niet één proces. Elke toolaanroep die hij doet start er een echte op je machine: een zoekopdracht, een build, een typecheck, een testrun, een script. Vermenigvuldig dat met een paar agents die parallel werken, over een hele dag, en je krijgt honderden processen die geboren en begraven worden zonder dat je er ooit één ziet.
Bijna allemaal lopen ze af. De processen die dat niet doen zijn het probleem. Een zoekopdracht met een patroon dat de regex-engine laat exploderen crasht niet en wordt niet traag: hij alloceert, wordt het gecomprimeerde geheugen in geduwd, en brengt de rest van zijn leven door met page faults op 4% CPU. Hij komt nooit klaar. Niemand maakt hem ooit af. En als de agent die hem startte gesloten wordt, krijgt hij het init-proces als nieuwe ouder en is hij een wees waar niemand op de machine nog verantwoordelijk voor is.
Daarom sluipt de traagheid erin. Er is geen dramatisch moment, er is een langzame opeenstapeling over een werkdag, en dat is precies de vorm waardoor mensen het verkeerde de schuld geven: oververhitting, te veel agents, een geheugenlek in de app. In de sessie die we hebben gemeten gebruikte de app zelf 2,8 GB verdeeld over 91 processen en de acht agent-CLI's 1,6 GB bij elkaar. Geen van beide was het probleem.
De procesbewaker is het vangnet. Hij bewaakt wat agents achterlaten, vertelt je welk proces vastzit en wie het startte, en laat je het beëindigen. De onderliggende oorzaken blijven veranderen: een andere tool, een ander patroon, een andere provider. Het vangnet hoeft niet mee te veranderen.
Waarom een machine met AI-agents traag wordt
De cijfers hieronder komen uit één gemeten sessie op een laptop met 16 GB en acht draaiende agents. Niets hiervan is een schatting.
De machine stond vijfenhalf uur aan. Geen enkel thermisch probleem: geen throttling geregistreerd, accu op 30,6 °C. Het load average lag tussen 17 en 21 op 8 cores, en de CPU bracht 56% van zijn tijd in de kernel door tegenover 1,5% inactief. Die verhouding verraadt alles. Een machine die echt werk doet brengt zijn tijd door in usercode; een machine met 56% systeemtijd is een kernel die niets anders doet dan geheugen comprimeren, decomprimeren en swappen.
Zeven vastgelopen zoekprocessen hielden elk tussen 3,9 en 8,0 GB vast, samen 41,8 GB geclaimd op een machine met 16 GB RAM. De swap stond op 22,3 GB van de 23,5, en er was sinds het opstarten ongeveer 993 GB naar swap geschreven. Die zeven processen beëindigen gaf meteen 15,5 GB terug, zonder één agent te herstarten en zonder de app te herstarten.
Niemand vangt dit met de hand op, omdat de gebruikelijke tools erover liegen. Op macOS kan een vastgelopen proces 20 MB residentieel geheugen tonen terwijl het er in werkelijkheid 8 GB vasthoudt, omdat alles wat het aanraakte door de geheugencompressor ging. We hebben er live een gemeten op 4,7 GB residentieel voor een echte voetafdruk van 14 GB. De virtuele grootte helpt evenmin: op dat platform meldt zelfs launchd zo'n 440 GB virtuele grootte, dus daarop filteren markeert de hele machine.
Dezelfde sessie, uur na uur: de brokken geheugen die niemand meer gebruikt, en wat er gebeurt als ze worden vrijgegeven.
En deze processen hebben vier eigenschappen die garanderen dat ze er morgen nog staan.
Ze komen nooit klaar
Hun eigen geheugen staat in swap, dus ze besteden hun tijd aan page faults in plaats van rekenen. Een gezonde zoekopdracht trekt een core vol; deze blijven op 4% hangen. Uit die spiraal is geen uitweg, en wachten helpt niets.
Ze gaan nooit dood
Op een toolaanroep staat geen timeout. Niets op de machine heeft een mening over een proces dat al vijftig minuten niets doet. Het blijft daar staan tot iemand het afschiet of de machine opnieuw opstart.
Ze overleven hun agent
Sluit het tabblad van de agent en het proces kan blijven leven, met het init-proces als nieuwe ouder. Vanaf dat moment verbindt niets het meer met wat dan ook: het is een wees, en niemand ruimt het ooit op. Twee van de zeven die we maten waren al zo ver.
Ze stapelen zich op
Eén per verificatieronde, één per zoekopdracht met pech. Daarom neemt de traagheid over de dag alleen maar toe, en daarom lijkt opnieuw opstarten het op te lossen. Het lost niets op, het zet alleen de teller terug.
Wat de procesbewaker doet
Hij bewaakt de processen die je agents starten, en is bewust heel kieskeurig over welke hij aanraakt.
Meet het echte geheugen
Niet de residentiële grootte, die een vastgelopen proces gigabytes te laag inschat. De bewaker leest de echte voetafdruk, inclusief gecomprimeerde en naar swap weggeschreven pagina's, dus een proces dat 20 MB toont terwijl het er 8 GB vasthoudt wordt gezien voor wat het is.
Kijkt naar de CPU, niet alleen naar de RAM
Geheugen alleen zou elke build op je machine markeren. De bewaker meet processorgebruik als een tempo tussen twee scans, dus een proces dat hard gewerkt heeft en daarna vastliep wordt alsnog gepakt, en een build die echt aan het werk is blijft met rust.
Vangt weesprocessen
Een proces dat de agent die het startte heeft overleefd wordt op eigen kracht gemeld, want niemand anders ruimt het ooit op. Het eigenaarschap wordt onthouden terwijl het proces nog vasthangt, het enige moment waarop dat te bepalen is.
Eén klik om te beëindigen
Een badge in de statusbalk toont elk vastgelopen proces met de agent die het startte, het geheugen, de leeftijd en de CPU. Er één beëindigen sluit het af, samen met alles wat het zelf gestart heeft. Het geheugen komt meteen terug en je agents draaien gewoon door.
macOS, Windows en Linux
Elk systeem vraagt een andere meting om de waarheid over geheugen te vertellen: gecomprimeerde pagina's op macOS, residentieel plus geswapt op Linux, private commit op Windows. Alle drie zijn geïmplementeerd, niet gepland.
Kost bijna niets
Eén procesmomentopname per minuut, gemeten op ongeveer 40 ms op een machine met 824 draaiende processen. De dure geheugenmeting draait alleen als er al iets vastgelopen lijkt, en er draait helemaal geen scan zolang er geen agent actief is.
De regel die vals alarm voorkomt
Een bewaker die je builds markeert is een bewaker die je binnen een week uitzet. Daarom wordt een proces nooit alleen op zijn geheugen gemeld. Het moet groot zijn, het moet al een tijd leven, en het moet gestopt zijn met de processor gebruiken. Alle drie tegelijk.
Die derde voorwaarde doet het werk. Een typecheck of een bundler houdt ook minutenlang gigabytes vast, maar trekt ondertussen een core vol. Een proces dat vastzit in swap blijft rond de 4% hangen, omdat het zijn leven doorbrengt met wachten op page faults in plaats van rekenen. Dat verschil scheidt een machine die werkt van een machine die kopje-onder gaat, en het is het enige signaal dat ze betrouwbaar uit elkaar houdt.
Processorgebruik wordt ook gemeten in plaats van afgelezen. Het cijfer dat een systeemtool geeft is een gemiddelde over het hele leven van een proces, en dat ziet er nog druk uit voor iets dat twintig minuten hard gewerkt heeft en daarna vastliep. De bewaker vergelijkt in plaats daarvan de verbruikte processortijd tussen twee scans, dus wat hij ziet is de laatste minuut, niet het laatste uur.
Hoe het werkt
Vier stappen, één keer per minuut, en de dure stap draait bijna nooit.
Eén goedkope momentopname van de machine
Elke minuut maakt de bewaker één momentopname van alle draaiende processen en loopt hij de boom onder elke agentterminal af. Gemeten kosten op een machine met 824 draaiende processen: ongeveer 40 ms. Zolang er geen agent draait, gebeurt dit helemaal niet.
De verdachten overhouden
Uit die momentopname houdt hij alleen de kindprocessen van agents over die langer leven dan jouw drempel en de processor niet meer gebruiken. In normaal gebruik is die lijst leeg, en stopt alles hier.
Meten wat vastgelopen lijkt
Alleen voor die korte lijst betaalt de bewaker de echte geheugenmeting, inclusief gecomprimeerde en naar swap weggeschreven pagina's. Een proces dat hij niet kan meten wordt nooit gemarkeerd: een onbekende is geen oordeel.
Melden, en jou laten beslissen
Er verschijnt een badge in de statusbalk en één melding vertelt het je één keer. Je opent de lijst, ziet wat het proces is, hoeveel het vasthoudt, hoe lang het al vastzit en welke agent het startte, en je beëindigt het als je dat wilt.
Waar hij nooit aan komt
Een tool die processen kan beëindigen moet heel strikt zijn over wat hem aangaat. Deze grenzen zijn structureel, geen opties die je moet onthouden aan te zetten.
- De agent-CLI zelf. Welke provider je ook draait, de bewaker beschermt het binary waarmee de app die terminal gestart heeft. Hij leest die naam uit de start zelf in plaats van uit een hardgecodeerde lijst, dus een subproces van dezelfde CLI is ook beschermd, op elke diepte.
- Je terminals met dev-commando's. Een dev-server die stilstaat voldoet aan elk criterium voor een vastgelopen proces: dik, oud, geen processorgebruik. Het is ook precies het proces dat je wél wilt zien draaien. Alleen agentterminals worden bewaakt, dus je dev-server komt nooit in beeld.
- De shell en het leidingwerk van de app zelf. De terminalhelper en de shell waarin een agent draait zijn per constructie uitgesloten. Alleen de toolprocessen onder de agent-CLI komen ooit in aanmerking.
- Alles wat hij niet zelf heeft opgepikt. Het enige pad dat een proces kan beëindigen weigert elk proces dat de bewaker niet uit de boom van een agent heeft opgepikt. Het kan geen manier worden om iets anders op je machine af te sluiten.
En er wordt niets automatisch beëindigd tenzij je erom vraagt. Standaard meldt de bewaker wat hij gevonden heeft en beslis jij, want jij bent degene die weet of een groot, stil proces verwacht was.
Wanneer hij zijn plek verdient
Elk van deze situaties is echt, geen enkele is hypothetisch.
De machine trager om 18 uur dan om 9 uur
Geen enkel moment waarop het stukging, gewoon een gestage afglijding over de dag. Die vorm is bijna altijd opgestapelde vastgelopen processen, en het is de moeilijkste om met de hand vast te stellen omdat er op geen enkel moment iets mis lijkt.
Meerdere agents die parallel werken
Hoe meer agents je draait, hoe meer toolaanroepen er gebeuren, en hoe groter de kans dat er eentje vastloopt. Het uitvalpercentage per aanroep is minuscuul; vermenigvuldigd met een dag parallel werk is het dat niet meer.
Een zoekopdracht die nooit terugkomt
Een patroon dat de regex-engine laat exploderen alloceert gigabytes op een bestand van een paar honderd kilobyte. De agent wacht erop, jij wacht op de agent, en de machine betaalt voor allebei.
Je sloot de agent, het proces bleef
Een tabblad sluiten maakt niet altijd iets vrij. Een proces dat al losgekoppeld was houdt zijn geheugen en verliest zijn laatste link met alles wat je in de app kunt zien.
Een laptop met 16 GB
Op een machine met veel RAM blijven een paar vastgelopen processen lang verborgen. Op een laptop met 16 GB raken ze de swap snel, en zodra het systeem geheugen begint te comprimeren wordt elke agent tegelijk trager.
Voordat je de app de schuld geeft
Als een machine kruipt terwijl AgentsRoom openstaat, is de app de voor de hand liggende verdachte. De echte cijfers hebben, per proces, met de agent die elk proces startte, maakt van een vermoeden iets dat je echt kunt nagaan.
Jij stelt de grenzen
De standaardwaarden zijn bewust voorzichtig. Alles hieronder staat in de instellingen, onder Terminal, en elk van die instellingen kan ook door een agent gelezen en gewijzigd worden via de MCP-tools van AgentsRoom.
- Kindprocessen van agents bewaken
- Staat standaard aan. Zet het uit en er draait helemaal geen scan meer, nooit.
- Melden boven een geheugendrempel
- Standaard twee gigabyte. Daaronder is een vastgelopen proces het niet waard om je voor te storen. Zet hem hoger op een werkstation met veel RAM, lager op een laptop waar het geheugen krap zit.
- Na een minimale levensduur
- Standaard vijf minuten. Dat is wat voorkomt dat een trage maar legitieme taak ooit gemarkeerd wordt, want bijna niets wat je echt wilt duurt vijf minuten zonder ook maar iets van de processor te gebruiken.
- Vastgelopen processen automatisch beëindigen
- Staat standaard uit, en dat is een bewuste productkeuze en geen voorzichtigheid. De bewaker velt een oordeel, en alleen jij weet of een groot, stil proces verwacht was. Zet het aan en hij handelt zelf, met een melding achteraf.
De processordrempel staat er bewust niet bij. Dat is de meting die een werkende build van een vastgelopen proces scheidt, en dat is geen kwestie van smaak.
Veelgestelde vragen
Betekent dit dat AgentsRoom mijn computer traag maakt?
Nee, en precies daarom bestaat de functie. In de sessie die we maten gebruikte de app 2,8 GB verdeeld over 91 processen en de acht agent-CLI's 1,6 GB bij elkaar. Die 41,8 GB werd vastgehouden door toolprocessen die vastgelopen waren. AgentsRoom is toevallig de enige plek die elke agent en elk proces dat hij startte kan zien, dus de enige plek die erover kan oordelen.
Schiet het mijn build of mijn testrun af?
Nee. Een proces wordt alleen gemarkeerd als het groot is EN oud EN gestopt is met de processor gebruiken. Een build die echt aan het werk is trekt een core vol, faalt dus op de derde voorwaarde en is nooit een kandidaat. Die voorwaarde bestaat precies om dat onderscheid te maken.
Bewaakt het mijn dev-server?
Nee, en dat zal het nooit doen. Een dev-server die stilstaat voldoet aan elk criterium: hij houdt veel geheugen vast, hij draait al uren, en hij gebruikt tussen twee requests geen processor. Alleen de kindprocessen van agentterminals worden bewaakt, dus je dev-commando's vallen per constructie buiten het bereik.
Kan het de agent zelf beëindigen?
Nee. De agent-CLI is beschermd, welke provider je ook gebruikt, en die bescherming is gebaseerd op het binary waarmee de app die terminal gestart heeft in plaats van op een lijst met bekende namen. De shell en de terminalhelper van de app zelf zijn ook uitgesloten.
Wat is een weesproces en waarom krijgt het een aparte behandeling?
Een proces waarvan de ouder is gestopt krijgt het init-proces van het systeem als nieuwe ouder. Vanaf dat moment verbindt niets het nog met de agent die het startte, dus niemand ruimt het ooit op. AgentsRoom onthoudt het eigenaarschap terwijl het proces nog vasthangt, het enige moment waarop dat te bepalen is, en kan het proces daarna dus alsnog melden.
Wat kost het bewaken zelf?
Eén procesmomentopname per minuut, gemeten op ongeveer 40 ms op een machine met 824 draaiende processen. De duurdere geheugenmeting draait alleen op processen die er al vastgelopen uitzien, wat in normaal gebruik betekent dat hij niet draait. En de scan bestaat helemaal niet zolang er geen agent actief is.
Waarom niet gewoon naar de geheugenkolom in Activiteitenweergave kijken?
Omdat die op macOS het probleem met een orde van grootte te laag inschat. Een proces dat het gecomprimeerde geheugen in geduwd is kan 20 MB residentieel tonen terwijl het 8 GB vasthoudt. We hebben er live een gemeten op 4,7 GB residentieel voor een echte voetafdruk van 14 GB. De virtuele grootte is niet beter: zelfs systeemprocessen melden er honderden gigabytes van.
Werkt het met Claude Code, Codex en de rest?
Ja. De bewaker weet niets van een specifieke tool of provider. Hij bewaakt de kindprocessen van welke agentterminal je ook gestart hebt, en de CLI die hij beschermt wordt uit de start zelf gelezen. Een provider toevoegen verandert hier niets aan.
Werkt het op Windows en Linux?
Ja. Elk platform vraagt een andere meting om het geheugen eerlijk weer te geven: gecomprimeerde pagina's op macOS, residentieel plus geswapt op Linux, private commit op Windows. Alle drie zijn geïmplementeerd.
Beëindigt het processen zonder het mij te vragen?
Niet tenzij je dat aanzet. Standaard meldt het wat het gevonden heeft, met de agent, het geheugen, de leeftijd en het processorgebruik, en beslis jij. Automatisch beëindigen is een instelling, uit bij de eerste start.
Wat gebeurt er met de agent als ik een van zijn processen beëindig?
De agent draait gewoon door. Zijn toolaanroep krijgt een foutmelding in plaats van eeuwig te blijven hangen, en dat is precies de uitkomst die je wilt: dat proces zou toch nooit klaar zijn gekomen. Er wordt niets herstart en er gaat geen context verloren.
Lost het de onderliggende oorzaak op?
Nee, en dat probeert het ook niet. De oorzaken veranderen: vandaag de ene tool, morgen een ander patroon, volgende maand een andere provider. Dit is een vangnet, gebouwd om te blijven werken als de oorzaak er een is die nog niemand gezien heeft.
Misschien ook interessant
Context Canary
De andere vroege waarschuwing: die bewaakt de context van de agent zelf in plaats van de machine, en vertelt je dat een agent afdrijft voordat hij bestanden en API's begint te verzinnen.
Dev Terminals
Draai je dev-servers en je lange commando's in AgentsRoom, met een melding zodra een lang commando klaar is. Deze terminals zijn precies degene die de procesbewaker met opzet nooit aanraakt.
Agentstatus volgen
Zie in één oogopslag welke agents werken, welke op jou wachten en welke stilstaan, zonder één terminal te lezen.
Tokengebruik
De andere hulpbron die het bekijken waard is. Tokenverbruik en quota per agent, zodat je weet waar je verbruik heen gaat.
Gesplitst scherm
Meerdere agents naast elkaar in één venster, elk met een eigen paneel, kleur en live status.
CLI Doctor
Als een agent niet wil starten, vertelt hij je waarom en wat je eraan kunt doen, in plaats van je met een lege terminal achter te laten.
Stop met betalen voor processen die niemand gebruikt
AgentsRoom is gratis te downloaden, en de procesbewaker staat vanaf de eerste start aan.
Companion-app: houd je agents onderweg in de gaten
Breng je eigen: Claude, Codex, Antigravity CLI of andere AI-provider.
Stuur bugs en verzoeken direct naar je openbare backlog.
Een glimp van AgentsRoom in actie.