Google’s Agent2Agent-protocol (A2A): een gids met voorbeelden

AI-agents veranderen hoe taken worden geautomatiseerd, beslissingen worden genomen en softwaresystemen samenwerken. Maar naarmate organisaties meer autonome agents bouwen, wordt de behoefte aan gestandaardiseerde communicatie over leveranciers en frameworks heen essentieel. Daar komt Agent2Agent (A2A) in beeld.

A2A is een open, leveranciersneutraal protocol dat door Google is ontwikkeld om samenwerking tussen AI-agents in verschillende systemen te standaardiseren.

In deze tutorial neem ik je mee in hoe A2A werkt, de ontwerpprincipes, hoe het echte, multi-agent-workflows over domeinen heen kan aandrijven, en hoe het verschilt van MCP.

Wat is Agent 2 Agent (A2A)?

Agent2Agent (A2A) is een open protocol dat interoperabiliteit tussen ondoorzichtige (black-box) agents mogelijk maakt. Het stelt AI-agents in staat om:

• Elkaar te ontdekken
• Gestructureerde taken uit te wisselen
• Responses te streamen
• Meer-omslaggesprekken af te handelen
• Te werken met modaliteiten zoals tekst, afbeeldingen, video en data.

Ik leg het basisidee van A2A uit aan de hand van het onderstaande diagram:

In de afbeelding worden twee agents weergegeven: een Google Agent (in blauw) en een andere agent (in groen), waarschijnlijk van een externe service. Beide agents proberen twee soorten documenten of taken te verwerken. De groene agent slaagt in beide, wat te zien is aan de groene vinkjes, terwijl de Google-agent er één wel en één niet haalt.

Dit verschil toont de noodzaak van onderhandeling en informatie-uitwisseling aan, centrale onderdelen van het A2A-protocol.

Ontwerpprincipes van Agent2Agent

A2A is ontworpen rond vijf kernprincipes om taken voor eindgebruikers uit te voeren zonder geheugen, gedachten of tools te delen. Deze vijf principes zijn:

• Omarm agentische mogelijkheden: Agents werken samen zonder geheugen, tools of uitvoeringsplannen te delen.
• Gebouwd op open standaarden: A2A gebruikt HTTP, JSON-RPC en SSE om eenvoudige interoperabiliteit met bestaande techstacks te garanderen.
• Standaard veilig: Het volgt OpenAPI-authenticatieschema’s en biedt beveiliging op enterprise-niveau.
• Ondersteunt langlopende taken: A2A is ontworpen voor achtergrondtaken, human-in-the-loop-goedkeuringen en streaming updates.
• Modality-agnostisch: Het verwerkt afbeeldingen, audio, pdf’s, HTML, JSON en andere gestructureerde/ongestructureerde formats.

Deze ontwerpprincipes maken A2A tot de ruggengraat van schaalbare, enterprise-klare multi-agent-ecosystemen.

Hoe werkt A2A?

In deze sectie duiken we in de werking van het Agent2Agent-protocol en begrijpen we de architectuur en levenscyclus van agentcommunicatie. We verkennen de belangrijkste actoren, de transport- en authenticatielagen en ontdekking via Agent Cards.

Actoren en protocollen

Het A2A-protocol definieert drie kernactoren:

• Gebruiker: De eindgebruiker die een taak initieert.
• Clientagent: De aanvrager die namens de gebruiker een taak formuleert en verstuurt.
• Remote agent: De ontvangende agent die de taak uitvoert en resultaten terugstuurt.

Teruggaand naar ons diagram hierboven: de blauwe agent is de clientagent en de groene agent is de remote agent.

Agent cards en ontdekking

Agents publiceren hun metadata en mogelijkheden via een gestandaardiseerd JSON-document, een Agent Card, meestal gehost op /.well-known/agent.json. Deze card bevat:

• Naam, versie en hosting-URL
• Beschrijving en serviceprovider
• Ondersteunde input/output-modaliteiten en contenttypen
• Authenticatiemethoden 
• Lijst met agentskills met tags en voorbeelden

De ontdekking kan verlopen via DNS, registers, marktplaatsen of private catalogi.

Kernobjecten voor communicatie

Het hart van A2A-communicatie is de Task, een gestructureerd object dat een atomaire eenheid van werk vertegenwoordigt. Taken hebben levenscyclusstaten zoals ingediend, bezig, invoer-vereist of voltooid.

Elke Task bevat:

• Messages: Deze worden gebruikt voor conversatie-uitwisselingen tussen de client en de remote agent
• Artifacts: Voor onveranderlijke resultaten die door de remote agent zijn gemaakt.
• Parts: Zelfstandige datablocks binnen messages of artifacts, zoals platte tekst, bestandsblobs of JSON.

A2A-workflowvoorbeeld

Zo werkt A2A in een voorbeeldworkflow:

