Multi-agent-communicatie: hoe AI-systemen met elkaar leren praten
Stel je een ziekenhuis voor waar je niet naar één alwetende arts gaat, maar waar een huisarts, een radioloog en een chirurg met elkaar overleggen voordat ze een beslissing nemen. Elk heeft een eigen specialisatie en samen komen ze tot een beter resultaat dan één persoon alleen zou kunnen. Multi-agent-communicatie is het AI-equivalent van dat overleg: meerdere zelfstandige AI-programma's, agents genoemd, wisselen berichten, taken en resultaten met elkaar uit om samen een probleem op te lossen dat te groot of te specialistisch is voor één systeem.
Een concreet voorbeeld: stel dat je een AI vraagt om een zakenreis te plannen. In plaats van dat één groot taalmodel alles zelf doet, kan een 'planning-agent' de taak opsplitsen en doorsturen naar een 'vlucht-agent' die tickets zoekt, een 'agenda-agent' die je beschikbaarheid checkt en een 'betaal-agent' die de transactie afhandelt. Die agents moeten het onderling eens worden over wie wat doet, in welke volgorde, en hoe ze resultaten aan elkaar doorgeven. Dat vraagt om afspraken over taal en structuur — precies waar multi-agent-communicatie over gaat.
Wat is het precies?
Een agent is in deze context geen mens, maar een stuk software dat op basis van een taalmodel (zoals GPT, Claude of Gemini) zelfstandig beslissingen neemt, tools kan aanroepen en doelen nastreeft zonder dat een mens elke stap goedkeurt. Zodra je meerdere van zulke agents laat samenwerken, ontstaat de vraag: in welke 'taal' en volgens welke regels praten ze met elkaar?
Net zoals computers op internet alleen met elkaar kunnen praten dankzij afgesproken standaarden (zoals HTTP voor webpagina's), hebben AI-agents een gedeeld formaat nodig voor hun berichten. Dat formaat bepaalt zaken als: hoe meld je wie je bent en wat je kunt, hoe vraag je een andere agent om een taak uit te voeren, hoe geef je een tussentijds resultaat door, en hoe meld je een fout.
In de praktijk bestaat multi-agent-communicatie meestal uit een paar bouwstenen. Ten eerste is er een berichtenformaat, vaak gebaseerd op bekende technieken zoals JSON (een simpel tekstformaat voor gestructureerde data). Ten tweede is er een vorm van taakverdeling: een orkestrerende agent (soms 'orchestrator' genoemd) verdeelt een grote opdracht in kleinere stukken. Ten derde is er gedeelde context: agents moeten elkaar bijpraten over wat er al gebeurd is, zodat ze niet langs elkaar heen werken. En ten slotte is er vaak een mechanisme om tools aan te roepen — externe programma's zoals een zoekmachine, rekenmachine of database — waarbij het ene agentbericht eigenlijk een verzoek is om zo'n tool namens een ander te gebruiken.
Belangrijk om te beseffen: dit is geen bewustzijn of 'overleg' zoals mensen dat voeren. Het blijft tekst die heen en weer wordt gestuurd tussen programma's, waarbij elk programma op basis van patronen in taal een passend antwoord genereert.
Wat wil men ermee bereiken?
De belangrijkste drijfveer is specialisatie. Eén taalmodel dat alles moet kunnen — coderen, plannen, rekenen, schrijven — presteert vaak minder goed dan een verzameling kleinere, gespecialiseerde agents die ieder hun eigen taak goed beheersen en de resultaten combineren.
Een tweede doel is het omzeilen van de beperkingen van een enkel model. Taalmodellen hebben een beperkt 'geheugen' binnen één gesprek (het zogeheten contextvenster). Door taken te verdelen over meerdere agents met elk hun eigen, kleinere stuk informatie, kan een groter probleem toch behapbaar blijven.
Een derde, en steeds belangrijker doel, is interoperabiliteit tussen bedrijven. Grote techbedrijven bouwen elk hun eigen AI-agents, maar een bedrijf wil dat zijn boekhoud-agent kan communiceren met de logistiek-agent van een leverancier, ook al zijn die door verschillende partijen gebouwd. Daarvoor zijn open, gedeelde standaarden nodig — net zoals e-mail werkt ongeacht welk mailprogramma je gebruikt. Dat is precies waarom er de laatste jaren een race is ontstaan om zulke standaarden te definiëren.
Ten slotte hoopt men op meer robuustheid: als één agent faalt of een fout maakt, kunnen andere agents dat mogelijk signaleren of corrigeren, in plaats van dat het hele systeem vastloopt.
Voorbeelden uit de praktijk
FIPA-ACL (eind jaren negentig, gestandaardiseerd in 2005) is een van de oudste pogingen om agentcommunicatie te standaardiseren, ontwikkeld door de Foundation for Intelligent Physical Agents. Het stamt uit een tijd vóór moderne taalmodellen en wordt vooral nog gebruikt in academisch onderzoek naar klassieke multi-agentsystemen.
Generative Agents ('Smallville', Stanford, 2023) was een spraakmakend onderzoeksproject waarin 25 AI-personages in een gesimuleerd dorpje met elkaar communiceerden, afspraken maakten en zelfs geruchten verspreidden. Het liet zien dat taalmodel-agents geloofwaardig sociaal gedrag kunnen vertonen, al was het een gesloten simulatie zonder praktische toepassing.
Microsoft AutoGen (2023) is een opensource-softwarekader waarmee ontwikkelaars meerdere agents kunnen laten samenwerken aan een taak, bijvoorbeeld een 'programmeur-agent' en een 'reviewer-agent' die code schrijven en controleren.
Model Context Protocol (MCP), gelanceerd door Anthropic in november 2024, is een open standaard waarmee AI-modellen op een uniforme manier toegang krijgen tot externe tools en gegevensbronnen. Hoewel primair gericht op de verbinding tussen model en tool, wordt het ook gebruikt als bouwsteen voor communicatie tussen agents onderling, en is het inmiddels overgenomen door meerdere andere AI-aanbieders.
Agent2Agent-protocol (A2A), aangekondigd door Google in april 2025, is specifiek ontworpen voor communicatie tússen agents van verschillende makers. Meer dan vijftig technologiebedrijven kondigden steun voor het protocol aan, met als doel dat bijvoorbeeld een HR-agent van het ene bedrijf een taak kan uitbesteden aan een agent van een ander bedrijf, zonder dat ze vooraf specifiek voor elkaar zijn gebouwd.
Hoe ver is de techniek?
Multi-agent-communicatie bevindt zich nog duidelijk in een vroege, experimentele fase. Er is geen enkele dominante standaard; MCP en A2A bijvoorbeeld zijn deels complementair (het ene regelt tool-toegang, het andere agent-tot-agent-verkeer) maar het is nog onduidelijk welke aanpak op lange termijn de overhand krijgt, en of ze naast elkaar zullen blijven bestaan.
Een terugkerend technisch probleem is foutopstapeling: als agent A een klein foutje maakt en dat doorgeeft aan agent B, die er op voortbouwt en het weer doorgeeft aan agent C, kan een kleine vergissing uitgroeien tot een grote fout, zonder dat iemand die op tijd opmerkt. Onderzoekers werken aan manieren om dit te detecteren, bijvoorbeeld door agents elkaars werk te laten controleren, maar een sluitende oplossing bestaat nog niet.
Ook veiligheid is een punt van zorg. Als een kwaadwillende partij een bericht tussen twee agents kan manipuleren (een vorm van zogeheten prompt-injectie, waarbij verborgen instructies in tekst een AI-systeem misleiden), kan dat ongewenst gedrag veroorzaken verderop in de keten. Beveiligingsonderzoekers waarschuwen dat multi-agentsystemen door hun onderlinge afhankelijkheid extra aandachtspunten voor misbruik kunnen introduceren.
In de praktijk zitten de meeste toepassingen nog in de pilotfase: bedrijven experimenteren met multi-agentopstellingen voor klantenservice, softwareontwikkeling en dataverwerking, maar grootschalige, betrouwbare inzet tussen volledig onafhankelijke organisaties is per 2025 nog geen gangbare praktijk.
Wie werken eraan?
Aan de commerciële kant zijn Anthropic (met MCP), Google (met A2A) en Microsoft (met AutoGen en het bredere Azure AI-platform) de meest zichtbare partijen. Ook OpenAI ontwikkelt eigen kaders voor agent-samenwerking, al met een minder uitgesproken focus op open standaarden.
Daarnaast speelt een levendige open source-gemeenschap een grote rol, met projecten als LangChain/LangGraph en CrewAI, die ontwikkelaars gereedschap geven om zelf multi-agentsystemen te bouwen zonder bij één techbedrijf te horen.
Academisch onderzoek komt vooral van Amerikaanse universiteiten zoals Stanford en MIT, die zowel de sociale als de technische aspecten van agentgedrag bestuderen. De historische standaardisatie-organisatie FIPA blijft een referentiepunt voor het formeel beschrijven van agentcommunicatie, ook al is de praktijk inmiddels verder gegaan dan hun oorspronkelijke standaarden. Geografisch ligt het zwaartepunt van de ontwikkeling duidelijk in de Verenigde Staten, met groeiende onderzoeksactiviteit in Europa en China.