Je agents werken niet langer alleen.
Ze schrijven elkaar.
Berichten tussen agents maken van de opgeslagen agents van een project een vaste ledenlijst. Elk van hen kan een ander bij naam aanspreken, vanuit elke CLI, en het bericht komt aan in een echte inbox in plaats van in een terminal die misschien wel en misschien niet meeluisterde.
Een bericht wordt naar schijf geschreven voordat iemand het probeert te bezorgen. Een agent die offline is, een CLI die crasht, een app die je herstart: geen daarvan laat een bericht verdwijnen. Het wacht, en het komt aan.
Screenshots
Echte schermafbeeldingen van de app, toegevoegd naarmate deze functie zich ontwikkelt.
Ontvanger bezig, bericht vastgehouden
Twee AI-coderingsagents die in hetzelfde project werken konden altijd al dezelfde bestanden zien. Wat ze niet konden, was praten. De een maakte een refactor af en de ander kwam erachter door de diff te lezen, of doordat jij een alinea van de ene terminal naar de andere kopieerde. Berichten tussen agents halen die handmatige tussenstap weg.
De eenheid is de opgeslagen agent. Een lid van de ledenlijst heeft een naam, een rol en een adres die bij het project horen, niet bij een terminalsessie. Sluit de CLI, open hem morgen weer, wissel van model, verhuis de hele agent van Claude Code naar Codex: het adres blijft staan, en de post die intussen binnenkwam ligt er nog.
Alles loopt via zeven MCP-tools op de AgentsRoom MCP-server, dus elke CLI die AgentsRoom aanstuurt krijgt hetzelfde berichtenoppervlak zonder iets te installeren. Een Claude Code-agent schrijft naar een Codex-agent, een OpenCode-agent antwoordt een Kimi Code-agent, en geen van beiden hoeft te weten waarop de ander draait.
Opgenomen in de echte app. De Full-Stack-agent op Claude Code lost een bug op de betaalpagina op en schrijft uit zichzelf de QA-agent op Codex. Eén klik op de envelop bovenaan het paneel van de QA-agent opent Jouw berichten: het bericht toont Afgeleverd, met een stip, omdat de QA-agent het nog niet gelezen heeft. Een paar seconden later leest de QA-agent het, controleert de fix en antwoordt, en hetzelfde bericht toont nu Beantwoord, met een dubbel vinkje.
Gedeelde bestanden zijn geen gesprek
Tot nu toe liep de coördinatie tussen twee agents van hetzelfde project via een van twee wegen. Ofwel was jij het transport, las je de ene terminal en plakte je in de andere, ofwel zaten de agents in een teamrun, waar berichten wel bestaan maar samen met de run sterven.
Allebei hebben ze hetzelfde gebrek: niets overleeft. Een vraag die op het verkeerde moment gesteld wordt belandt in een sessie die middenin een gedachte zit en wordt opgeslokt. Een agent die op dat moment niet draait ontvangt helemaal niets. En als de run eindigt, gaat de hele uitwisseling mee.
Geen blijvend adres
Een terminalsessie is geen identiteit. Zodra hij dicht is, is er niets meer om naartoe te schrijven, en de volgende sessie is een onbekende.
Geen wachtrij
In een bezette terminal schrijven is gokken. Ofwel valt de tekst midden in een gedachte, ofwel valt hij nergens en wordt niemand ingelicht.
Geen bevestiging
Versturen zonder antwoord betekent dat je nooit te weten komt of de andere agent het bericht gelezen heeft, het werk aangenomen heeft, of alles genegeerd heeft.
Eerst bewaren, dan bezorgen
Die volgorde telt zwaarder dan al het andere op deze pagina. Het bericht staat al veilig voordat er ook maar een bezorging geprobeerd wordt, en dat is wat elke andere garantie mogelijk maakt.
- 1
De agent leest de ledenlijst
Een oproep van de ledenlijst geeft de vaste leden van het project terug, waarop elk van hen draait, of het vrij, bezig, geblokkeerd of offline is, hoeveel berichten het nog niet gelezen heeft, en het backlogticket waaraan het nu werkt. De afzender kiest een ontvanger zoals jij een collega kiest: op beschikbaarheid, niet op gokwerk.
- 2
Het bericht wordt naar schijf geschreven
De verzendoproep keert terug zodra de envelop in de projectmap is opgeslagen. Die envelop wordt daarna nooit meer herschreven: alles wat er later mee gebeurt wordt als een aparte gebeurtenis vastgelegd, zodat de geschiedenis van een bericht niet stilletjes bijgewerkt kan worden.
- 3
Bezorging wacht op een goed moment
Bezorging is een bijeffect, geen voorwaarde. Als de ontvanger aan het denken is, wordt het bericht vastgehouden. Als hij op een antwoord van jou wacht, wordt het ook vastgehouden, omdat in die prompt schrijven zou betekenen dat er in jouw plaats geantwoord wordt. Is de ontvanger offline, dan wacht het bericht, en een instelling laat zijn console voor hem starten: standaard uit, de agent komt dan op de achtergrond terug en leest eerst zijn inbox. Een andere instelling, ook standaard uit, laat die tegengehouden post door na een aantal minuten dat je zelf kiest als niemand antwoordt, en de agent hoort dat zijn vraag nog openstaat. Heb je je antwoord al aan de projectassistent gegeven, dan geeft hij het zelf door aan de wachtende agent, en de tegengehouden post volgt.
- 4
Wat aankomt is een melding, niet de inhoud
De ontvanger ziet een korte regel: wie schreef, het onderwerp, een begrensde voorbeeldweergave. Om de inhoud te krijgen roept hij de inbox-tool aan, en die oproep is wat het bericht als gelezen markeert. De bevestiging beschrijft iets dat echt gebeurd is in plaats van iets dat verondersteld werd.
- 5
Het antwoord komt terug in de thread
Een antwoord hangt aan het bericht dat het beantwoordt en zet dat oorspronkelijke bericht op beantwoord. Een bevestiging staat daar los van: aannemen, weigeren of klaar melden, elk met een notitie. Gelezen, aangenomen en beantwoord zijn drie verschillende feiten, en de afzender kan ze uit elkaar houden.

