MCP, WebMCP en A2A: welk protocol kiezen voor jouw AI-agenten in 2026

Door het team van Kiwop · Digital Agency gespecialiseerd in Softwareontwikkeling en toegepaste Kunstmatige Intelligentie voor wereldwijde klanten in Europa en de VS · Gepubliceerd op 19 april 2026 · Laatst bijgewerkt: 19 april 2026

TL;DR — Per april 2026 bestaan er drie sleutelprotocollen voor AI-agenten naast elkaar. MCP (Model Context Protocol) verbindt een agent met zijn tools en data; het is de de-facto-standaard, gedoneerd aan de Linux Foundation. WebMCP is de browservariant zodat sites acties kunnen blootstellen aan agenten; blijft opkomend. A2A (Agent-to-Agent) verbindt agenten onderling; v1.0 in productie met 150+ organisaties. Gebruik MCP voor tools, A2A om te orkestreren en WebMCP voor je website.

Elke week ontvangen we dezelfde vraag vanuit directiecomités en productteams: "We bouwen een AI-agent, welk protocol gebruiken we?". Het juiste antwoord is niet meer "MCP, punt uit" — dat was het in 2025, maar 2026 heeft een constellatie van standaarden gebracht die elkaar meer aanvullen dan beconcurreren. Wat interessant is, is niet welke wint: het is welke elk probleem oplost.

Dit artikel is de technische vergelijking die ons zes maanden geleden weken onderzoek zou hebben bespaard. Het is gebaseerd op onze echte ervaring met het bouwen van persoonlijke assistenten met Claude Code en MCP, op het interne werk aan Nexo (onze workspace-SaaS in ontwikkeling), en op de meest recente officiële bronnen gepubliceerd door Anthropic, Google, Cloudflare, Vercel, de Linux Foundation en het W3C zelf. Als je een binair antwoord zoekt, zul je het hier niet krijgen. Als je beslissingscriteria zoekt, blijf lezen.

Waarom 2026 het jaar is van de protocollen voor AI-agenten

2023 was het jaar van de prompt. 2024 was het jaar van de tool (tool use). 2025 was het jaar van de agent. En 2026 is ongetwijfeld het jaar van de protocollen. De reden is eenvoudig: wanneer er één agent met één API praat, werkt elk ad-hoc-contract. Wanneer je tientallen agenten hebt, dozijnen modellen van verschillende providers, honderden interne en externe tools, en klanten die hun eigen agenten op de jouwe willen aansluiten, eet chaos het product op.

De explosie is brutaal geweest. Anthropic rapporteert meer dan 10.000 publieke actieve MCP-servers en 97 miljoen maandelijkse SDK-downloads tussen Python en TypeScript volgens de officiële mededeling van MCP-donatie aan de Linux Foundation. A2A, op zijn beurt, ging van een Google-voorstel in april 2025 naar meer dan 150 organisaties en onder de paraplu van de Linux Foundation begin 2026. Op 9 december 2025 werd de Agentic AI Foundation (AAIF) onder de Linux Foundation geformaliseerd, met Anthropic, OpenAI, Google, Microsoft, AWS, Block, Cloudflare en Bloomberg als platina leden — een beweging behandeld door TechCrunch die het einde markeert van het tijdperk van proprietary protocollen.

De foto per april 2026 is de volgende. Er zijn drie protocollen die elk technisch team moet begrijpen: MCP, WebMCP en A2A. Er is een vierde, ACP (Agent Communication Protocol) van IBM, dat conceptueel overlapt met A2A en waarvan de adoptie tot op heden aanzienlijk kleiner is. En er is een veelheid aan aangrenzende initiatieven — AGENTS.md, Open Responses, ANP, LLMFeed — die eromheen draaien zonder nog dezelfde kritieke massa te bereiken. We richten ons op de drie die ertoe doen voor echte architectuurbeslissingen.

Fragmentatie is een reëel probleem. Zoals opgemerkt in de academische arXiv-enquête over agent-interoperabiliteitsprotocollen, lost elk protocol een verschillende laag van de stack op: het probleem is niet er één kiezen, het is begrijpen in welke laag elk opereert en ze combineren zonder onnodige koppelingen te creëren. Dat is de these die we gaan ontwikkelen.

