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 een handvol die tegelijk draaien is al genoeg om het geheugen van een machine vol te zetten.
De procesbewaker loopt de kindprocessen van je agents na, markeert de processen die je geheugen opeten, stuk voor stuk of als groep, noemt de verantwoordelijke agent en laat je die onderbreken. Er wordt niets achter je rug om afgesloten.
Screenshots
Echte schermafbeeldingen van de app, toegevoegd naarmate deze functie zich ontwikkelt.
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 terwijl de kernel gigabytes voor hem naar swap schrijft. Hij komt nooit klaar. Niemand maakt hem ooit af. En als de agent die hem startte gesloten wordt, 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.
Gefilmd in de echte app: een AI-agent start een commando dat 1,5 GB geheugen vasthoudt en nooit klaar is. Een minuut later kleurt de melding Processen rood in de statusbalk en opent het paneel Bescherming van je computer vanzelf, met de agent die het startte, het commando en het geheugen dat het vasthoudt. Eén klik op Beëindigen geeft de 1,5 GB vrij, en de agent is nog steeds open.
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. Ze zitten daarbij niet stil: de op hol geslagen processen die we maten verstookten er elk tussen de 10 en 19% van een core, en hoe meer er zich opstapelen, hoe minder elk van hen krijgt. 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. Elk systeem verbreekt de band anders: klassiek Unix geeft het init als nieuwe ouder, een Linux-desktop je systemd-gebruikersmanager, en Windows geeft het helemaal geen nieuwe ouder en laat het wijzen naar een ouder die niet meer bestaat. Daarom kijkt de bewaker nooit naar ouders. Hij onthoudt wat hij heeft opgepikt zolang de band er nog was, en behandelt alles wat in de actuele processenboom ontbreekt als een wees, op alle drie de systemen precies hetzelfde. Twee van de zeven die we maten waren al zo ver.
Ze stapelen zich op
Eén per verificatieronde, één per zoekopdracht met pech, en er nog één elke keer dat een agent een traag commando voor een vastgelopen commando aanziet en het opnieuw start. We hebben twaalf typechecks tegelijk gemeten, gestart door zes agents, waarvan er twee er elk drie tegelijk hadden lopen. 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.
Meet de processor, vertrouwt hem nooit
Processorgebruik wordt gelezen als een tempo tussen twee scans, niet als het levenslange gemiddelde dat een systeemtool geeft, dus een proces dat hard gewerkt heeft en daarna vastliep wordt alsnog gepakt. Wat het oplevert is een hogere drempel voor iets dat nog werkt, nooit een vrijbrief: een op hol geslagen proces dat een vijfde van een core verstookt is precies wat de eerste versie van deze bewaker miste.
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.
Ziet de groep, niet alleen de uitschieter
Twaalf typechecks van elk 1,4 GB zijn 16,8 GB op een machine met 16 GB, en stuk voor stuk blijven ze onder een verstandige drempel. Zodra de processen die je agents gestart hebben samen de helft van het fysieke geheugen van de machine vullen, wordt de omvang niet meer één voor één beoordeeld.
Noemt de verantwoordelijke agent
Twee of meer gemarkeerde opdrachten van dezelfde agent worden gegroepeerd onder zijn avatar, met wat ze samen vasthouden en een waarschuwing die de cyclus uitlegt waarin ze vastzitten. Eén opdracht is een ongelukje; meerdere tegelijk is gedrag.
Onderbreekt de agent, niet alleen het proces
Een proces beëindigen terwijl de agent midden in zijn beurt zit geeft die agent een foutmelding waar hij op reageert, vaak door de opdracht opnieuw uit te voeren. Eén knop stuurt in plaats daarvan Ctrl+C naar de terminal van de agent: zijn beurt eindigt, er wordt niets opnieuw gestart, en de agent blijft open.
De regels die vals alarm voorkomen
Een bewaker die je builds markeert is een bewaker die je binnen een week uitzet, dus de drempel ligt bewust hoog. Van elk kindproces van een agent dat langer leeft dan jouw drempel wordt het echte geheugen gemeten, en het wordt gemeld zodra het meer vasthoudt dan jij hebt toegestaan. Een proces dat nog de processor gebruikt moet het dubbele vasthouden, en dat is wat een lange, legitieme build buiten schot houdt.
Processorgebruik bepaalt die drempel, het is geen toegangspoort. De eerste versie van deze bewaker eiste dat een proces niets meer deed voordat hij überhaupt naar het geheugen keek, en dat was verkeerd. Een zoekopdracht met een patroon dat de regex-engine laat exploderen doet wel degelijk iets: hij verstookt een vijfde van een core terwijl de kernel gigabytes voor hem naar swap schrijft. Erger nog, hoe meer er zich opstapelen, hoe minder processor elk van hen krijgt, dus de blinde vlek was het grootst helemaal aan het begin, precies wanneer er eentje beëindigen het goedkoopst was.
De tweede regel bestaat omdat een drempel per proces geen groep kan zien. Twaalf typechecks die elk 1,4 GB vasthouden zijn afzonderlijk redelijk en samen dodelijk op een machine met 16 GB. Dus zodra alles wat de agents gestart hebben samen de helft van het fysieke geheugen van de machine beslaat, wordt het allemaal gemeld, wat elk stuk op zichzelf ook weegt. Uit die groep wordt nooit iets automatisch beëindigd: het zit onder de grens die jij hebt ingesteld, en het is alleen gemarkeerd vanwege zijn buren.
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 elk kindproces over van een agent dat langer leeft dan jouw drempel. Dat is het hele filter, en er wordt niets uitgesloten omdat het nog de processor gebruikt: precies zo miste de vorige versie van deze bewaker de op hol geslagen processen. In normaal gebruik is die lijst leeg, want de toolaanroepen van een agent zijn binnen seconden klaar.
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. Zelfs aangezet laat automatisch beëindigen alles met rust wat nog de processor gebruikt, en ook alles wat alleen gemarkeerd is om wat zijn buren vasthouden.
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. Daaronder wordt er zelfs niets gemeten, en dat is wat de gewone toolaanroepen van een agent, die binnen seconden klaar zijn, volledig buiten beeld houdt.
- 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 niet bij, en het punt waarop de machine als verzadigd geldt evenmin. Allebei stonden ze ooit verkeerd en zijn ze rechtgezet door echte incidenten te meten in plaats van op smaak te beslissen, dus een schuifregelaar voor een van beide zou vooral een manier zijn om de blinde vlek terug te zetten.
Veelgestelde vragen
Stel ons een andere vraagBetekent dit dat AgentsRoom mijn computer traag maakt?
Schiet het mijn build of mijn testrun af?
Bewaakt het mijn dev-server?
Kan het de agent zelf beëindigen?
Wat is een weesproces en waarom krijgt het een aparte behandeling?
Wat kost het bewaken zelf?
Waarom niet gewoon naar de geheugenkolom in Activiteitenweergave kijken?
Werkt het met Claude Code, Codex en de rest?
Werkt het op Windows en Linux?
Beëindigt het processen zonder het mij te vragen?
Wat gebeurt er met de agent als ik een van zijn processen beëindig?
Lost het de onderliggende oorzaak op?
Twaalf processen, geen enkele boven mijn drempel. Zegt hij dan iets?
Wat doet de knop Agent onderbreken precies?
Misschien ook interessant
Wakker houden
Voorkom dat je computer in slaapstand gaat midden in een build, een dev-server of een beurt van een AI-agent. AgentsRoom houdt de slaapstand van het systeem tegen terwijl Claude Code, Codex of een andere agent werkt, een dev-commando draait of een database-export bezig is, en laat de machine daarna weer slapen. Een kopje in de statusbalk laat zien wanneer en waarom, en met één klik blijft de machine 1, 4 of 8 uur wakker, net als met Caffeine of PowerToys Awake. macOS, Windows en Linux.
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.
