Wat is Google's A2A Protocol? Agent-naar-Agent communicatie uitgelegd

In april 2025 introduceerde Google het Agent2Agent Protocol (A2A), een open standaard waarmee AI-agents andere AI-agents kunnen ontdekken, ermee communiceren en taken aan hen delegeren. MCP geeft agents hun tools. A2A geeft ze collega's. Geïsoleerde AI-assistenten worden samenwerkende multi-agentsystemen die complexe bedrijfsworkflows aankunnen.

Wat is het A2A Protocol?

Het Agent2Agent Protocol (A2A) is een open communicatieprotocol waarmee AI-agents met elkaar kunnen praten, ongeacht het framework of de leverancier die ze heeft gebouwd. Zie het als een gemeenschappelijke taal voor AI-agents. Een Salesforce-agent kan een SAP-agent vragen om voorraad te controleren, een reisboeking-agent kan coördineren met een betalingsagent, zonder dat ze elkaars interne architectuur hoeven te kennen.

Vóór A2A waren multi-agentsystemen grotendeels proprietary. Bouwde je agents in LangChain, dan konden ze praten met andere LangChain-agents. Maar niet met agents in Google's ADK of Amazon Bedrock. A2A doorbreekt die silo's met een leveranciersneutraal protocol, gebouwd op bestaande webstandaarden: HTTPS voor transport, JSON-RPC 2.0 voor berichten, en Server-Sent Events (SSE) voor streaming.

Waarom A2A belangrijk is

Enterprise software zit vol gespecialiseerde systemen: CRM, ERP, HR, finance, supply chain. Elk steeds vaker aangestuurd door AI-agents. Het probleem: die agents werken in isolatie. Een klantenservice-agent kan een bestelling opzoeken, maar kan de logistieke agent niet vragen naar real-time verzendstatus. Een inkoopagent vindt leveranciers, maar kan niet coördineren met de financiële agent voor budgetgoedkeuring.

A2A lost dit op met een standaardmanier waarop agents:

• Elkaar ontdekken via Agent Cards, machineleesbare JSON-bestanden die beschrijven wat een agent kan
• Taken delegeren met een duidelijk gedefinieerde levenscyclus (submitted, working, completed, failed)
• Rijke content uitwisselen inclusief tekst, bestanden en gestructureerde data
• Updates streamen in real time voor langlopende operaties
• Authenticatie onderhandelen voordat er data wordt uitgewisseld

Gary Lerhaupt van Salesforce zei het zo: "De toekomst van enterprise AI ligt in agent-to-agent-samenwerking" voor het orkestreren van losgekoppelde systemen. A2A maakt die samenwerking mogelijk zonder vendor lock-in.

De Agent Card: het visitekaartje van je agent

De kern van A2A is de Agent Card , een JSON-document op een well-known URL dat alles beschrijft wat een client-agent moet weten voordat die met jouw agent praat. Letterlijk een machineleesbaar visitekaartje voor AI-agents.

De Agent Card wordt gehost op /.well-known/agent-card.json (eerdere versies van de specificatie gebruikten /.well-known/agent.json). De kaart bevat:

• Identiteit: Naam, beschrijving, provider en versie
• Service URL: Het endpoint waar de agent taken accepteert
• Mogelijkheden: Of de agent streaming, push-notificaties of uitgebreide kaarten ondersteunt
• Vaardigheden: Specifieke taken die de agent kan uitvoeren, met input/output-types
• Authenticatie: Vereiste beveiligingsschema's (API key, OAuth 2.0, OpenID Connect, Mutual TLS)
• Input/Output-modi: Ondersteunde MIME-types voor communicatie

Zo ziet een echte Agent Card eruit:

{
  "name": "Acme Inventory Agent",
  "description": "Real-time inventory lookup and availability checking for Acme Corp products.",
  "url": "https://agents.acme.com/inventory",
  "provider": {
    "organization": "Acme Corp",
    "url": "https://acme.com"
  },
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "securitySchemes": {
    "oauth2": {
      "type": "oauth2",
      "flows": {
        "clientCredentials": {
          "tokenUrl": "https://auth.acme.com/token",
          "scopes": {
            "inventory:read": "Read inventory levels"
          }
        }
      }
    }
  },
  "security": [{ "oauth2": ["inventory:read"] }],
  "defaultInputModes": ["application/json", "text/plain"],
  "defaultOutputModes": ["application/json", "text/plain"],
  "skills": [
    {
      "id": "check-availability",
      "name": "Check Product Availability",
      "description": "Check real-time stock levels for a given SKU across all warehouses.",
      "inputModes": ["application/json"],
      "outputModes": ["application/json"]
    },
    {
      "id": "reserve-stock",
      "name": "Reserve Inventory",
      "description": "Place a temporary hold on inventory for a pending order.",
      "inputModes": ["application/json"],
      "outputModes": ["application/json"]
    }
  ]
}

