AI-basisprincipes
Wat is Agent2Agent (A2A)? Hoe AI‑agents communiceren en samenwerken
Agent2Agent is een open protocol waarmee agents elkaar kunnen ontdekken, berichten uitwisselen en werkzaamheden over systemen heen kunnen coördineren. Leer hoe A2A verschilt van MCP en waarom interoperabele agents belangrijk zijn.
Voeg Unite.AI toe aan je voorkeursbronnen op Google
Agent2Agent (A2A) is een open protocol dat AI‑agents in staat stelt elkaar te ontdekken, berichten uit te wisselen, taken te delegeren, voortgang te rapporteren en resultaten terug te leveren over systeemgrenzen heen. Het is ontworpen voor situaties waarin een agent hulp van een andere nodig heeft zonder dat een van beide partijen zijn interne redenering, geheugen of implementatie hoeft bloot te stellen.
Naarmate organisaties gespecialiseerde agents inzetten, wordt communicatie een infrastructuurprobleem. Een inkoop‑agent kan informatie nodig hebben van een compliance‑agent; een klantenservice‑agent kan een logistiek‑agent nodig hebben om een zending te onderzoeken. A2A biedt een gemeenschappelijke manier om dat werk te coördineren, zelfs wanneer de agents verschillende frameworks, leveranciers of modellen gebruiken.
Waarom agents een communicatiestandaard nodig hebben
Traditionele API’s exposeren functies en data, maar een agent‑naar‑agent‑interactie kan veel open‑ender zijn. De ontvangende agent moet mogelijk een doel interpreteren, bepalen hoe het op te lossen, vervolgvragen stellen, minuten of uren werken, updates streamen en meerdere artefacten teruggeven.
Zonder een gedeeld protocol zou elk platform zijn eigen formaten definiëren voor identiteit, capaciteitsontdekking, taken, berichten, status en fouten. Die fragmentatie maakt cross‑platform delegatie moeilijk en sluit bruikbare agents af binnen individuele producten.
A2A standaardiseert de communicatielaag terwijl elke agent een black box blijft. De huidige A2A-specificatie definieert de kernobjecten en interacties van het protocol.
De belangrijkste rollen in A2A
Deze scheiding is wat A2A anders maakt dan een eenvoudige functieaanroep. De externe deelnemer kan een langdurige taak beheren, om aanvullende informatie vragen, ondersteunde content‑types onderhandelen en één of meer artefacten teruggeven. De client‑agent houdt die taak bij terwijl hij de identiteit en autoriteit van de gebruiker of applicatie die de taak initieerde behoudt.
Een A2A‑interactie omvat meestal twee logische rollen:
- Client agent: de agent of applicatie die werk aanvraagt.
- Remote agent: de agent die het verzoek ontvangt en het werk uitvoert of coördineert.
Dezelfde agent kan in de ene context werk aanvragen en in een andere context een andere agent bedienen.
Agent‑kaarten: capaciteiten ontdekken
Voordat een taak wordt gedelegeerd, moet een client weten wat een remote agent kan doen en hoe ermee gecommuniceerd kan worden. A2A gebruikt een Agent‑Card om beschrijvende en operationele metadata te publiceren.
Een Agent‑Card kan de naam van een agent, endpoint, ondersteunde protocol‑features, authenticatie‑verwachtingen, vaardigheden en geaccepteerde content‑types beschrijven. Een vaardigheid is een gedeclareerd competentiegebied, zoals het vertalen van een document, het controleren van een contract, of het onderzoeken van een markt.
Ontdekking bewijst geen kwaliteit of betrouwbaarheid. Een Agent‑Card is een claim over capaciteit, geen onafhankelijke certificering. Productiesystemen hebben nog steeds identiteit, autorisatie, beleidscontroles, reputatie en evaluatie nodig.
Berichten, taken en artefacten
A2A vertegenwoordigt samenwerking via verschillende kernobjecten.
Berichten
Berichten dragen communicatie tussen agents. Ze kunnen tekst en andere gestructureerde delen bevatten, waardoor agents instructies, verduidelijkingen of contextueel materiaal kunnen uitwisselen.
Taken
Een taak vertegenwoordigt een eenheid werk waarvan de status in de loop van de tijd kan veranderen. Een remote agent kan het werk accepteren, de verwerking voortzetten, om meer input vragen, het voltooien, falen of annuleren. Een blijvende taakidentiteit is nuttig voor langdurige operaties omdat de client naar dezelfde taak kan verwijzen bij updates.
Artefacten
Artefacten zijn de outputs die door het werk worden geproduceerd, zoals een rapport, dataset, afbeelding, code‑patch of gestructureerde aanbeveling. Het scheiden van artefacten van conversatie‑berichten maakt het voor de client makkelijker om de uiteindelijke leveringen te identificeren en te gebruiken.
Hoe een A2A‑interactie werkt
| A2A | Coördineert werk en berichten tussen autonome agenten. |
|---|---|
| MCP | Verbindt een AI‑host met tools, bronnen en prompts. |
| Gedeelde behoefte | Identiteit, toegangsrechten met scope, gestructureerde berichten en controleerbare resultaten. |
| Fout | Een ontvangende agent vertrouwt een verzoek of artefact zonder de autoriteit of het bewijs te verifiëren. |
Stel je een reisplanningsagent voor die een specialist nodig heeft om inreisvereisten te verifiëren.
- De client ontdekt een externe agent en leest de Agent Card.
- Hij controleert of de agent de relevante mogelijkheid en een compatibele interactiemethode aanbiedt.
- De client authenticeert zich en stuurt een bericht met een beschrijving van de taak, reizigers, data en vereiste output.
- De externe agent maakt of werkt een taak bij en begint met werken.
- De externe agent kan voortgang streamen of om een ontbrekend detail vragen.
- De client levert de verduidelijking terwijl hij de taakcontext behoudt.
- De externe agent voltooit de taak en retourneert een gestructureerd artefact met het resultaat.
- De client evalueert dat resultaat voordat hij het gebruikt in het bredere reisplan.
De externe agent beslist hoe hij zijn opdracht uitvoert. Hij kan zijn eigen tools aanroepen, privégegevens raadplegen of extra agenten coördineren. A2A vereist niet dat die interne stappen worden onthuld.
A2A vs. MCP
De protocollen kunnen zich op verschillende lagen van dezelfde architectuur bevinden. Een reisplanningsagent zou een specialistische visum‑onderzoeksopdracht kunnen delegeren via A2A. Die specialistische agent zou vervolgens MCP‑verbindingen kunnen gebruiken om goedgekeurde databases te doorzoeken en beleidsdocumenten op te halen. A2A coördineert de verantwoordelijkheid tussen agenten; MCP standaardiseert de toegang tussen een AI-host en mogelijkheden.
A2A en het Model Context Protocol lossen verschillende integratieproblemen op.
- MCP verbindt een AI‑applicatie met tools en context. Een client ontdekt mogelijkheden zoals functies, bronnen en prompts van een MCP‑server.
- A2A verbindt agenten met agenten. Een client delegeert een doelgerichte taak aan een externe agent die zijn eigen proces kan beheren en een resultaat kan teruggeven.
Het verschil lijkt op het gebruik van een tool versus het inhuren van een specialist. Een rekenmachine toont een bewerking; een analist accepteert een doel en beslist welke bewerkingen nodig zijn. In echte systemen kan een externe A2A‑agent intern MCP gebruiken om zijn eigen tools en gegevens te bereiken.
A2A vs. gewone API’s
Een conventionele API is ideaal wanneer de aanroeper de exacte bewerking en invoerformaat kent: een record ophalen, een offerte berekenen of een veld bijwerken. A2A is nuttig wanneer het verzoek conversatiegericht, stateful, asynchroon of resultaatgericht is.
A2A vervangt niet elke API. Externe agenten roepen vaak gewone API’s aan om hun werk uit te voeren, en organisaties kunnen deterministische services direct blootstellen wanneer agentdiscretie geen meerwaarde biedt.
Waarom interoperabiliteit belangrijk is
Agent-ecosystemen zullen heterogeen zijn. Verschillende teams zullen optimaliseren voor verschillende domeinen, modellen, beveiligingsgrenzen en implementatieomgevingen. Een gedeeld protocol stelt organisaties in staat die specialisatie te behouden terwijl samenwerking mogelijk wordt gemaakt.
Interoperabiliteit kan ook de integratiekoppeling verminderen. Een client kan vertrouwen op een gedeclareerde vaardigheid en protocolgedrag in plaats van het framework van de externe agent te importeren of de interne logica te dupliceren. Het overzicht van het A2A-project beschrijft dit doel als het mogelijk maken dat agents die op verschillende stacks zijn gebouwd, als peers communiceren; de update van het project in 2026 over het toetreden tot de Agentic AI Foundation weerspiegelt de drang naar neutraal, brancheoverstijgend bestuur.
Beveiligings- en vertrouwensuitdagingen
Delegatie creëert een keten van verantwoordelijkheid. De client moet de identiteit en geadverteerde capaciteit van de externe agent verifiëren, de gedeelde context minimaliseren en de autorisatie van de initiërende gebruiker behouden. De externe agent mag niet automatisch brede privileges overnemen alleen omdat een andere agent de taak heeft aangevraagd. Elke stap vereist authenticatie, gescopeerde referenties, auditbaarheid en een duidelijke regel voor wat er gebeurt wanneer vereisten conflicteren of het vertrouwen laag is.
Agent-naar-agent delegatie creëert een autoriteitsketen. Een client kan per ongeluk gevoelige context delen, een externe agent meer discretie geven dan bedoeld, of handelen op een onbetrouwbaar artefact. De externe agent kan ook kwaadaardige instructies of bestanden ontvangen van een niet‑vertrouwde client.
Sterke implementaties hebben controles op meerdere lagen nodig:
- Identiteit en authenticatie: verifieer welke agent en organisatie deelnemen.
- Autorisatie: beperk de vaardigheden, gegevens, acties en taakomvang die beschikbaar zijn voor elke aanroeper.
- Dataminimalisatie: deel alleen de context die de externe agent nodig heeft.
- Herkomst: registreer wie het werk heeft aangevraagd, welke agent het heeft geproduceerd en welke bronnen het ondersteunen.
- Uitvoervalidatie: behandel externe artefacten als onbetrouwbaar totdat ze de relevante controles doorstaan.
- Delegatielimieten: beheers of een externe agent extra agents of services mag inschakelen.
- Menselijke goedkeuring: pauzeer vóór financiële, juridische, externe, destructieve of anderszins ingrijpende acties.
Protocolcompatibiliteit impliceert niet automatisch organisatorisch vertrouwen. Een agent kan A2A correct spreken en toch ongeschikt zijn voor een specifieke taak.
Wanneer zouden teams A2A moeten gebruiken?
A2A is het meest overtuigend wanneer onafhankelijke agents moeten samenwerken over product-, leverancier- of organisatorische grenzen heen; wanneer het werk langdurig is; of wanneer het ontvangende systeem de vrijheid moet behouden over hoe het resultaat wordt geproduceerd.
Het kan overbodig zijn voor een eenvoudige functie, een vaste interne workflow, of nauw gekoppelde componenten binnen één applicatie. In die gevallen kan een gewone API, event‑bus of directe tool‑aanroep makkelijker te beheren en te evalueren zijn.
Waar je aan moet denken over wat Agent2Agent (A2A) is
A2A biedt een gemeenschappelijke taal voor agents om mogelijkheden te ontdekken en doelgerichte werkzaamheden te coördineren zonder hun interne mechaniek te delen. De kernwaarde is niet dat meerdere agents automatisch beter zijn dan één, maar dat onafhankelijk gebouwde specialisten via een stabiele grens kunnen samenwerken.
Die grens moet meer dragen dan berichten. Het heeft identiteit, taakstatus, artefacten, permissies, herkomst en foutafhandeling nodig. A2A levert de protocolbasis; organisaties moeten nog steeds het vertrouwensmodel leveren.
