A2A Protocol: de toekomst van agent-to-agent communicatie

Wat is het A2A Protocol?

Het Agent-to-Agent (A2A) protocol is een open standaard die is geinitieerd door Google en ondersteund wordt door een groeiende coalitie van technologiebedrijven. Het protocol definieert een gestandaardiseerde manier waarop AI-agents met elkaar kunnen communiceren, taken kunnen delegeren en resultaten kunnen uitwisselen. Denk aan A2A als het HTTP van de AI-agentwereld: een universele taal die het mogelijk maakt dat agents van verschillende aanbieders naadloos samenwerken. Dit staat in direct verband met het Model Context Protocol (MCP), dat de interactie definieert tussen een model en lokale tools.

Waarom is dit relevant voor website-eigenaren? Omdat het web in toenemende mate niet alleen door mensen wordt bezocht, maar ook door autonome AI-agents die namens gebruikers taken uitvoeren. Een AI-agent die een vlucht boekt, vergelijkt daarbij mogelijk informatie van tientallen websites. Het A2A protocol bepaalt hoe deze agents zich identificeren, wat ze kunnen en hoe ze informatie uitwisselen.

De Agent Card: je digitale visitekaartje

Het hart van het A2A protocol is de Agent Card: een JSON-document dat beschrijft wie een agent is, wat deze kan en hoe je ermee communiceert. Elke A2A-compatibele agent publiceert een Agent Card op een voorspelbare locatie, vergelijkbaar met hoe robots.txt — bibliotheekterm werkt voor webcrawlers.

De Agent Card bevat metadata over de agent (naam, beschrijving, aanbieder), een lijst van capabilities (welke taken de agent kan uitvoeren), skills (specifieke vaardigheden) en endpoint-definities (hoe je de agent kunt bereiken). Dit discovery-mechanisme is vergelijkbaar met hoe robots.txt en llms.txt werken voor respectievelijk crawlers en taalmodellen.

// Voorbeeld Agent Card (/.well-known/agent.json)
{
  "name": "Kobalt AEO Scanner Agent",
  "description": "Analyseert websites op AI-gereedheid en genereert optimalisatierapporten",
  "url": "https://aeo-expert.nl/api/a2a",
  "version": "1.0.0",
  "provider": {
    "organization": "Kobalt",
    "url": "https://www.kobaltdigital.nl"
  },
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "authentication": {
    "schemes": ["Bearer"]
  },
  "defaultInputModes": ["text/plain", "application/json"],
  "defaultOutputModes": ["application/json", "text/html"],
  "skills": [
    {
      "id": "scan-website",
      "name": "Website AEO Scan",
      "description": "Voert een volledige AEO- en Agent-Readiness scan uit op een URL",
      "tags": ["aeo", "seo", "ai-readiness", "website-analyse"],
      "examples": [
        "Scan https://example.com op AI-gereedheid",
        "Geef een AEO-rapport voor mijn website"
      ]
    },
    {
      "id": "check-schema",
      "name": "Schema.org Validator",
      "description": "Controleert en valideert Schema.org markup op een pagina",
      "tags": ["schema-org", "structured-data", "validatie"],
      "examples": [
        "Valideer de Schema.org markup op https://example.com"
      ]
    }
  ]
}

Hoe A2A-communicatie werkt

Het A2A protocol definieert een gestandaardiseerde communicatieflow die uit drie fasen bestaat.

Fase 1: Discovery

Een client-agent ontdekt beschikbare agents door hun Agent Cards op te halen. De cards worden gepubliceerd op /.well-known/agent.json, een conventie die vergelijkbaar is met /.well-known/openid-configuration voor OAuth. De client-agent leest de skills en capabilities om te bepalen welke agent geschikt is voor de gevraagde taak.

Fase 2: Task Execution

Zodra een geschikte agent is gevonden, stuurt de client-agent een taakverzoek naar het endpoint van de server-agent. Het A2A protocol gebruikt een JSON-RPC achtig berichtenformaat met ondersteuning voor streaming, waardoor langlopende taken (zoals een uitgebreide website-scan) tussentijdse updates kunnen sturen.