Hoe A2A werkt: de taaklevenscyclus

A2A-communicatie werkt in drie stappen: ontdekken, authenticeren en communiceren. De client-agent vindt via de Agent Card een geschikte remote agent, authenticeert zich, en stuurt dan taken via een duidelijk gedefinieerde levenscyclus.

Stap 1: Ontdekking

De client-agent haalt de Agent Card op van de well-known URL van de remote agent. Die inspecteert de vaardigheden, mogelijkheden en authenticatievereisten om te bepalen of deze agent kan helpen bij de huidige taak.

Stap 2: Authenticatie

Op basis van de beveiligingsschema's in de Agent Card authenticeert de client zich. A2A ondersteunt dezelfde beveiligingsschema's als de OpenAPI-specificatie:

• API Key: eenvoudige token-gebaseerde authenticatie
• HTTP Bearer: JWT of opaque tokens
• OAuth 2.0: Authorization Code, Client Credentials of Device Code flows
• OpenID Connect: identiteitslaag-authenticatie
• Mutual TLS: certificaat-gebaseerde wederzijdse authenticatie

Stap 3: Taakuitvoering

De client stuurt een bericht naar de remote agent, die een Task aanmaakt. Dat is de centrale werkeenheid in A2A. Elke taak heeft een uniek ID en doorloopt duidelijk gedefinieerde statussen:

Taken produceren Artifacts: tastbare outputs zoals documenten, datapayloads of bestanden. Elk artifact en bericht bestaat uit Parts. TextPart voor platte tekst, FilePart voor binaire data, DataPart voor gestructureerde JSON.

Real-time updates: streaming en push-notificaties

Voor langlopende taken ondersteunt A2A twee mechanismen voor real-time updates:

• Streaming via SSE: De client opent een persistente verbinding en ontvangt incrementele updates naarmate de taak vordert. De SendStreamingMessage methode levert statuswijzigingen en gedeeltelijke artifacts in real time.
• Push-notificaties via Webhooks: Voor asynchrone workflows registreert de client een webhook-URL. De remote agent POST statusupdates (TaskStatusUpdateEvent) en artifact-leveringen (TaskArtifactUpdateEvent) naar dit endpoint.

Transportprotocollen

A2A v0.3 ondersteunt drie transportbindingen. Welke je kiest hangt af van je infrastructuur:

gRPC kwam erbij in v0.3. Een binaire transportoptie voor high-performance agentcommunicatie met lagere latency en kleinere payloads, handig voor gedistribueerde enterprise-systemen.

A2A vs MCP: complementair, niet concurrerend

De vraag die ik het vaakst krijg over A2A: hoe verhoudt het zich tot Anthropic's Model Context Protocol (MCP) ? Kort antwoord: ze lossen verschillende problemen op en zijn ontworpen om samen te werken.