1. Gebruiker start een taak: De gebruiker stuurt een verzoek naar een clientagent, bijvoorbeeld: “Plan een laptopvervanging.”
2. Clientagent ontdekt een remote agent: De clientagent zoekt andere capabele agents op met behulp van een Agent Card die gehost is op een publieke of private URL. Dit JSON-bestand bevat skills, ondersteunde modaliteiten, authenticatie en de service-URL.
3. Clientagent verstuurt een Task: De clientagent stuurt een task/send-verzoek naar de geselecteerde remote agent, met JSON-RPC 2.0 over HTTP. De payload bevat:
• Een taak-ID
• Een sessie-ID (optioneel)
• Een bericht met één of meer parts (bijv. tekst, bestand, JSON)
4. Remote agent reageert: De remote agent verwerkt de taak en reageert met:
• Directe resultaten (via artifact)
• Tussentijdse berichten (via message)
• Of vraagt meer info (zet de status op input-required)
5. Streaming en push-updates (indien async): Als de taak lang duurt, kan de remote agent gedeeltelijke resultaten terugstreamen via Server-Sent Events (SSE). Als de client de verbinding verbreekt, kunnen pushmeldingen worden gestuurd naar een beveiligde webhook van de client.
6. Statusovergangen van de taak: De taak doorloopt de staten: submitted → working → input-required → completed. Op elk moment kan de agent updates of nieuwe artifacts naar de client sturen.
7. Artifacts en messages: Messages worden gebruikt voor communicatie of verduidelijking (bijv. “Upload je bonnetjes, alsjeblieft.”), terwijl artifacts worden gebruikt voor het tonen van eindoutputs zoals een rapport-pdf, analysesamenvatting, JSON-lijst, enz.
8. Clientagent gaat verder of rondt de taak af: Als invoer nodig is, verzamelt de clientagent die van de gebruiker en stuurt een vervolg-task/send. Zodra de taak voltooid is, kan de client alle artifacts ophalen met task/get.

A2A-voorbeeld: IT-helpdeskticket oplossen

Stel je een enterprise IT-helpdesksysteem voor dat AI-agents gebruikt om supporttickets autonoom te beheren en op te lossen. In deze setup ontvangt een gebruikersagent een verzoek zoals:

“My laptop isn’t turning on after the last software update.”

De gebruikersagent orkestreert vervolgens een oplossingsworkflow door via A2A samen te werken met meerdere remote agents.

Zo interacteren agents via A2A in bovenstaande scenario:

• De clientagent stuurt een taak naar de Hardware Diagnostic Agent met het verzoek om een apparaatcontrole.
• Als de hardware in orde is, wordt het geëscaleerd naar de Software Rollback Agent, die recente updates evalueert.
• Als terugdraaien mislukt, wordt de Device Replacement Agent ingeschakeld om een hardware-omruiling te starten.

Elke agent werkt onafhankelijk, publiceert een Agent Card met zijn mogelijkheden en communiceert asynchroon via gestructureerde Tasks. De agents kunnen:

• Logs of diagnostiek streamen als artifacts
• De flow pauzeren als gebruikersinvoer nodig is
• Push-updates sturen zodra hun onderdeel klaar is

Dit is een puur A2A-usecase, omdat:

• Er geen gestructureerde tools zoals API’s of OCR-engines worden gebruikt
• Alle coördinatie plaatsvindt tussen ondoorzichtige, samenwerkende agents
• Agents optreden als gelijken met individuele beslislogica en eigen modality-afhandeling

A2A vs MCP: wanneer gebruik je wat?

A2A en MCP lossen verschillende maar complementaire uitdagingen op in agentische systemen. Terwijl A2A zich richt op het laten samenwerken van agents als autonome gelijken, is het Model Context Protocol (MCP) bedoeld om agents te verbinden met gestructureerde tools en externe bronnen.

Waarom hebben we zowel A2A als MCP nodig?

Protocollen creëren standaarden voor interoperabiliteit. In de agentische wereld zijn twee typen interoperabiliteit cruciaal:

• Tool-interoperabiliteit (MCP): Agents die gestructureerde functies, API’s of tools aanroepen.
• Agent-interoperabiliteit (A2A): Agents die samenwerken in natuurlijke taal of gemengde modaliteiten.

Voorbeeld: Workflow voor leninggoedkeuring

Stel je een multi-agent-systeem voor dat leninggoedkeuringen voor een financiële instelling automatiseert.

Zo werken A2A en MCP samen in dit scenario:

Stap 1: Voorbewerking van de aanvraag via tools en API’s (MCP)

Een LoanProcessor-agent ontvangt een leningsaanvraag van de gebruiker. Deze gebruikt MCP om:

• Een kredietscore-API aan te roepen
• Vervolgens de banktransactiegeschiedenis op te halen uit een beveiligde gegevensbron
• Tot slot geüploade documenten te valideren met OCR

Stap 2: Multi-agent-coördinatie voor de eindbeslissing (A2A)

Op basis van de gestructureerde data uit stap 1 gebruikt de agent A2A om:

• Samen te werken met een RiskAssessmentAgent om het kredietrisico van de aanvrager te beoordelen

• Vervolgens een ComplianceAgent te raadplegen om te waarborgen dat de lening aan wettelijke en regelgevende eisen voldoet

• Bij goedkeuring over te dragen aan een DisbursementAgent om de uitbetaling te plannen.

Conclusie

Agent2Agent (A2A) is de ontbrekende schakel in grootschalige multi-agent-systemen. Met duidelijke agentgrenzen, gestructureerde taakgebaseerde communicatie en ingebouwde ondersteuning voor streaming en push maakt het modulaire, vindbare en schaalbare agentecosystemen mogelijk.

A2A is ontworpen voor de behoeften van echte bedrijven en is veilig, async, modality-flexibel en leveranciersagnostisch. Of je nu Google’s ADK, LangGraph, CrewAI of je eigen framework gebruikt: A2A helpt je agents met agents praten.

Wil je meer leren over AI-agents? Ik raad deze blogs aan:

• CrewAI: een gids met voorbeelden van multi-AI-agentsystemen
• Agentic AI: hoe het werkt, voordelen, vergelijking met traditionele AI