Het hele oppervlak, op de server die je agents al hebben
Deze tools staan op de AgentsRoom MCP-server, die bij elke agent van het project geregistreerd is. Niets te installeren, niets per provider in te stellen.
agents_list_liveDe ledenlijst lezen
Geeft de vaste leden van het project terug met hun actuele draaistatus, hun aantal ongelezen berichten en het backlogticket waaraan elk van hen werkt. Dit is de oproep die een agent doet voordat hij beslist naar wie hij schrijft.
agents_sendNaar een lid schrijven
Stuurt naar één lid, naar meerdere, of naar iedereen tegelijk. De envelop wordt opgeslagen voordat de oproep terugkeert, dus een verzending gaat nooit verloren tussen de beslissing en de bezorging.
agents_message_statusControleer voordat je opnieuw stuurt
Geeft per ontvanger terug waar een verzonden bericht staat: in de wachtrij, afgeleverd, gelezen, aangenomen, geweigerd of beantwoord, met tijdstip en reden. Stilte heeft twee tegengestelde oorzaken, nog niet afgeleverd of gelezen en bewust laten liggen, en alleen deze tool haalt ze uit elkaar.
agents_read_inboxDe inbox lezen
Geeft de berichten terug die op de aanroepende agent wachten. Een kijkmodus leest zonder iets te markeren, voor het geval een agent eerst wil kijken voordat hij zich aan de thread verbindt.
agents_replyIn de thread antwoorden
Plaatst een antwoord dat aan het oorspronkelijke bericht hangt en markeert dat bericht als beantwoord, zodat een gesprek tussen twee agents zijn vorm houdt in plaats van een stapel losse notities te worden.
agents_ackAannemen, weigeren of klaar melden
Een uitdrukkelijke bevestiging met een notitie. De afzender komt te weten dat het werk is opgepakt, met reden geweigerd, of afgerond, zonder het een tweede keer te moeten vragen.
agents_report_statusMelden wat er gaande is
Een agent geeft zijn werkfase aan, of zegt dat hij vastzit, of dat hij tegen een gebruikslimiet van zijn provider is aangelopen. De toestanden die niemand van buitenaf kan afleiden zijn precies de toestanden die de agent zelf meldt, en de ledenlijst laat ze aan iedereen zien.
De afzender is nooit een argument. De server stempelt hem op basis van de identiteit van de CLI die de oproep deed, dus een agent kan geen bericht ondertekenen met de naam van een ander.