Het verschil in een zin: MCP verbindt een agent met tools en databronnen (databases, API's, bestandssystemen). A2A verbindt agents met andere agents voor taakdelegatie en samenwerking.

Een praktijkvoorbeeld: een inkoopworkflow. De inkoopagent gebruikt MCP om interne databases te bevragen voor inkoophistorie en budgetdata. Diezelfde agent gebruikt A2A om prijsvergelijking te delegeren aan een externe leveranciersagent en budgetgoedkeuring aan te vragen bij een financiële agent. MCP voor de verticale integratie met tools, A2A voor de horizontale samenwerking tussen agents.

Wie staat achter A2A?

A2A heeft snel enterprise-ondersteuning gekregen sinds de lancering in april 2025. De tijdlijn:

• 9 april 2025: Google kondigt A2A aan met meer dan 50 technologiepartners
• 23 juni 2025: Google doneert A2A aan de Linux Foundation voor leveranciersneutrale governance
• 31 juli 2025: A2A v0.3 uitgebracht met gRPC-ondersteuning, ondertekende Agent Cards en verbeterde Python SDK
• Q3-Q4 2025: Meer dan 150 organisaties ondersteunen nu het protocol

Linux Foundation Governance

Met de oprichting van het Agent2Agent-project onder de Linux Foundation ging A2A van een door Google geleid initiatief naar een leveranciersneutrale standaard. De oprichtende leden:

Naast de oprichtende leden wordt A2A ondersteund door grote technologiebedrijven (Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, UKG, Workday) en wereldwijde adviesbureaus (Accenture, BCG, Capgemini, Cognizant, Deloitte, HCLTech, Infosys, KPMG, McKinsey, PwC, TCS, Wipro).

Huidige adoptie en implementaties in de praktijk

Grote platformen integreren A2A al in hun agent-ecosystemen:

• Salesforce Agentforce: Integreert A2A om AI-agents te laten samenwerken met agents van andere platformen
• SAP Joule: Werkt samen aan A2A om de enterprise AI-assistent te verbinden met externe agent-ecosystemen
• ServiceNow Agent Control Tower: Bouwt A2A-ondersteuning in het agent-orkestratieplatform voor cross-platform workflows
• Google ADK: A2A-ondersteuning is direct ingebouwd in Google's Agent Development Kit, zodat elke ADK-gebouwde agent native A2A spreekt
• Amazon Bedrock AgentCore: AWS heeft A2A gedocumenteerd als een ondersteund protocolcontract voor Bedrock-agents

Het protocol heeft ook SDK's en referentie-implementaties beschikbaar in Python en Java (met een Quarkus-integratie), waardoor het toegankelijk is voor de meeste enterprise-ontwikkelteams.

Hoe A2A te implementeren

A2A implementeren hangt af van of je een agent aanbiedt (server) of agents consumeert (client). Hier het meest voorkomende scenario: je AI-agent vindbaar en aanroepbaar maken voor andere agents.

Stap 1: Maak je Agent Card

Host een JSON-bestand op /.well-known/agent-card.json op je domein. Dit is het startpunt voor agent-ontdekking:

{
  "name": "Your Agent Name",
  "description": "Clear, concise description of what your agent does.",
  "url": "https://yourdomain.com/a2a",
  "provider": {
    "organization": "Your Company",
    "url": "https://yourdomain.com"
  },
  "version": "1.0.0",
  "capabilities": {
    "streaming": false,
    "pushNotifications": false
  },
  "securitySchemes": {
    "apiKey": {
      "type": "apiKey",
      "in": "header",
      "name": "X-API-Key"
    }
  },
  "security": [{ "apiKey": [] }],
  "defaultInputModes": ["application/json"],
  "defaultOutputModes": ["application/json"],
  "skills": [
    {
      "id": "your-skill-id",
      "name": "Human-Readable Skill Name",
      "description": "What this skill does and when to use it."
    }
  ]
}

Stap 2: Implementeer de A2A-endpoints

Je A2A-server moet minimaal deze JSON-RPC-methoden afhandelen:

• message/send: Ontvang een bericht van een client-agent en maak een taak aan of werk deze bij
• tasks/get: Retourneer de huidige status van een taak op basis van ID
• tasks/cancel: Annuleer een lopende taak

Optionele methoden voor uitgebreide functionaliteit:

• message/stream: Stream real-time updates via SSE
• tasks/list: Lijst taken op voor een bepaalde context
• tasks/pushNotification/*: Beheer webhook-abonnementen

Stap 3: Beheer de taaklevenscyclus

Wanneer een client een bericht stuurt, moet je server:

1. Authenticatie valideren tegen je gedeclareerde beveiligingsschema's
2. Een nieuwe Task aanmaken met status WORKING
3. Het verzoek verwerken. Als je meer informatie nodig hebt, stel de status in op INPUT_REQUIRED
4. Artifacts genereren (je output) en de status instellen op COMPLETED
5. Als er iets misgaat, stel de status in op FAILED met een beschrijvende foutmelding

{
  "jsonrpc": "2.0",
  "id": "req-001",
  "method": "message/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [
        {
          "kind": "text",
          "text": "Check availability for SKU-7890 in the EU warehouse"
        }
      ]
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": "req-001",
  "result": {
    "id": "task-abc-123",
    "status": {
      "state": "completed"
    },
    "artifacts": [
      {
        "parts": [
          {
            "kind": "data",
            "data": {
              "sku": "SKU-7890",
              "warehouse": "EU-AMS",
              "available": 342,
              "reserved": 18
            }
          }
        ]
      }
    ]
  }
}

Wat het implementeren van A2A betekent voor je website

A2A-ondersteuning implementeren levert zowel directe als strategische voordelen op:

IsAgentReady controleert op de aanwezigheid van een A2A Agent Card als onderdeel van de Agent Protocols -categorie (15% van je totaalscore). Een geldige Agent Card op /.well-known/agent-card.json verbetert direct je AI-agentgereedheidsscore.

Wie zou A2A moeten implementeren?

A2A is niet voor elke website. Het is specifiek voor diensten die mogelijkheden hebben die andere agents willen gebruiken. Overweeg A2A als je bent:

• SaaS-platformen met API's waarmee andere systemen integreren (CRM, ERP, HR, e-commerce)
• API-providers die data of diensten aanbieden die AI-agents kunnen consumeren (weer, betalingen, verzending, identiteitsverificatie)
• AI-servicebedrijven die gespecialiseerde agents bouwen die moeten samenwerken met andere agents
• Enterprise-softwareleveranciers wier producten deel uitmaken van grotere bedrijfsworkflows
• Marktplaatsoperators waar meerdere partijen gecoördineerde interacties nodig hebben

Is je website voornamelijk informatief (blog, portfolio, marketingsite), dan is A2A minder relevant. Richt je dan op de andere AI-gereedheidscategorieën, zoals gestructureerde data, semantische HTML en content-ontdekking .

Beveiligingsoverwegingen

A2A is ontworpen met enterprise-beveiliging in het achterhoofd. De belangrijkste kenmerken:

• Opaque agents: Agents exposeren nooit hun interne logica, geheugen of proprietary implementaties. Ze delen alleen wat er in de Agent Card is gedeclareerd.
• Ondertekende Agent Cards: Vanaf v0.3 kunnen Agent Cards cryptografisch worden ondertekend met JWS (RFC 7515), waardoor clients de identiteit van de agent en de integriteit van de kaart kunnen verifiëren voordat ze verbinding maken.
• Standaard auth-schema's: A2A sluit aan bij OpenAPI-beveiligingsschema's, zodat bedrijven hun bestaande OAuth 2.0- en OIDC-infrastructuur kunnen gebruiken.
• Zero-trust-compatibel: Het protocol ondersteunt mutual TLS en kan worden geïntegreerd met enterprise zero-trust-architecturen.
• Toegangscontrole op taakniveau: Elke vaardigheid kan zijn eigen beveiligingsvereisten declareren, waardoor fijnmazige rechten mogelijk zijn.

Tijdlijn en roadmap

A2A beweegt snel. Van concept naar enterprise-standaard:

Het protocol is nog in ontwikkeling. Verwachte verbeteringen: formele opname van autorisatieschema's in Agent Cards, dynamische validatiemethoden voor vaardigheden, en ondersteuning voor dynamische UX-onderhandeling (audio/video midden in een gesprek toevoegen).

Vandaag beginnen

Klaar voor een volledige A2A-implementatie, of gewoon aan het verkennen? Praktische vervolgstappen:

1. Publiceer een Agent Card: Begin met een minimale /.well-known/agent-card.json die je dienst en mogelijkheden beschrijft. Zelfs zonder backend-endpoints maakt dit je agent vindbaar.
2. Scan je website: Gebruik IsAgentReady om te zien hoe je site scoort op ondersteuning van agentprotocollen.
3. Verken de specificatie: De officiële A2A-specificatie is goed gedocumenteerd en bevat transportbindingdetails voor JSON-RPC, gRPC en REST.
4. Probeer de SDK: Google biedt Python- en Java-SDK's met voorbeeldimplementaties. Bekijk de A2A GitHub-repository voor quickstarts.
5. Lees de Agent Card-specificatie: Begrijp alle verplichte en optionele velden om je Agent Card zo compleet mogelijk te maken.

Conclusie

A2A standaardiseert hoe AI-agents samenwerken. Het definieert een agent-web: een netwerk waarin AI-agents elkaar ontdekken, authenticeren en taken aan elkaar delegeren over organisatiegrenzen heen.

Met de steun van de Linux Foundation, oprichtende leden zoals Google, AWS, Microsoft, Salesforce, SAP en ServiceNow, en meer dan 150 organisaties erachter, is A2A op weg om de standaard te worden voor enterprise-agent-interoperabiliteit. Multi-agent-samenwerking wordt de norm. De vraag is of jouw diensten deel uitmaken van dat ecosysteem wanneer het zover is.

Bronnen

• A2A Protocol Specification - Officiële protocolspecificatie met volledige technische details
• Announcing the Agent2Agent Protocol (A2A) - Google's originele aankondigingsblogpost (april 2025)
• Agent2Agent Protocol is Getting an Upgrade - Google Cloud-blog over verbeteringen in v0.3
• Linux Foundation Launches the Agent2Agent Protocol Project - Aankondiging van Linux Foundation-governance
• A2A GitHub Repository - Open source code, SDK's en voorbeeldimplementaties
• What Is Agent2Agent (A2A) Protocol? - Technisch overzicht van IBM
• MCP vs A2A: A Guide to AI Agent Communication Protocols - Auth0's vergelijking van de twee protocollen
• What's New with Agents: ADK, Agent Engine, and A2A Enhancements - Google I/O-updates
• Google Upgrades Agent2Agent Protocol with gRPC and Enterprise-Grade Security - InfoWorld-analyse van v0.3
• Google Advances A2A Protocol, Gains Microsoft and SAP Backing - Cloud Wars-coverage van enterprise-adoptie