Taken doorlopen gedefinieerde statussen: submitted, working, input-required, completed en failed. Deze statemachine zorgt ervoor dat beide agents altijd weten in welke fase de taak zich bevindt, zelfs bij netwerkonderbrekingen.

Fase 3: Response

Na voltooiing van de taak stuurt de server-agent het resultaat terug in een van de geconfigureerde output-modes. Dit kan gestructureerde JSON zijn, maar ook HTML of plain text. De client-agent verwerkt het resultaat en presenteert het aan de eindgebruiker of gebruikt het als input voor een volgende stap.

Praktijkvoorbeeld: een volledige A2A flow

Laten we een concreet voorbeeld doorlopen. Een gebruiker vraagt een persoonlijke AI-assistent om zijn website te laten scannen op AI-gereedheid. De assistent (client-agent) zoekt een geschikte scanner-agent via discovery, stuurt een taakverzoek, en ontvangt het scanrapport.

// Stap 1: Client-agent haalt Agent Card op
GET https://aeo-expert.nl/.well-known/agent.json

// Stap 2: Client-agent stuurt taakverzoek
POST https://aeo-expert.nl/api/a2a
Content-Type: application/json
Authorization: Bearer 

{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "params": {
    "id": "task-abc-123",
    "message": {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "Scan https://example.com op AI-gereedheid"
        }
      ]
    }
  }
}

// Stap 3: Server-agent stuurt statusupdates (via streaming)
{"jsonrpc": "2.0", "result": {"id": "task-abc-123", "status": {"state": "working", "message": "Bezig met scannen..."}}}
{"jsonrpc": "2.0", "result": {"id": "task-abc-123", "status": {"state": "working", "message": "Schema.org analyse..."}}}

// Stap 4: Server-agent stuurt eindresultaat
{"jsonrpc": "2.0", "result": {"id": "task-abc-123", "status": {"state": "completed"}, "artifacts": [{"parts": [{"type": "text", "text": "AEO Score: 72/100..."}]}]}}

De impact op websites en content

De opkomst van agent-to-agent communicatie heeft directe gevolgen voor hoe websites worden gebouwd en geoptimaliseerd. AI-agents zijn geen passieve consumenten van content: ze voeren actief taken uit en hebben gestructureerde, machine-leesbare informatie nodig.

• Gestructureerde API's worden belangrijker dan ooit. Agents communiceren bij voorkeur via JSON en gedefinieerde endpoints, niet via het scrapen van HTML.
• Machine-leesbare metadata (Schema.org — bibliotheekterm, OpenAPI specs, Agent Cards) wordt de standaard manier waarop agents je diensten ontdekken.
• Authenticatie en autorisatie moeten agent-compatibel zijn. OAuth 2.0 met scoped tokens is het minimum.
• Content moet niet alleen leesbaar zijn voor mensen, maar ook interpreteerbaar voor agents die namens mensen handelen.
• Rate limiting en abuse protection moeten rekening houden met legitimate agent-verkeer naast menselijk verkeer.

A2A versus MCP: wanneer gebruik je wat?

Een veelgestelde vraag is hoe A2A zich verhoudt tot het Model Context Protocol (MCP). Het korte antwoord: ze zijn complementair en vullen elkaar aan. MCP is ontworpen voor de interactie tussen een AI-model en lokale tools of databronnen. A2A is ontworpen voor communicatie tussen twee of meer remote agents over het netwerk.

// Vergelijking A2A vs MCP

// A2A: Remote agent-to-agent communicatie
// - Agent ontdekt andere agents via /.well-known/agent.json
// - Taken worden gedelegeerd via JSON-RPC over HTTPS
// - Ondersteunt streaming en langlopende taken
// - Focus: multi-agent orkestratie

// MCP: Lokale model-to-tool communicatie
// - Model ontdekt tools via capabilities handshake
// - Tools worden lokaal aangeroepen via gestandaardiseerde interface
// - Focus: uitbreiding van modelcapaciteiten met externe tools

// Praktijkscenario: beide protocollen samen
// 1. Gebruiker vraagt AI-assistent om websiteanalyse
// 2. Assistent gebruikt MCP om lokale tools aan te roepen
//    (bijv. browser-tool voor screenshot)
// 3. Assistent gebruikt A2A om remote scanner-agent
//    aan te roepen voor diepgaande analyse
// 4. Resultaten worden gecombineerd en gepresenteerd