MCP — Model Context Protocol (Anthropic, 2024)

MCP is, per april 2026, de de-facto-standaard om een AI-agent met externe tools te verbinden. Het werd door Anthropic gepubliceerd in november 2024 als open protocol, en in zijn eerste jaar legde het het pad af dat andere standaarden een decennium hebben gedaan: van individueel voorstel tot gedeelde industrie-infrastructuur.

Wat MCP conceptueel is

MCP definieert een contract tussen twee partijen: een MCP-client (meestal de agent of de host van het model) en een MCP-server (meestal een adapter naar een externe service: Gmail, GitHub, een database, een intern systeem). De client ontdekt welke tools de server aanbiedt, leest het schema en roept ze aan met getypeerde parameters. De communicatie gebruikt JSON-RPC 2.0 over een transport.

Het protocol dekt niet alleen tools: het definieert ook resources (statisch leesbare inhoud, zoals bestanden of records), prompts (herbruikbare templates) en — sinds de specificatie van 25 november 2025 — asynchrone operaties, stateless servers, server identity en officiële extensies volgens de officiële specificatie. Deze evolutie is wat MCP liet overgaan van "een lokale client verbinden" naar "agent-infrastructuur in productie voeden".

Transports: stdio en Streamable HTTP

MCP ondersteunt twee officiële transports volgens de transportdocumentatie van de spec:

• stdio: de client start de server als lokaal subprocess en communiceert via standaardinvoer/uitvoer. Ideaal voor lokale uitvoeringen, CLI en persoonlijke assistenten.
• Streamable HTTP: de server leeft als onafhankelijk proces en stelt één HTTP-endpoint beschikbaar dat POST en GET accepteert. Kan Server-Sent Events gebruiken voor streaming. Het is de de-facto-standaard voor externe servers in 2026 en vervangt het oude HTTP+SSE-transport.

De snelle regel: stdio voor persoonlijke assistenten op één machine, Streamable HTTP voor gedeelde services in productie.

Beschikbare servers en ecosysteem

Per april 2026 dekt het MCP-ecosysteem vrijwel elke relevante zakelijke service: Gmail, Google Calendar, Google Drive, Slack, Linear, GitHub, Notion, Jira, Confluence, Salesforce, HubSpot, Stripe, PostgreSQL, Snowflake, BigQuery en tientallen meer. De adoptie steekt providergrenzen over: OpenAI heeft het native ondersteund in ChatGPT sinds maart 2025, Microsoft heeft het geïntegreerd in Copilot, Google ondersteunt het in Gemini, en editors als Cursor, Windsurf en VS Code spreken MCP native.

Optimale use cases

MCP schittert wanneer er één agent is die toegang nodig heeft tot veel heterogene bronnen: een persoonlijke assistent die je mail en agenda leest, een development-copilot die je code en tickets raadpleegt, een salesagent die CRM- en facturatiedata kruist. In al die gevallen is het patroon hetzelfde: de agent roept getypeerde tools aan op servers die met concrete systemen praten.

Beperkingen