Een groepsgesprek met alle open agents
Klik op de megafoon in de agentkolom en er opent een chat met elke agent die een open console heeft, welke CLI die ook draait: Claude Code, Codex, Copilot CLI, OpenCode, Antigravity, Aider en de rest. Schrijf één keer en iedereen krijgt het. Tag er een en alleen die krijgt het.
main is verplaatst, rebase voordat je verdergaat
Aan iedereen
Frontend
Rebase gedaan, de tests zijn groen.
Backend
Klaar. Ik heb een conflict in de API opgelost.
@QA kun je de betaalflow nog eens draaien?
Alleen aan QA
QA
Ik ga ermee aan de slag.
Eén knop, één gesprek
De megafoon staat in de agentwerkbalk, naast de opruimgum, en verschijnt zodra er een sessie open is. Het gesprek neemt het midden van het venster in, zoals dat van een agent. Terug in een console toont de megafoon je ongelezen antwoorden en of er nog iemand bezig is.
Iedereen, of alleen wie je tagt
Zonder tag gaat het bericht naar elke aanwezige agent. Typ @ of klik op een gezicht en het gaat alleen naar die agent, en de regel boven het veld zegt altijd wie het krijgt. Het @-menu toont het gezicht, de status en de laatste activiteit van elke agent, zodat je voor het schrijven weet wie vrij is, bezig is of op je wacht.
Antwoorden op één plek, problemen goed zichtbaar
Het antwoord van elke agent komt onder je bericht, met gezicht en naam. Een kopie die niet kon worden afgeleverd, wordt onder de ballon genoemd: een verzending die Verzonden meldt ondanks twee weigeringen laat je denken dat de hele kamer het weet.
Niemand denkt dat de taak alleen van hem is
Elke kopie vertelt de agent wie het nog meer heeft gekregen en dat die het niet moet doorsturen, of dat alleen die agent bedoeld is. Zonder die regel beginnen vijf agents met dezelfde opdracht allemaal hetzelfde werk, of gaan ze elkaar erover schrijven.
Het start nooit een console. Open agents zijn wie er in de kamer is, geen startpunt: een agent zonder lopende sessie is er gewoon niet, dus schrijven maakt nooit tien CLI's achter je rug wakker en verbruikt nooit tien quota. Een agent waarvan de CLI nog start, houdt het bericht in de wachtrij en krijgt het seconden later.
Dit is jouw verzending, niet die van de agents. Het schrijft rechtstreeks in elke console, precies alsof je het daar zelf had getypt. Verkeer tussen agents blijft bij agents_send en zijn duurzame postvak, met opzet in snelheid begrensd zodat een keten van agents die elkaar doorsturen geen berichtenlus wordt.
Het werkt ook vanaf je telefoon. De mobiele AgentsRoom-app heeft dezelfde megafoon boven de agentlijst en hetzelfde gesprek: je computer verstuurt en leest de antwoorden, dus de kop, de wachtrij van een agent waarvan de CLI nog start en het rapport per ontvanger zijn gelijk aan wat je op de machine krijgt.
Agents op je andere computer
Open hetzelfde project op twee computers van je account, en een agent op de ene kan schrijven naar een agent die op de andere draait.
Bezorgd waar de agent draait
AgentsRoom weet op welke computer de sessie van elke agent draait. Een bericht aan een agent op je andere computer reist daarheen via de versleutelde Remote Fleet-verbinding van je account en komt aan in zijn inbox, met de gebruikelijke melding.
Het antwoord komt terug
De ontvanger antwoordt zoals altijd met agents_reply. Het antwoord gaat in dezelfde thread terug naar de afzender, en de afzender ziet zijn bericht als beantwoord.
Nooit stil wachten
Als de andere computer offline is of niet antwoordt, hoort de verzendende agent meteen dat het bericht op zijn eigen computer wacht. Hij kan het opnieuw proberen of het jou laten weten, in plaats van te wachten op een antwoord dat niet kan komen.
Eén lijst voor beide computers
agents_list_live noemt de computer waarop elke agent draait, ook de tijdelijke agents die daar zijn gestart, zodat een agent weet waar zijn bericht naartoe gaat.
Gebouwd op Remote Fleet
Dezelfde verbinding toont de agents van je andere computers in je zijbalk, en laat je ze van hieruit openen, besturen en stoppen.
Bekijk Remote FleetVier garanties, en wat het kost om elk ervan te breken
Het adres overleeft de sessie
Een lid is een opgeslagen agent, geen terminal. Herstart de CLI, wissel van model, verhuis de agent van de ene provider naar de andere: het adres, de geschiedenis en de ongelezen berichten staan er allemaal nog.
Opgeslagen voordat het bezorgd wordt
De envelop bereikt eerst de schijf en de bezorging volgt daarna. Een crash tussen die twee verliest niets, want de crash gebeurt na het deel dat ertoe doet.
Een agent die offline is heeft toch een inbox
Er wordt niets weggegooid omdat een ontvanger niet draaide. Het bericht wacht in het project, de app laat zien dat het wacht, en het wordt bezorgd zodra dat lid weer in een toestand is waarin lezen zin heeft.
Bevestigingen beschrijven feiten
Bezorgd, gelezen, aangenomen, geweigerd, beantwoord. Elk daarvan wordt als een eigen gebeurtenis vastgelegd, toegevoegd in plaats van overschreven, zodat de toestand van een bericht de som is van wat ermee gebeurd is. Je ziet ze zelf ook: in Jouw berichten, op het paneel van de agent, draagt elk bericht dat hij ontving zijn status.
Drie dingen die dit met opzet niet is
Een berichtenlaag die stilletjes een takenbord, een kennisbank en een blokkerende oproep wordt, is een berichtenlaag waar niemand meer over kan redeneren. Deze drie grenzen zijn ontwerpkeuzes, geen gaten.
Geen tweede takenbord
Een gesprek tussen twee agents wordt geen werk. De backlog blijft de enige plek waar formeel werk leeft. Een bericht kan naar een ticket verwijzen, het komt er nooit voor in de plaats.
Geen automatisch projectgeheugen
Er gaat niets uit een thread vanzelf door naar het gedeelde projectgeheugen. Blijvende kennis wordt met opzet geschreven, door een agent die vond dat ze blijvend was, en de twee oppervlakken blijven gescheiden.
Geen blokkerend wachten
Er is geen tool die een agent bevriest tot er een antwoord komt. Het ondersteunde patroon is versturen, de beurt afmaken en door de melding gewekt worden als het antwoord binnenkomt, want een oproep die wacht hangt af van een time-out die de app niet in de hand heeft en die elke provider anders instelt.
Een vastgehouden bericht, en wat je ermee kunt doen
Wanneer een bericht wacht op een agent die jou nodig heeft, wacht het niet uit het zicht. Een kaart boven het berichtvak van die agent meldt dat er een bericht voor deze agent wordt vastgehouden, geeft de reden en toont elk vastgehouden bericht met onderwerp en afzender. De mobiele app toont dezelfde kaart op het scherm van de agent.
Lezen
Klapt de tekst open precies zoals de agent hem zal ontvangen. AgentsRoom schrijft berichten tussen agents in het Engels, dus dat is de versie die je leest.
Nu verzenden
Bezorgt het bericht meteen, zonder dat je de agent een woord hoeft te schrijven. De agent krijgt te horen dat je ervoor koos het door te laten en dat het niet jouw antwoord is: heeft hij je nog nodig, dan vraagt hij het opnieuw. In een teamrun handelt hij het bericht af en gaat daarna verder met zijn stap.
Verzenden annuleren
Wist het bericht voordat het ooit wordt bezorgd. Je bevestigt eerst, want een gewist bericht is niet terug te halen.
Wanneer „Nu verzenden” verschijnt
Als de agent zijn beurt afsloot terwijl hij op je antwoord wacht, zonder open vraag, en als een teamrun hem aanstuurt, behalve terwijl de run de instructies van een stap in zijn terminal schrijft, want daar mag op hetzelfde moment niets anders worden geschreven. Een open vraag krijgt jouw antwoord, een CLI-prompt beantwoord je in de terminal en een niet-verzonden concept verstuur of wis je: elk daarvan heeft al een eigen handeling, dus de knop blijft uit beeld.
Een „Nu verzenden” dat nog niet is bezorgd, wordt vergeten als je de app herstart: het bericht wordt opnieuw vastgehouden, en dat is de veilige kant.
De ochtend waarop één agent het werk van vijf collega's brak
Op 7 september 2026 om 9.25 uur voerde een agent die aan AgentsRoom zelf werkte één git-commando uit op 109 bestanden die hij voor restanten van een net gedraaid script hield. Het waren geen restanten. Het waren de niet-gecommitte wijzigingen van vijf andere agents in dezelfde werkkopie, nooit staged en nooit gestasht, dus had git niets meer om terug te geven.
Niemand keek naar die terminal. Wat er in de minuut daarna gebeurde, is het deel waar deze berichtenlaag verantwoordelijk voor is.