Je website voorbereiden op A2A

Hoewel het A2A protocol nog in ontwikkeling is, kun je nu al stappen nemen om je website klaar te maken voor een wereld waarin AI-agents een steeds grotere rol spelen.

1. Implementeer robuuste Schema.org markup op al je pagina's. Dit is de basis waarop agents je content ontdekken en begrijpen.
2. Bied een API aan voor je belangrijkste functionaliteit. Als je een dienst aanbiedt die agents kunnen gebruiken, maak deze dan beschikbaar via een gedocumenteerde REST of GraphQL API.
3. Publiceer een OpenAPI specificatie voor je API. Dit stelt agents in staat om automatisch te begrijpen welke endpoints beschikbaar zijn en welke parameters ze accepteren.
4. Overweeg een Agent Card te publiceren als je diensten aanbiedt die relevant zijn voor AI-agents. Zelfs als het protocol nog niet breed geadopteerd is, positioneer je jezelf als early adopter.
5. Zorg voor goede authenticatie en autorisatie. Implementeer OAuth 2.0 met duidelijke scopes zodat agents veilig namens gebruikers kunnen handelen.
6. Monitor je server logs op agent-verkeer. Begin patronen te herkennen in hoe AI-agents je site benaderen en optimaliseer daarop.

Een minimale Agent Card publiceren

Je hoeft geen volledig A2A-endpoint te bouwen om te beginnen. Een minimale Agent Card op /.well-known/agent.json maakt je al vindbaar voor agents die het web scannen op beschikbare diensten.

// Minimale Agent Card voor een informatie-website
// Publiceer op: /.well-known/agent.json
{
  "name": "Jouw Bedrijf",
  "description": "Informatie over [jouw diensten/producten]",
  "url": "https://jouwdomein.nl",
  "version": "0.1.0",
  "provider": {
    "organization": "Jouw Bedrijf B.V.",
    "url": "https://jouwdomein.nl"
  },
  "capabilities": {
    "streaming": false,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "company-info",
      "name": "Bedrijfsinformatie",
      "description": "Biedt informatie over onze diensten en expertise",
      "tags": ["info", "diensten"]
    }
  ]
}

A2A in het bredere protocol-landschap

Het A2A protocol staat niet op zichzelf. Het maakt deel uit van een groter ecosysteem van standaarden die samen de toekomst van AI op het web vormgeven. Model Context Protocol (MCP) van Anthropic definieert hoe AI-modellen lokale tools en databronnen gebruiken. OAuth discovery definieert authenticatie voor agents. De llms.txt standaard geeft instructies aan AI-crawlers. En robots.txt blijft de fundamentele laag voor crawlbeheer.

Samen vormen deze protocollen de infrastructuur van het agentic web: een web waarin niet alleen mensen, maar ook AI-agents actieve deelnemers zijn. Voor website-eigenaren is de boodschap helder: wie vroeg investeert in deze protocollen, bouwt een voorsprong op die moeilijk in te halen is wanneer agent-to-agent communicatie mainstream wordt.

Wil je een overzicht van hoe al deze protocollen samen je AI-zichtbaarheid bepalen? Begin met ons introductie-artikel over AEO dat de complete strategie beschrijft.

Samenvatting: de belangrijkste punten

• A2A is een open standaard van Google die definieert hoe AI-agents onderling communiceren, taken delegeren en resultaten uitwisselen.
• De Agent Card (/.well-known/agent.json) is het discovery-mechanisme waarmee agents elkaars capabilities ontdekken.
• A2A en MCP zijn complementair: MCP voor lokale model-tool interactie, A2A voor remote agent-agent communicatie.
• Je kunt nu al beginnen door robuuste Schema.org markup te implementeren, een API te documenteren en OAuth 2.0 gereed te maken.
• Een minimale Agent Card publiceren positioneert je als early adopter en maakt je vindbaar voor AI-agents.

Veelgestelde vragen

Het web evolueert van een netwerk voor mensen naar een netwerk voor mensen en agents. A2A is de taal die agents nodig hebben om samen te werken. Wie die taal spreekt, is klaar voor de toekomst.