MCP is niet de juiste tool wanneer het verkeer agent↔agent is (daar komt A2A binnen), wanneer de consument een browser is en geen proces met vooraf geïnstalleerde OAuth-credentials (daar komt WebMCP binnen), noch wanneer de operatie massieve binaire streams of sub-milliseconde-latency vereist (daar komen specifieke API's binnen). En hoewel de adoptie enorm is, blijft beveiliging een actief werkgebied: er is groeiende literatuur over tool poisoning, prompt injection via tool-beschrijvingen en moeilijk te auditen permissies. Elke MCP-agent in productie heeft een sandboxing- en bevestigingslaag nodig die het protocol zelf niet oplegt.

WebMCP — de MCP voor het web (2025-2026)

WebMCP is de gok van Google en Microsoft om de MCP-filosofie naar de browser en het web zelf over te brengen. Het is geen uitbreiding van MCP: het is een parallelle standaard, gecoördineerd binnen de W3C Web Machine Learning Community Group, die het client-servercontract aanpast aan de specifieke omgeving van de browser. We behandelden het initiële voorstel al in WebMCP: jouw website klaar voor AI-agenten; hier richten we ons op hoe hij zich positioneert tegenover MCP en A2A.

Waarom WebMCP en niet gewoon MCP over HTTP

A priori klinkt het overbodig: als MCP al Streamable HTTP-transport heeft, waarom een andere standaard? Het WebMCP-ecosysteem is in early preview per april 2026, maar de bestaansreden gaat verder dan onvolwassenheid. Het technische antwoord is dat de browser een radicaal andere omgeving is dan een server. In de browser:

• De authenticatie wordt beheerd door de gebruiker, niet de agent (de sessie-cookie leeft in de browser, reist niet met de agent).
• Acties moeten zichtbaar en superviseerbaar zijn door de mens (er is geen ruimte voor ondoorzichtige automatiseringen).
• Het blootgestelde oppervlak is dat van de bezochte website, geen toegewijd endpoint.
• Ontdekking gebeurt wanneer de gebruiker naar de pagina navigeert, niet via een globaal register.

WebMCP lost precies die verschillen op. Volgens de officiële Cloudflare Browser Run-documentatie over WebMCP stelt de website een set tools bloot — bijvoorbeeld searchFlights() of bookTicket() — met getypeerde parameters. Een agent die de pagina bezoekt kan die tools ontdekken, hun schema's lezen en ze direct aanroepen zonder clicks te simuleren of de DOM te scrapen.

Implementatie: Cloudflare en Vercel

De twee providers die het snelst hebben bewogen zijn Cloudflare en Vercel, hoewel met verschillende benaderingen.

• Cloudflare voegde WebMCP-ondersteuning toe aan zijn product Browser Run (voorheen Browser Rendering) op 15 april 2026, volgens zijn officiële changelog. De integratie stelt een AI-agent in staat zijn MCP-client tegen Browser Run te verbinden via het CDP-endpoint en tools te ontdekken die zijn blootgesteld door elke site die WebMCP implementeert — zelfs wanneer die site de infrastructuur niet beheert.
• Vercel heeft zijn product gericht op het deployen van MCP-servers op zijn Functions-platform, gebruikmakend van Fluid Compute om onregelmatige gebruikspatronen typisch voor agenten te optimaliseren. De officiële Vercel MCP-documentatie beschrijft hoe Streamable HTTP-endpoints met ingebouwde OAuth op te zetten, en hun AI SDK bevat experimentele MCP-client. Hoewel Vercel meer klassieke MCP dan pure WebMCP is, is hij de referentieprovider wanneer je backend al op Next.js draait.

Optimale use cases

WebMCP is het juiste antwoord wanneer je product een publieke website is en je wilt dat AI-agenten hem goed gebruiken: e-commerce (zoeken, filters, winkelwagen, checkout), SaaS met complexe formulieren (configurators, offertes), marketplaces, reserveringssystemen. Elk geval waarin een menselijke gebruiker knoppen en formulieren zou gebruiken en je wilt dat een agent hetzelfde doet met minder wrijving.

Adoptiestand per april 2026

Hier moet eerlijk worden gezegd: WebMCP is opkomend, niet volwassen. Chrome ondersteunt het experimenteel in Canary, Cloudflare heeft gedeeltelijke productie, en de AB Magency-dekking over de "agentic format war" verzamelt dat WebMCP tegelijkertijd concurreert met voorstellen als Markdown for Agents van Cloudflare (gelanceerd op 12 februari 2026). Beide bestaan naast elkaar; geen van beide heeft gewonnen. Voor een team dat vandaag moet beslissen, is WebMCP een redelijke toekomstgok voor sites met voorspelbaar agent-verkeer, maar geen standaard waarop de hele architectuur wordt gebouwd.

A2A — Agent-to-Agent protocol (2026)

Als MCP een agent verbindt met zijn tools, verbindt A2A agenten onderling en, per april 2026, is het de horizontale referentiestandaard. Het is het verschil tussen "een werknemer gebruikt zijn tools" en "een werknemer delegeert taken aan een andere werknemer". Het is geen academisch onderscheid: het lost echte problemen op die MCP niet kan oplossen.

Oorsprong en huidige status

A2A werd aangekondigd door Google op Google Cloud Next 2025 op 9 april 2025, met meer dan 50 launch partners (Accenture, Atlassian, Box, Cohere, Deloitte, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, UiPath, onder andere). In juni 2025 doneerde Google het aan de Linux Foundation. In maart 2026 werd A2A v1.0 gepubliceerd, de versie die de community als productie-klaar beschouwt. De officiële documentatie op a2a-protocol.org beschrijft het model in detail; de upgrade-aankondiging van de Google Cloud Blog documenteert de verbeteringen van v1.0.

Architectuur: Agent Cards en discovery

Het kernconcept van A2A is de Agent Card: een JSON-document dat beschrijft wat een agent kan, welke skills hij blootstelt, welke authenticatie hij vereist en waar hij te bereiken is. Agenten ontdekken elkaar door elkaars Agent Cards te lezen, net als webservices worden ontdekt via OpenAPI. In v1.0 dragen de Agent Cards cryptografische handtekeningen (Signed Agent Cards), waarmee kan worden geverifieerd dat een card is uitgegeven door het domein dat eigenaar is van de agent — een belangrijke verbetering tegen impersonatie.

Het transport is JSON-RPC 2.0 over HTTP, Server-Sent Events of gRPC, met authenticatie via API keys, HTTP auth, OAuth 2.0/OIDC en mutual TLS. Dat wil zeggen: dezelfde stukken die elke zakelijke backend al een decennium gebruikt, zonder iets opnieuw uit te vinden.

Optimale use cases

A2A is het juiste antwoord wanneer er meerdere gespecialiseerde agenten moeten samenwerken: een orkestratie-agent die "zoek een vlucht" delegeert aan een reisagent, "reserveer een hotel" aan een hotelagent, en "betaal" aan een betalingsagent. Elke gespecialiseerde agent heeft zijn eigen tools (MCP intern) en biedt zijn Agent Card extern aan om georkestreerd te worden. Typische scenario's: multi-provider purchasing concierges, multi-departementale workflows in grote bedrijven, marketplaces van agenten.

Fundamenteel verschil met MCP

De sleutel, goed samengevat door IBM in hun artikel over A2A, is dat MCP verticaal is (agent↔tool) en A2A horizontaal (agent↔agent). Beide zijn complementair. Een A2A-agent kan intern MCP gebruiken om toegang te krijgen tot zijn data. Een MCP-agent heeft misschien nooit A2A nodig als hij één enkele agent is. De beslissing is niet "MCP of A2A"; het is "ik heb er één, de andere of beide nodig".

Beperkingen en volwassenheid

A2A v1.0 is recent. Hoewel er productie-deployments zijn bij Microsoft, AWS, Salesforce, SAP en ServiceNow volgens de Stellagent-dekking, is het ecosysteem van interopererende agenten nog steeds klein vergeleken met dat van MCP-tools. Vandaag bouwen met A2A betekent dat je veel van de onderdelen moet bouwen die MCP al volwassen heeft: libraries, gateways, debuggers, observability. Als je probleem "één agent met veel tools" is, voegt A2A complexiteit toe zonder iets nieuws op te lossen.

Vergelijkingstabel: MCP vs WebMCP vs A2A

De tabel is bewust dicht. Als we hem in één zin zouden samenvatten: MCP regeert binnen de agent, A2A regeert tussen agenten, WebMCP regeert in de browser. Elke architectuurbeslissing begint met identificeren waar je bent en van daaruit te werken.

Echt voorbeeld 1: de PA van Kiwop gebruikt MCP stdio

Onze PA (Personal Assistant) — de persoonlijke AI-assistent die we bij Kiwop bouwden na de Anthropic OAuth-onderbreking van 4 april 2026, gedetailleerd gedocumenteerd in van OpenClaw naar PA met Claude Code en MCP — is een schoolvoorbeeld van optimaal gebruik van MCP stdio.

De architectuur in één zin

Claude Code draait op een lokale machine (macOS, met launchd als procesmanager). Hij heeft toegang nodig tot Gmail, Google Calendar, Google Drive en Slack. Voor elk van die vier services hebben we een lokale MCP-server die wordt gestart als subprocess van de sessie. De MCP-client ingebed in Claude Code start de servers via stdio, ontdekt hun tools en roept ze aan wanneer nodig.

Waarom stdio en niet Streamable HTTP

De verleiding was de MCP-servers op een HTTP-endpoint te deployen en Claude Code via netwerk te laten verbinden. We verwierpen het om drie redenen:

1. Credentials: de OAuth-tokens van Gmail, Calendar, Drive en Slack leven in de macOS Keychain. Die tokens blootstellen via netwerk zou tunneling, rotatie en een geheimenmodel impliceren dat we niet wilden.
2. Latency: stdio is lokaal proces met UNIX-pipe. Elke oproep is sub-milliseconde. Een HTTP-endpoint voegt netwerktijd toe zonder functionele winst.
3. Operationele eenvoud: de dag dat er iets stuk gaat, is een lokaal proces inspecteren oneindig veel gemakkelijker dan een remote service debuggen.

De beslissing past bij de algemene logica die we beschrijven in LLMOps: taalmodellen beheren in productie — dicht houden wat dicht kan zijn vermindert het faaloppervlak. Dat is de filosofie die we ook zullen weerspiegelen in de volgende post over patronen en antipatronen van AI-agenten in productie.

Wat we NIET hebben aangeraakt

Noch WebMCP noch A2A. De PA is één enkele agent (Claude Code) met veel tools, bediend door één enkele persoon. A2A introduceren zou pure over-engineering zijn: er is geen andere agent om mee te coördineren. WebMCP introduceren is niet van toepassing: er is geen browser tussen, en de MCP-services dekken al alles wat we nodig hebben.

Dit is belangrijk: een goed ontwerp is evenveel waard door wat het weglaat als door wat het bevat. Elk toegevoegd protocol is te onderhouden code, aanvalsoppervlak en afhankelijkheid van providerbeleid.

Echt voorbeeld 2: Nexo (onze SaaS) plant WebMCP voor klanten

Nexo is de interne SaaS die we bij Kiwop bouwen — een collaboratieve workspace met geïntegreerde agent-mogelijkheden. Zonder in productdetails te gaan (hij wordt later officieel gelanceerd), kunnen we wel de architectuurbeslissing over protocollen vertellen, want die illustreert perfect het dilemma dat de meeste SaaS de komende 12-18 maanden zullen tegenkomen.

Het probleem: klanten die hun eigen agenten willen verbinden

Beta-klanten vroegen ons om twee heel verschillende dingen:

1. "We willen dat onze eigen agenten (Claude, GPT, interne agenten van de klant) toegang hebben tot de data van hun workspace in Nexo."
2. "We willen dat jullie interne agenten in Nexo kunnen samenwerken met de agenten die mijn bedrijf al heeft."

Dat zijn twee volkomen verschillende protocol-problemen.

Beslissing: WebMCP (en remote MCP) voor het eerste, A2A voor het tweede

Voor het eerste probleem (klanten die externe agenten verbinden met hun data in Nexo) besloten we een Streamable HTTP MCP-server per tenant bloot te stellen en parallel WebMCP-endpoints voor te bereiden zodat wanneer gebruikers door de Nexo-UI browsen vanuit een browser met agent, die agent de beschikbare acties kan ontdekken zonder de DOM te scrapen. De blootgestelde tools zijn dezelfde in beide transports; wat verandert is wie ze consumeert en hoe ze authentiseren. Past bij wat we al aanbevelen aan klanten in onze LLM-integratie-service.

Voor het tweede probleem (orkestratie van klantagenten met onze agenten) zetten we in op A2A. We publiceren gesigneerde Agent Cards voor elke interne capability (classify-document, summarize-meeting, draft-email), de klant kan ze ontdekken vanuit zijn orkestratie-agent, en het verkeer zal JSON-RPC over HTTP met OAuth 2.0 zijn. Het belangrijkste voordeel van A2A boven "ik maak nog een REST API" is dat de klant onze API niet hoeft te leren: zijn agent ontdekt, leest de card en opereert.

Wat we NIET hebben gekozen en waarom

We verwierpen alles op pure MCP bouwen hoewel het technisch mogelijk is. De reden is dat MCP is geoptimaliseerd voor agent↔tool: als een klant naar Nexo wil delegeren met een eigen agent en complexe resultaten wil krijgen (multi-step, met tussenstanden, met blootgestelde redeneringen), past A2A beter. MCP is niet bedoeld voor agent↔agent-gesprekken met gedeeld geheugen.

We verwierpen ook beginnen met A2A voor alles, aangezien voor het geval "klant die data van zijn workspace wil lezen/schrijven met Claude" een MCP-server de korte en standaardroute is, met het grootste client-ecosysteem erachter.

De bredere les, voor elke SaaS die erover nadenkt hoe zich te openen voor agenten: het is geen binaire beslissing, het is een beslissing per use case. Data blootstellen aan één enkele clientagent → remote MCP. Publieke website blootstellen aan agenten die hem bezoeken → WebMCP. Interoperen met klantagenten als gelijken → A2A.

Wanneer je MCP (noch WebMCP noch A2A) NIET moet gebruiken

Een hoofdstuk dat in veel artikelen ontbreekt. Agent-protocollen zijn zeer goed voor hun domein en zeer slecht daarbuiten. Enkele signalen dat je geen MCP, WebMCP noch A2A in je architectuur moet stoppen:

• Extreme latency. Als de operatie sub-milliseconde-respons vereist (hoogfrequent handelen, industriële controle, videogames), doden de overhead van JSON-RPC, de handshake, de tool-beschrijving en de round-trip van het model elk agent-protocol. Gebruik specifieke binaire API's.
• Massieve binaire streams. Video-transcodering, volumebeeldverwerking, real-time audiostreaming. MCP kan de job aanroepen, maar is niet het kanaal waarover de bytes reizen. Behoud je specifieke pipelines.
• Lange batch-processen zonder agent. Als jouw geval "cron job verwerkt elke nacht een CSV" is, is een AI-agent met MCP artillerie tegen mussen. Een script en een scheduler blijven het juiste antwoord.
• Strikte determinisme. Bankoperaties, kritieke transacties, auditlogs. Een agent met tools kan in de loop blijven, maar de transactionele motor moet deterministisch zijn, met gedocumenteerde retries en zonder ruimte voor "het model koos een andere tool".
• Gereguleerde compliance met uitgebreide audit. Als elke oproep een juridisch reproduceerbaar spoor moet achterlaten, heb je een laag nodig onder de agent-protocollen — niet erboven — die dat register garandeert. Het kan, maar een AI-agent toevoegen vereenvoudigt compliance niet; het maakt het complexer.

Gerelateerd: in gereguleerde sectoren (gezondheidszorg, juridisch, financieel) vereist elke agent-architectuur een fase van AI-consultancy om te begrijpen wat is toegestaan voordat een protocol wordt gekozen. Een protocol kiezen zonder daar doorheen te gaan is het klassieke antipatroon.

Interoperabiliteit: kun je de drie combineren?

Ja, en het is zelfs waarschijnlijk dat je het doet. Het schoonste patroon in april 2026 combineert de drie protocollen in een coherente stack.

Het conceptuele diagram:

1. Een orkestratie-agent (hoogste niveau, spreekt A2A naar buiten).
2. Wanneer hij een interne tool moet gebruiken (een database lezen, een zakelijke API aanroepen) → MCP.
3. Wanneer hij een complexe subtaak moet delegeren aan een andere gespecialiseerde agent → A2A naar die agent.
4. Wanneer hij moet handelen op een externe website die geen eigen API biedt maar wel WebMCP → WebMCP-client via browser.

De ontvangende A2A-agent gebruikt op zijn beurt intern MCP voor zijn eigen tools. En als de ontvangende agent een publieke SaaS met frontend is, stelt hij waarschijnlijk ook een WebMCP-oppervlak bloot voor menselijke gebruikers met agenten. Het systeem is recursief en composeerbaar: elke agent is een client van de drie protocollen en (potentieel) een server van twee (MCP en A2A).

Deze compositie is precies wat bronnen beschrijven zoals de Digital Applied-protocolkaart of de WorkOS-gids over MCP/ACP/A2A: de protocollen concurreren niet omdat ze verschillende lagen oplossen. Ze concurreren met hun alternatieven in dezelfde laag (WebMCP vs Markdown for Agents; A2A vs ACP), niet onderling.

Een nuance: vermijd over-orkestratie

Voordat je de drie protocollen in een systeem stopt, vraag je af of je ze nodig hebt. De meeste AI-applicaties in productie tot op heden hebben alleen MCP nodig. Een grote minderheid heeft MCP + WebMCP nodig (SaaS met publiek frontend). Een kleine maar groeiende minderheid heeft MCP + A2A nodig (multi-agent ecosystemen). Het drievoudige geval is echt maar zeldzaam. Als je niet kunt rechtvaardigen waarom elke laag een verschillend probleem oplost, is er waarschijnlijk een overbodig.

Tabel: wanneer welk te gebruiken

Tabel: adoptievolwassenheid per april 2026

Roadmap en adoptie in 2026

Wat in elke fase is volgens officiële bronnen per april 2026:

• MCP: stabiele specificatie van 25 november 2025 met asynchrone operaties en stateless servers; volgende relevante mijlpaal, de MCP Dev Summit Europe aangekondigd voor 17-18 september 2026 in Amsterdam. Te volgen signalen: consolidatie van Streamable HTTP-transport als remote default, progressieve terugtrekking van legacy SSE, standaardisatie van beveiligingspatronen voor tool poisoning.
• A2A: v1.0 gepubliceerd in maart 2026 met Signed Agent Cards en formele AP2-uitbreiding. Te volgen signalen: groei van het publieke Agent Card-register, verschijning van A2A-gateways (equivalenten van traditionele API-gateways), native integratie met de grote orkestrators (LangGraph, CrewAI, AutoGen).
• WebMCP: early-preview-programma geopend, gedeeltelijke implementatie in Cloudflare, beperkte ondersteuning in Chrome Canary. Te volgen signalen: acceptatie van het concept in het W3C, beslissing van Chromium Stable over standaardondersteuning, definitieve positionering tegenover Markdown for Agents.
• Aangrenzende standaarden: AGENTS.md (voorgesteld door OpenAI, onder AAIF), Open Responses (open specificatie van OpenAI voor interopererende agent-loops, gerapporteerd door InfoQ in februari 2026), en Skills (bijgedragen door Block/Anthropic). Geen concurreert direct met MCP/WebMCP/A2A, maar ze lossen complementaire onderdelen op: repo-beschrijving, interoperabiliteit van loops, prompt-bundling.

De minst risicovolle voorspelling voor de komende 6-12 maanden is dat MCP consolideert als commodity, A2A zijn eerste grote golf van B2B-deployments bereikt, en WebMCP een betwist terrein blijft tot Chrome Stable beslist het te ondersteunen of niet. In het geval van besluit om niet te ondersteunen, kan het voorstel sterven of migreren naar een alternatieve oplossing (Markdown for Agents of andere).

Veelgestelde vragen

Is MCP alleen van Anthropic?

Nee sinds december 2025. Anthropic doneerde MCP aan de recent opgerichte Agentic AI Foundation onder de Linux Foundation, met Anthropic, OpenAI, Google, Microsoft, AWS, Block, Cloudflare en Bloomberg als platina leden. Vandaag heeft MCP community-governance. Anthropic blijft sterk bijdragen aan de ontwikkeling maar is niet langer de enige beslisser.

Vervangt WebMCP mijn REST API?

Nee. WebMCP stelt een oppervlak bloot bedoeld voor agenten die vanuit browsers opereren. Jouw REST API blijft de juiste route voor backend-backend-integraties, mobiele apps en clients geauthentiseerd met eigen credentials. WebMCP voegt een laag toe gericht op de agent van de gebruiker, vervangt hem niet.

Is A2A klaar voor productie per april 2026?

Ja voor standaardgevallen. De v1.0 gepubliceerd in maart 2026 bevat Signed Agent Cards en wordt geschikt beschouwd voor productie. Er zijn deployments bij Microsoft, AWS, Salesforce, SAP en ServiceNow. Echter, het ecosysteem van libraries en tooling is minder volwassen dan dat van MCP — verwacht meer eigen engineering te besteden aan gateways, observability en Agent Card-beheer.

Welke SDK gebruiken om te beginnen met MCP?

De officiële SDK's in Python en TypeScript dekken de meeste gevallen. Om servers te bouwen in het Anthropic-ecosysteem is de officiële TypeScript-SDK de aanbevolen route. Voor scripting en lokale servers is de Python-SDK de standaard. Beide worden onderhouden door Anthropic met officiële ondersteuning.

Kan ik MCP gebruiken met modellen die niet van Anthropic zijn?

Ja. Sinds maart 2025 ondersteunt ChatGPT MCP native; Copilot en Gemini ook. MCP-servers zijn modelagnostisch: elke client die het protocol spreekt kan ze consumeren. Dat is de belangrijkste reden waarom MCP won — de portabiliteit tussen providers is echt, geen marketing.

Is WebMCP hetzelfde als Markdown for Agents van Cloudflare?

Nee. Het zijn twee concurrerende voorstellen met verschillende filosofieën. WebMCP stelt getypeerde acties bloot die de agent aanroept; Markdown for Agents stelt een gestructureerde Markdown-representatie van de site bloot zodat de agent die interpreteert. Per april 2026 bestaan beide naast elkaar en heeft geen gewonnen. Als je beide flanken wilt dekken, documenteert Cloudflare hoe parallelle ondersteuning te implementeren.

Wat is het echte verschil tussen A2A en ACP?

Conceptueel lossen ze hetzelfde probleem op: horizontale communicatie tussen agenten. A2A wordt gedreven door Google en heeft veel meer tractie (150+ organisaties, Linux Foundation, v1.0 productie). ACP wordt gedreven door IBM (BeeAI) met meer beperkte adoptie. Technisch gebruikt ACP directere HTTP-conventies; A2A gebruikt JSON-RPC met gesigneerde Agent Cards. Als je vandaag vanaf nul begint, heeft A2A een betere waarde/risico-verhouding vanwege het ecosysteem.

Heb ik de drie protocollen nodig in mijn project?

Bijna nooit. De meeste projecten beginnen met alleen MCP. Een SaaS met publiek frontend voegt WebMCP toe wanneer het agent-verkeer de investering rechtvaardigt. Een ecosysteem met meerdere interopererende agenten voegt A2A toe. De veelgemaakte fout is de drie toe te voegen vanaf dag één zonder duidelijke business case; het gezonde patroon is te beginnen met MCP en de rest alleen toe te voegen wanneer er een echt probleem is om op te lossen.

Conclusie: kies per laag, niet per merk

De juiste vraag in 2026 is niet "welk protocol is het beste?" maar "welke laag ben ik aan het oplossen?". MCP regeert binnen de agent, in de agent↔tool-verbinding. A2A regeert tussen agenten, in de horizontale verbinding. WebMCP regeert op de grens tussen je publieke website en de agenten die hem bezoeken. Het zijn drie verschillende lagen; ze concurreren niet, ze componeren.

De operationele les, na het bouwen van de PA op MCP stdio en het ontwerpen van Nexo op remote MCP + A2A + WebMCP, is dat de kost van het verkeerd kiezen van een protocol enorm is. Elk protocol brengt een mentaal model mee, een set libraries, een klantenadoptiecurve en een onderhoudsverplichting op lange termijn. Maar het is ook waar — en dit is misschien het belangrijkste — dat de portabiliteit tussen lagen nooit groter is geweest. Een goed ontworpen MCP-server wordt zonder wijzigingen geconsumeerd vanuit Claude, ChatGPT, Copilot, Gemini en Cursor. Een goed ontworpen A2A-agent is zichtbaar vanuit elke orkestrator die het protocol spreekt. Een site met WebMCP reageert op elke agent die hem bezoekt. De investering in open protocollen betaalt zich snel terug.

Bij Kiwop — Digital Agency gespecialiseerd in Softwareontwikkeling en toegepaste Kunstmatige Intelligentie voor wereldwijde klanten in Europa en de VS — bouwen we al twee jaar op LLM's in productie en sinds begin 2025 op MCP. Als je team vandaag beslist hoe jullie platform te openen voor AI-agenten of hoe een multi-agent systeem te orkestreren, kunnen we je helpen de juiste architectuur te kiezen zonder over-engineering. Bekijk onze diensten voor ontwikkeling van AI-agenten, AI-consultancy en LLM-integratie — of schrijf ons en we gaan zitten.

En als de technische tour je interesseerde, volg de draad met de andere posts van het cluster: van OpenClaw naar PA met Claude Code en MCP, bouw je PA met Claude Code en MCP, AI-agenten in productie: patronen en antipatronen 2026 en WebMCP: jouw website klaar voor AI-agenten.