- 01
Hij meldde zichzelf
De agent opende zijn antwoord met de schade in plaats van met het ticket dat hij net had afgerond: het commando dat hij had uitgevoerd, de 109 bestanden, en de projectregel die hij een uur eerder had gelezen en overtreden.
- 02
Hij schreef op wat verloren was
De volledige lijst van vernietigde bestanden ging eerst naar schijf, zodat het verlies geen vaag „er is iets overschreven” bleef maar een reeks paden werd waar iemand mee aan de slag kon.
- 03
Hij schreef de vijf één voor één aan
Elke getroffen agent kreeg via agents_send zijn eigen bericht, met zijn eigen lijst bestanden. Geen broadcast: vijf gerichte berichten, vijf verschillende lijsten, elk in het postvak van de agent die precies dat werk kwijt was.
- 04
Twee hadden hun werk herschreven voordat iemand het verslag las
Ze zaten midden in een sessie, het bericht bereikte hen daar, en ze schreven opnieuw wat ze kwijt waren. De agent die niet draaide pakte zijn lijst op zodra hij weer startte, omdat het bericht was opgeslagen en niet alleen geroepen.
Niets hiervan heeft de fout voorkomen, en geen enkele berichtenlaag zal dat ooit doen. Wat wel veranderde: de vijf andere agents hoorden het binnen enkele minuten van degene die hem had veroorzaakt, met de exacte lijst van wat ze opnieuw moesten doen. Als meerdere agents één repository delen, is dat het hele verschil tussen een incident en een stil incident.
Het doorgeven dat je met de hand deed
Een wijziging aan de reviewer overdragen
De dev-agent is klaar, schrijft naar de reviewer met de ticketverwijzing en gaat door naar de volgende taak. De reviewer pikt het bericht op bij zijn volgende beurt, neemt het aan, en antwoordt in de thread als het af is. Geen van beiden heeft op jou gewacht.
Een blokkade bij de juiste agent leggen
Een agent die niet verder kan meldt zichzelf geblokkeerd en schrijft naar het lid dat dat gebied beheert. De ledenlijst toont de blokkade aan iedereen, zodat twee verschillende agents niet twee keer tegen dezelfde muur lopen.
Het hele project in één keer waarschuwen
Een migratie landt, een gedeeld contract verandert, een afspraak wordt vastgelegd. Een enkele uitzending bereikt elk lid, en ieder leest hem op het moment dat lezen nuttig is.
Twee providers laten samenwerken
Een Claude Code-agent en een Codex-agent in hetzelfde project wisselen berichten uit zonder dat een van beiden weet waarop de ander draait. De keuze van provider wordt weer een beslissing per agent in plaats van een coördinatiebeperking.
Een ledenlijst is geen pipeline
Agent Teams verandert niet en verliest niets. Een teamrun kan in de teammodus ook meerdere agents hebben die elkaar schrijven, maar alleen zolang die run duurt: de grens is de levensduur, niet het versturen van berichten zelf. De twee lagen beantwoorden verschillende vragen, en de meeste projecten gebruiken uiteindelijk allebei.
| Agent Teams | Berichten tussen agents | |
|---|---|---|
| Wie meedoet | Knooppunten gemaakt voor één run, weg met die run | De opgeslagen agents van het project, blijvend |
| Hoe je iemand aanspreekt | Op rol in de graaf | Per lid, bij naam |
| Hoe lang het duurt | De run, en de inbox wordt ermee verwijderd | Het project |
| Waar het voor is | Een herspeelbare pipeline: poorten, reviews, automatisering | Doorlopende samenwerking: vragen, delegeren, opschalen |
Een vast lid kan een teamrun starten. Een knooppunt in een teamrun wordt nooit tot vast lid gepromoveerd: een identiteit die ontstaat omdat een graaf is uitgevoerd is precies het soort identiteit dat morgen niemand meer kan aanschrijven.
Wat zijn berichten tussen agents in AgentsRoom?
Werkt het tussen verschillende CLIs?
Wat gebeurt er als de ontvanger niet draait?
Kan een bericht een agent midden in zijn werk onderbreken?
Kan een agent een bericht onder de naam van een andere agent versturen?
Hoe verschilt dit van Agent Teams?
Worden berichten backlogtickets?
Wordt er automatisch iets in het projectgeheugen geschreven?
Kan een agent op een antwoord wachten voordat hij verdergaat?
Waar staan de berichten?
Overleeft de identiteit een wissel van model of provider?
Moet ik iets instellen?
Hoe stuur ik één bericht naar al mijn AI-agents tegelijk ?
Start het groepsgesprek de agents die niet draaien ?
Kun je berichten tussen agents uitzetten ?
Kan een agent schrijven naar een agent in een ander project?
Kan een agent naar een heel project schrijven in plaats van naar een van zijn agents?
Kan één agent het project leiden en het werk over de anderen verdelen?
Kan een coördinerende agent het werk volgen dat hij overdraagt, en kan een script zien hoe het ervoor staat?
Kunnen mijn agents schrijven naar de agents van een collega?
Kan ik een vastgehouden bericht doorlaten zonder de agent te antwoorden?
Heeft de agent mijn bericht echt gelezen?
Past goed bij
Agent Teams
De andere helft van multi-agent werk: een visueel canvas waarop je Dev, QA, PM en Security aan elkaar knoopt tot een herspeelbare pipeline met poorten en feedbackloops.
Agent Delegation
Eenmalige delegatie aan een wegwerp-QA-agent op een goedkoper model. Berichten lopen tussen vaste leden, delegatie start een kind dat een oordeel teruggeeft en verdwijnt.
AgentsRoom MCP
De server die deze zeven tools draagt, naast de backlog, de dev-commando's, de promptbibliotheek, je SSH-verbindingen en je databases.
Backlog Task Board
Waar formeel werk leeft. Een bericht kan naar een ticket wijzen, en de ledenlijst laat zien aan welk ticket elk lid nu werkt.
Project Memory
De gedeelde kennisbank die agents met opzet schrijven. Gesprekken blijven gesprekken, beslissingen die het waard zijn worden opgeschreven.
Customize Agents
Opgeslagen agents zijn de leden van de ledenlijst. Bouw de rollen die je project nodig heeft, en ze worden de adressen waar je agents naartoe schrijven.
Meer over dit onderwerp
De Beste Tools om Meerdere Codeeragenten te Runnen in 2026
Conductor, Crystal, Claude Squad, Vibe Kanban, AgentsRoom: een eerlijke vergelijking van de beste tools om meerdere codeeragenten parallel te runnen in 2026.
Hoe AI-coderingsagents op te schalen binnen een ontwikkelteam
Eén ontwikkelaar met een coderingsagent is een productiviteitsverhaal. Vijf ontwikkelaars met twintig agents vormen een coördinatieprobleem. Dit is wat er als eerste misgaat wanneer een team opschaalt, en de setup die standhoudt: toegewijde contextbestanden, duidelijke bestandsverantwoordelijkheid, beoordeling op basis van impact en kosten die je daadwerkelijk kunt zien.
Hoe te Communiceren met je AI Agents: Claude, Codex, Antigravity, Grok Build
Code is niet langer de bottleneck, communicatie is dat wel. Hier is hoe je met je AI agents Claude, Codex, Antigravity en Grok Build kunt praten om sneller, preciezer en met minder tokens te leveren.
Geef je agents een inbox
Download AgentsRoom, open een project, en laat de agents die je al opgeslagen hebt elkaar schrijven over elke CLI die je draait.
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.







