# WebMCP uitgelegd: wat het is, het verschil met MCP en wat je nu doet

WebMCP is een voorgestelde webstandaard waarmee een website haar eigen acties, zoals "zoek een product" of "vraag een offerte aan", als gestructureerde tools aanbiedt aan een AI-agent in de browser. De agent hoeft je pagina dan niet meer te lezen als een plaatje. Hij roept de functie aan die jij hebt vrijgegeven, terwijl de gebruiker meekijkt.

*Laatst bijgewerkt: 10 september 2026 · Door Marc Diks*

## TL;DR

- WebMCP laat een website JavaScript-functies en HTML-formulieren registreren als tools die een AI-agent in de browser kan aanroepen, via `document.modelContext` of een paar extra attributen op een `<form>`.
- MCP (Model Context Protocol) verbindt AI-apps met servers en werkt overal. WebMCP werkt alleen in een open browsertab, zolang de gebruiker op je site is. Google noemt de twee aanvullend.
- Het is nog experimenteel: een origin trial in Chrome 149 en Edge 150, een Community Group-concept bij de W3C, en Gemini in Chrome gaat de tools volgens Google pas "binnenkort" gebruiken.
- Begin met leesacties (zoeken, berekenen, status opvragen) en laat de gebruiker zelf op verzenden drukken bij alles wat geld kost of een contract raakt.
- De grootste valkuil is een agent die via jouw tool een onomkeerbare actie uitvoert, gestuurd door een gemanipuleerde instructie. De spec noemt prompt injection als eerste risico.

## Kernfeiten

- WebMCP is een browser-API waarmee webapplicaties JavaScript-functies en HTML-formulieren als tools aanbieden aan AI-agents. Bron: https://webmachinelearning.github.io/webmcp/
- De spec is een Draft Community Group Report van de W3C Web Machine Learning Community Group, laatste versie 9 september 2026, editors Brandon Walderman (Microsoft), Khushal Sagar en Dominic Farolino (Google). Bron: https://webmachinelearning.github.io/webmcp/
- De imperatieve API is `document.modelContext.registerTool()`; eerdere versies gebruikten `navigator.modelContext`. Bron: https://developer.chrome.com/docs/ai/webmcp/imperative-api
- De declaratieve API gebruikt de formulierattributen `toolname`, `tooldescription`, `toolparamdescription` en `toolautosubmit`. Bron: https://developer.chrome.com/docs/ai/webmcp/declarative-api
- Toolannotaties: `readOnlyHint`, `consequentialHint`, `untrustedContentHint`, standaard `false`. Bron: https://webmachinelearning.github.io/webmcp/
- Chrome opende het WebMCP Early Preview Program op 10 februari 2026. Bron: https://developer.chrome.com/blog/webmcp-epp
- De origin trial loopt vanaf Chrome 149 en Edge 150; de Edge-trial loopt tot 17 november 2026. Bron: https://github.com/webmachinelearning/webmcp/blob/main/implementation-status.md
- Google (I/O, 19 mei 2026): "Gemini in Chrome will soon support WebMCP APIs." Bron: https://developer.chrome.com/blog/chrome-at-io26
- Google noemt MCP en WebMCP aanvullend: MCP is blijvend en werkt overal, WebMCP is gebonden aan de browsertab. Bron: https://developer.chrome.com/docs/ai/webmcp/compare-mcp
- MCP werd op 25 november 2024 geïntroduceerd door Anthropic en op 9 december 2025 ondergebracht bij de Agentic AI Foundation (Linux Foundation). Bron: https://www.anthropic.com/news/model-context-protocol
- Lighthouse heeft een categorie agentic browsing met audits voor WebMCP-tools, WebMCP-schema's, formulieren zonder declaratieve WebMCP, llms.txt, toegankelijkheid voor agents en layoutstabiliteit (Chrome 150+). Bron: https://developer.chrome.com/docs/lighthouse/agentic-browsing/scoring
- Zoekvolume "webmcp" in Nederland: 8 in januari 2026, 1.077 in februari 2026 (Ahrefs Keywords Explorer, opgevraagd 10 september 2026).

## Wat is WebMCP en waarom nu?

WebMCP (Web Model Context Protocol) is een browser-API waarmee je als websitebouwer functies van je webapplicatie beschikbaar maakt voor AI-agents. Zo'n functie heet een tool. Elke tool krijgt een naam, een beschrijving in gewone taal en een schema dat vastlegt welke invoer hij verwacht.

Een voorbeeld maakt het tastbaar. Stel, je hebt een webshop met een zoekfilter op maat, kleur en prijs. Een agent die dat filter zonder WebMCP moet bedienen, maakt een screenshot, zoekt de juiste dropdown, klikt, wacht, maakt weer een screenshot. Met WebMCP registreer je één tool, `filter_producten`, met drie velden. De agent vult die in en jouw eigen code doet de rest.

De standaard komt uit de Web Machine Learning Community Group van de W3C. De eerste auteurs werkten bij Microsoft en Google.

Vijf momenten laten zien hoe snel dit ging: eerste publicatie van het voorstel op 13 augustus 2025, Chrome opent het Early Preview Program op 10 februari 2026, Google I/O kondigt op 19 mei 2026 de origin trial aan vanaf Chrome 149, de developer origin trial start op 9 juni 2026, en de laatste versie van het spec-concept dateert van 9 september 2026. Bij de I/O-aankondiging toonde Google logo's van merken die experimenteren, waaronder Expedia, Booking.com, Shopify, Etsy, Target, Credit Karma en TurboTax.

Ook de zoekinteresse laat de piek zien: van 8 zoekopdrachten op "webmcp" in Nederland in januari 2026 naar 1.077 in februari, de maand van de early preview, gevolgd door een snelle daling naar een niveau van 84 per maand vanaf juni. In de Verenigde Staten piekte "webmcp" in dezelfde maand op 14.428 zoekopdrachten en zakte daarna terug naar een stabielere bodem van rond de 2.700 per maand — developers zijn daar dus verder aan de slag gegaan, terwijl het in Nederland vaker bij nieuwsgierigheid bleef.

WebMCP hoort bij een bredere beweging die vaak het *agentic web* heet: een web waarop AI-agents namens mensen zoeken, vergelijken en handelen. Meer: https://www.marcdiks.nl/blog/agentic-commerce-2026 en https://www.marcdiks.nl/blog/hebben-we-anno-2026-nog-websites-nodig

## Wat is MCP (Model Context Protocol)?

MCP is een open standaard om AI-applicaties te verbinden met externe systemen: zie het als een USB-C-poort voor AI-applicaties. Anthropic introduceerde MCP op 25 november 2024 en bracht het op 9 december 2025 onder bij de Agentic AI Foundation, een fonds binnen de Linux Foundation dat het samen met Block en OpenAI oprichtte. Google, Microsoft, AWS, Cloudflare en Bloomberg steunen die foundation.

MCP kent drie rollen: de host (de AI-applicatie, zoals Claude, ChatGPT of een code-editor), de client (het onderdeel dat één verbinding met één server onderhoudt) en de server (het programma dat context en acties levert). Een MCP-server biedt tools (functies), resources (gegevens als context) en prompts (sjablonen) aan.

De specificatie van 28 juli 2026 maakte de kern van MCP stateless en scherpte de autorisatie aan; de belangrijkste SDK's halen samen bijna een half miljard downloads per maand. Sinds 26 januari 2026 bestaat er ook MCP Apps, een uitbreiding van Anthropic en OpenAI waarmee een tool een interactief scherm kan teruggeven in het chatvenster. Houd de drie begrippen uit elkaar: MCP (de verbinding), MCP Apps (een interface in de chat) en WebMCP (tools op je eigen webpagina). Meer over risico's van MCP-servers: https://www.marcdiks.nl/blog/ai-skill-nooit-downloaden

## Wat is het verschil tussen WebMCP en MCP?

Het korte antwoord: MCP zet tools op een server, WebMCP zet tools op een webpagina. Beide lenen hetzelfde begrippenkader (tools, schema's, parameters), maar het zijn aparte standaarden met een ander beheer.

| | MCP | WebMCP |
|---|---|---|
| Doel | Data en acties overal en altijd beschikbaar maken voor agents | Een live website klaarmaken voor directe interactie met een agent, tijdens het bezoek van de gebruiker |
| Levensduur | Blijvend: een server die altijd draait | Tijdelijk: bestaat zolang de tab open is |
| Waar het werkt | Overal: desktop, mobiel, cloud, web | Alleen bij agents in de browser |
| Wie is ingelogd | Een apart account, token of OAuth-koppeling | De sessie van de gebruiker in de browser |
| Wie bouwt het | Backend-developers | Frontend-developers |
| Beheer van de standaard | Agentic AI Foundation (Linux Foundation) | Web Machine Learning Community Group (W3C) |

Diagram (beschrijving): MCP loopt van AI-app (host) via MCP-client en JSON-RPC (HTTP of stdio) naar een MCP-server die je systemen ontsluit. WebMCP loopt van de gebruiker via een agent in de browser en document.modelContext naar je webpagina en je bestaande frontend-code.

```mermaid
flowchart LR
  subgraph MCP["MCP: tools op een server"]
    A1["AI-app (host)"] --> A2["MCP-client"]
    A2 -->|"JSON-RPC via HTTP of stdio"| A3["MCP-server"]
    A3 --> A4["Je systemen: CRM, database, API"]
  end
  subgraph WEB["WebMCP: tools op een webpagina"]
    B1["Gebruiker in de browser"] --> B2["Agent in de browser"]
    B2 -->|"document.modelContext"| B3["Jouw webpagina"]
    B3 --> B4["Je bestaande frontend-code en formulieren"]
  end
```

Google raadt aan om beide te gebruiken, elk voor zijn eigen taak: MCP voor de kernlogica en bereik buiten je site, WebMCP voor interactie met je live interface op het moment dat een klant langskomt. Meer over waar agents draaien: https://www.marcdiks.nl/blog/ai-vendor-lock-in-kill-switch

## Hoe werkt WebMCP technisch?

WebMCP geeft twee manieren om tools te maken. De imperatieve API is JavaScript en geeft volledige controle. De declaratieve API bestaat uit een paar extra HTML-attributen op een formulier dat je al hebt.

Je registreert een tool via `document.modelContext.registerTool()` (eerdere versies gebruikten `navigator.modelContext`). Een tool bestaat uit een naam, een beschrijving, een invoerschema in JSON Schema en een `execute`-functie:

```javascript
await document.modelContext.registerTool({
  name: 'bereken_premie_scooter',
  title: 'Premie scooterverzekering berekenen',
  description:
    'Berekent de maandpremie voor een scooterverzekering op basis van ' +
    'postcode, bouwjaar en dekking. Sluit niets af.',
  inputSchema: {
    type: 'object',
    properties: {
      postcode: { type: 'string', description: 'Nederlandse postcode, bijv. 3401AB' },
      bouwjaar: { type: 'integer', minimum: 1990 },
      dekking: { type: 'string', enum: ['wa', 'wa_beperkt_casco', 'allrisk'] },
    },
    required: ['postcode', 'bouwjaar', 'dekking'],
  },
  annotations: { readOnlyHint: true },
  execute: async ({ postcode, bouwjaar, dekking }) => {
    const premie = await berekenPremie(postcode, bouwjaar, dekking);
    toonUitkomstOpPagina(premie);
    return `Maandpremie: EUR ${premie.toFixed(2)}`;
  },
});
```

Drie annotaties helpen een agent inschatten hoe voorzichtig hij moet zijn, alle drie standaard `false`: `readOnlyHint` (leest alleen, verandert niets), `consequentialHint` (gevolgen die groot, echt of onomkeerbaar zijn) en `untrustedContentHint` (uitkomst niet blind te vertrouwen).

Heb je al een net HTML-formulier, dan maak je er met een paar attributen een tool van:

```html
<form toolname="schade_melden"
      tooldescription="Meldt schade aan een bestaande polis. De klant verstuurt zelf."
      action="/schade/melden">
  <label for="polisnummer">Polisnummer</label>
  <input type="text" id="polisnummer" name="polisnummer" required>
  <select name="soort" required
          toolparamdescription="Soort schade: bepaalt naar welk team de melding gaat.">
    <option value="aanrijding">Aanrijding</option>
    <option value="diefstal">Diefstal</option>
    <option value="brand">Brand</option>
  </select>
  <button type="submit">Melding versturen</button>
</form>
```

Met `toolname` en `tooldescription` benoem je de tool, met `toolparamdescription` leg je per veld uit wat erin hoort. De agent vult de velden in, maar de gebruiker drukt zelf op versturen — tenzij je `toolautosubmit` toevoegt.

Diagram (beschrijving): de gebruiker stelt een vraag aan de agent in de browser; de agent vraagt met getTools() welke tools de pagina heeft, roept met executeTool() de read-only tool bereken_premie_scooter aan, de pagina rekent met bestaande code en toont de uitkomst, en de agent geeft het antwoord terug terwijl de pagina zichtbaar meebeweegt.

```mermaid
sequenceDiagram
  participant G as Gebruiker
  participant A as Agent in de browser
  participant P as Webpagina
  G->>A: "Wat kost een allrisk-verzekering voor mijn scooter?"
  A->>P: getTools(): welke tools zijn er?
  P-->>A: bereken_premie_scooter (readOnlyHint)
  A->>P: executeTool(postcode, bouwjaar, dekking)
  P->>P: bestaande code rekent, pagina toont uitkomst
  P-->>A: "Maandpremie: EUR [bedrag]"
  A->>G: antwoord, met de pagina als bewijs zichtbaar
```

WebMCP werkt alleen op HTTPS en per herkomst gescheiden, onder de Permissions Policy `tools` (standaard `self`).

## Waarom tools beter werken dan een agent die je scherm leest

Agents konden websites al bedienen zonder WebMCP: screenshots maken, HTML-structuur lezen, klikken en toetsaanslagen simuleren — traag en breekbaar. Met WebMCP verklaart de site zelf het doel van een knop of veld. Dat gaat sneller en met minder fouten, laat je de regie over je eigen interface houden (de klant blijft bij jou, ziet je eigen voorwaarden, je eigen validatie draait), en houdt de mens in beeld: volledig autonome workflows zonder toezicht zijn een expliciet niet-doel van de spec. Goed gelabelde formulieren, nuttig voor schermlezers, zijn meestal ook makkelijk om te zetten naar een declaratieve WebMCP-tool. Meer: https://www.marcdiks.nl/blog/waarom-openai-nu-jouw-concurrent-wordt en https://www.marcdiks.nl/blog/toegankelijkheid-als-innovatie

## Wat betekent WebMCP voor je website, SEO en AI-vindbaarheid?

AI-vindbaarheid gaat over gevonden en geciteerd worden; WebMCP gaat over de stap daarna: kan een agent iets doen op je site zodra de gebruiker er is? Google heeft niet gezegd dat WebMCP meetelt voor je positie in de zoekresultaten. Lighthouse heeft wel een categorie agentic browsing (Chrome 150+) met audits voor geregistreerde WebMCP-tools, formulieren zonder declaratieve WebMCP, WebMCP-schemavaliditeit, llms.txt, toegankelijkheid voor agents en layoutstabiliteit — een nulmeting, geen bewezen rankingfactor.

Schema.org, llms.txt en WebMCP doen elk iets anders: schema.org beschrijft je pagina voor zoekmachines en AI-systemen, llms.txt geeft taalmodellen een overzicht in markdown, WebMCP biedt acties aan die een agent kan uitvoeren. Een sterke site heeft uiteindelijk alle drie. Meer: https://www.marcdiks.nl/ai-vindbaarheid en https://www.marcdiks.nl/blog/ai-overview-wat-betekent-het-voor-jouw-website

## WebMCP in de verzekeringspraktijk

Verzekeren draait op formulieren: premie berekenen, offerte aanvragen, schade melden, adres wijzigen, polis opzeggen. Indeling naar risico: premie berekenen en dekkingen vergelijken kunnen met `readOnlyHint: true` door de agent zelf; schade melden en adres wijzigen als declaratief formulier zonder (adreswijziging: met) `consequentialHint`, de klant verstuurt of bevestigt zelf; een polis afsluiten is beter nog geen tool; herroepen of opzeggen is declaratief met bevestiging (`consequentialHint: true`).

Sinds 19 juni 2026 moet een consument een online afgesloten overeenkomst, ook voor financiële diensten zoals verzekeringen, via een duidelijk zichtbare herroepingsfunctie kunnen herroepen (Richtlijn (EU) 2023/2673). Wie een opzegknop voor mensen bouwt, kan diezelfde flow met een paar attributen ook bruikbaar maken voor de agent van een klant — en mag het een agent dan niet moeilijker maken om op te zeggen dan om af te sluiten.

Voor adviseurs blijft de zorgplicht bestaan als een agent een formulier invult: een agent die op laagste premie kiest, weet niet dat de klant een dure e-bike heeft. Voor advieszware producten ligt de waarde van WebMCP vooral in de voorfase (informatie ophalen, gegevens invullen), minder bij het afsluiten zelf. Meer: https://www.marcdiks.nl/blog/ontbindingsfunctie-verzekering-opzegknop-2026, https://www.marcdiks.nl/blog/dark-patterns-verbod-opzegknop-2026 en https://www.marcdiks.nl/blog/klantdata-uploaden-naar-ai

## Welke risico's brengt WebMCP mee?

De spec noemt zelf vijf risico's: (1) prompt injection via kwaadaardige instructies in een toolbeschrijving; (2) verkeerd voorgestelde intentie; (3) privacylekken via te veel gevraagde parameters; (4) grenzen tussen domeinen die omzeild worden; (5) onvoorspelbaar gedrag in privénavigatie. Agents kunnen identiteit, inlogstatus, betaalgegevens en browsergeschiedenis overnemen en info over meerdere sites combineren — een agent die zo'n toegang heeft en een gemanipuleerde toolbeschrijving leest, kan veel schade doen.

Vier tegenmaatregelen uit de spec: beperk de lengte van toolbeschrijvingen en invoer, werk met gedeelde testsets voor aanvallen, markeer onbetrouwbare uitkomsten met `untrustedContentHint`, markeer tools met gevolgen met `consequentialHint`. Wat de spec niet voor je regelt: goedkeuring van wijzigende tools (er is een `toolchange`-event), logging van agentaanroepen, en validatie aan de serverkant — vertrouw nooit alleen op het schema. Meer: https://www.marcdiks.nl/blog/de-ontsnapping-ai-agents, https://www.marcdiks.nl/blog/ai-agents-eigen-taal-meelezen en https://www.marcdiks.nl/blog/ai-skill-nooit-downloaden

## Browserondersteuning en standaardisatie: waar staat het?

September 2026: origin trial in Chrome (vanaf 149, plus een Early Preview Program, lokaal testen via `chrome://flags/#enable-webmcp-testing`) en Microsoft Edge (vanaf 150, tot 17 november 2026). Brave heeft experimentele ondersteuning in Leo. Firefox volgt het voorstel (open Bugzilla-melding); Safari's WebKit-standpunt wordt nog besproken. Nergens staat het standaard aan.

Een tool heeft pas waarde als een agent hem aanroept: Google zei op I/O dat Gemini in Chrome WebMCP "binnenkort" gaat ondersteunen, maar op 10 september 2026 was er geen bevestiging dat dit al breed live staat. De spec zelf is een Draft Community Group Report, nog niet op het formele W3C-standaardisatiespoor; namen en gedrag kunnen nog veranderen, zoals de verhuizing van `navigator.modelContext` naar `document.modelContext` al liet zien.

## De zes grootste misverstanden over WebMCP

- WebMCP is een nieuwe versie van MCP. In werkelijkheid is het een aparte W3C-standaard die MCP's begrippen leent maar apart beheerd wordt.
- Met WebMCP kan elke AI-chatbot je site gebruiken. In werkelijkheid werkt het alleen voor agents die in de browser draaien, in een tab waar de gebruiker je site open heeft.
- WebMCP helpt je hoger ranken in Google. Daar is geen bewijs voor; Lighthouse geeft alleen een nulmeting via agentic browsing.
- Een agent kan via WebMCP zomaar betalen of opzeggen. In werkelijkheid bepaal jij welke tools er zijn en drukt de gebruiker standaard zelf op versturen.
- WebMCP vervangt je API of MCP-server. Google noemt de twee juist aanvullend.
- Je moet er nu vol op inzetten, anders ben je te laat. Een kleine test met één leesactie levert nu meer op dan een groot project.

## Hoe pak je WebMCP aan? (stappenplan)

1. Kies de vijf taken die klanten het vaakst op je site doen.
2. Deel ze in naar gevolgen: alleen lezen, iets wijzigen, of geld/contract.
3. Start met één leesactie als imperatieve tool (`readOnlyHint: true`).
4. Annoteer je belangrijkste formulier declaratief, zonder autosubmit.
5. Test lokaal (`chrome://flags/#enable-webmcp-testing`, Model Context Tool Inspector) en meet met de Lighthouse-categorie agentic browsing.
6. Richt beheer in: goedkeuring van nieuwe tools, logging, serverkant-validatie, `consequentialHint`-beleid.
7. Doe mee aan de origin trial, of wacht bewust — en controleer bij elke nieuwe Chrome-versie of er iets veranderde.

Zelfcheck: we weten welke vijf taken klanten het vaakst uitvoeren; elke taak heeft een risicoklasse en eigenaar; onze formulieren zijn goed gelabeld; we hebben één leesactie getest; nieuwe tools doorlopen dezelfde goedkeuring als een nieuwe API; agentaanroepen worden gelogd; invoer wordt altijd serverkant opnieuw gecontroleerd; iemand volgt de spec en de Chrome-releases.

## WebMCP en de regelgeving

Drie kaders voor Nederlandse organisaties (inschatting, laat het juridisch toetsen): de AVG (dataminimalisatie — vraag alleen wat de tool nodig heeft); de EU AI Act (een website die alleen tools aanbiedt zet daarmee zelf geen AI-model in; de verplichtingen liggen primair bij wie een AI-systeem aanbiedt of gebruikt); consumenten- en sectorregels (de herroepingsfunctie uit Richtlijn (EU) 2023/2673 geldt sinds 19 juni 2026 ook voor financiële diensten zoals verzekeringen). Meer: https://www.marcdiks.nl/eu-ai-act, https://www.marcdiks.nl/projecten/ai-wet-impact-scanner en https://www.marcdiks.nl/ai-governance

## Veelgestelde vragen

**Wat is WebMCP?**
WebMCP (Web Model Context Protocol) is een voorgestelde webstandaard waarmee een website functies en formulieren aanbiedt als tools voor AI-agents in de browser. Elke tool heeft een naam, een beschrijving en een invoerschema; de agent roept de tool aan in plaats van knoppen te zoeken op een screenshot. De standaard komt van de W3C en draait in 2026 als origin trial in Chrome en Edge.

**Wat is het verschil tussen WebMCP en MCP?**
MCP (Model Context Protocol) verbindt AI-applicaties met servers en werkt overal, ook als de gebruiker niet op je website is. WebMCP zet tools op een webpagina en werkt alleen in een open browsertab, tijdens het bezoek van de gebruiker en met diens inlogsessie. MCP is backend, WebMCP is frontend.

**Wat is een MCP-server?**
Een MCP-server is een programma dat context en acties levert aan AI-applicaties via het Model Context Protocol: tools (functies), resources (gegevens als context) en prompts (sjablonen). Een server kan lokaal draaien of op afstand via HTTP.

**Is WebMCP een officiële W3C-standaard?**
Nog niet. WebMCP is een Draft Community Group Report, laatste versie 9 september 2026. Community Groups zijn open werkgroepen binnen de W3C; hun rapporten staan nog niet op het formele standaardisatiespoor dat eindigt bij een W3C Recommendation.

**Welke browsers ondersteunen WebMCP?**
In september 2026: origin trial in Chrome (vanaf 149) en Microsoft Edge (vanaf 150, tot 17 november 2026). Brave heeft experimentele ondersteuning in Leo. Firefox en Safari volgen het voorstel nog. Nergens staat het standaard aan.

**Moet ik WebMCP nu al op mijn website zetten?**
Voor de meeste organisaties is een kleine test verstandig en een groot project te vroeg. Begin met één leesactie en goed gelabelde formulieren.

**Is WebMCP goed voor SEO?**
Google heeft niet gezegd dat WebMCP meetelt voor je positie in de zoekresultaten. Lighthouse heeft wel een categorie agentic browsing als nulmeting.

**Is WebMCP veilig?**
WebMCP draait alleen op HTTPS, is gescheiden per herkomst en valt onder een Permissions Policy. Veiligheid hangt vooral af van jouw keuzes: welke tools je aanbiedt, of je gevolgen markeert met `consequentialHint`, en of je invoer aan de serverkant opnieuw controleert.

**Heb ik een developer nodig voor WebMCP?**
Voor de declaratieve variant heb je weinig code nodig. Voor de imperatieve variant schrijf je JavaScript, meestal met je bestaande functies. Het beheer vraagt meer dan de code.

## Verder verdiepen

- Agentic commerce: hoe AI-agents online retail op z'n kop zetten: https://www.marcdiks.nl/blog/agentic-commerce-2026
- Hebben we anno 2026 nog websites nodig?: https://www.marcdiks.nl/blog/hebben-we-anno-2026-nog-websites-nodig
- Waarom OpenAI nu jouw concurrent wordt: https://www.marcdiks.nl/blog/waarom-openai-nu-jouw-concurrent-wordt
- AI-vindbaarheid: https://www.marcdiks.nl/ai-vindbaarheid
- Wat een AI Overview betekent voor je website: https://www.marcdiks.nl/blog/ai-overview-wat-betekent-het-voor-jouw-website
- AI-skills zijn het nieuwe phishing: https://www.marcdiks.nl/blog/ai-skill-nooit-downloaden
- De ontsnapping: hoe AI-agents zichzelf uit hun kooi hackten: https://www.marcdiks.nl/blog/de-ontsnapping-ai-agents
- AI-agents: in 5 dagen een eigen taal die jij niet kunt lezen: https://www.marcdiks.nl/blog/ai-agents-eigen-taal-meelezen
- Klantdata uploaden naar AI: wat mag wel en niet: https://www.marcdiks.nl/blog/klantdata-uploaden-naar-ai
- AI vendor lock-in: waarom de kill switch jouw probleem is: https://www.marcdiks.nl/blog/ai-vendor-lock-in-kill-switch
- Herroepen of opzeggen: de nieuwe herroepingsknop: https://www.marcdiks.nl/blog/ontbindingsfunctie-verzekering-opzegknop-2026
- Dark patterns verbod en verplichte opzegknop: https://www.marcdiks.nl/blog/dark-patterns-verbod-opzegknop-2026
- Toegankelijkheid als innovatie: https://www.marcdiks.nl/blog/toegankelijkheid-als-innovatie
- EU AI Act: https://www.marcdiks.nl/eu-ai-act
- AI-governance: https://www.marcdiks.nl/ai-governance

## Bronnen

- https://webmachinelearning.github.io/webmcp/
- https://github.com/webmachinelearning/webmcp
- https://developer.chrome.com/blog/webmcp-epp
- https://developer.chrome.com/blog/chrome-at-io26
- https://developer.chrome.com/blog/ai-webmcp-origin-trial
- https://modelcontextprotocol.io/docs/getting-started/intro
- https://www.anthropic.com/news/model-context-protocol
- https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/
- https://modelcontextprotocol.io/docs/learn/architecture
- https://blog.modelcontextprotocol.io/posts/2026-07-28/
- https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/
- https://developer.chrome.com/docs/ai/webmcp/compare-mcp
- https://developer.chrome.com/docs/ai/webmcp
- https://developer.chrome.com/docs/ai/webmcp/imperative-api
- https://developer.chrome.com/docs/ai/webmcp/declarative-api
- https://developer.chrome.com/docs/lighthouse/agentic-browsing/scoring
- https://eur-lex.europa.eu/legal-content/NL/ALL/?uri=CELEX%3A32023L2673
- https://github.com/webmachinelearning/webmcp/blob/main/implementation-status.md
- https://developer.microsoft.com/en-us/microsoft-edge/origin-trials/trials/0b76fe60-b266-458e-a285-04e375c0c31a
- https://eur-lex.europa.eu/legal-content/NL/TXT/?uri=CELEX:32016R0679
- Ahrefs Keywords Explorer, zoekvolumes NL en VS voor "webmcp", opgevraagd op 10 september 2026

Canonical: https://www.marcdiks.nl/webmcp
Auteur: Marc Diks (https://www.marcdiks.nl/about)
Laatst bijgewerkt: 2026-09-10