Op 28 juli publiceerde het Model Context Protocol zijn spec van 2026-07-28. Vijfde revisie sinds de lancering, en de maintainers noemen het de grootste tot nu toe. De belangrijkste verandering: MCP hield op een stateful protocol te zijn en werd stateless.
Die zin zegt de meeste mensen niets. Even een stap terug.
Wat MCP is, in ongeveer een minuut
MCP is de standaardstekker tussen AI-modellen en al de rest.
Voordat het bestond, moest elke AI-app die je Drive wilde lezen, je database wilde bevragen of een Jira-ticket wilde openen, voor elk daarvan een maatwerkintegratie schrijven. Elk model, elke tool, elke keer opnieuw. Dat schaalde niet.
MCP loste dat op met één vorm. Je bouwt eenmalig een MCP-server voor je dienst, en elke MCP-client kan ermee praten. Claude, Cursor, VS Code, of wat er volgend jaar uitkomt. Anthropic bracht het uit in november 2024, gaf het daarna aan een stichting, en de adoptie ging sneller dan bijna iedereen had verwacht. Anthropic houdt het nu op zo'n 400 miljoen SDK-downloads per maand, met ruim 950 servers alleen al in de connectorenmap van Claude.
Zie het als USB-C voor AI-tools. Eén stekker in plaats van een la vol adapters.
Wat er echt veranderde
Oud MCP had een geheugen. Nieuw MCP niet.
Onder de oude regels begon verbinden met een externe MCP-server met een handshake. De client zegt hallo. De server zegt hallo terug en overhandigt een session ID. Vanaf dat moment draagt elk verzoek dat ID mee, en de server onthoudt je tussen aanroepen door.
Klinkt handig. In productie was het een hoofdpijndossier.
Dit is waarom. Stel dat je MCP-server op tien machines draait achter een load balancer, wat elke echte deployment in de praktijk is. Je handshake landt op machine drie. Machine drie maakt je session ID aan en onthoudt je. Je volgende verzoek wordt naar machine zeven gerouteerd, die nog nooit van je gehoord heeft. Fout, opnieuw beginnen.
De engineers van Google schreven over het uitrollen van MCP op hun eigen infrastructuur en zeiden dat ze precies hierop volledig vastliepen. Elke workaround kostte iets. Pin elke gebruiker aan één machine en je bent je load balancing kwijt. Duw de sessiestatus in een gedeelde Redis en je draait ineens een database voor een protocoldetail. Laat je gateway de body van elk verzoek openbreken om de routering te bepalen, en je betaalt het in latency. En als een machine herstartte, was iedereen erop zijn sessie kwijt.
De nieuwe spec schrapt het probleem in plaats van het te beheren. Geen handshake. Geen session-ID-header. Elk verzoek draagt mee wat de server moet weten: protocolversie, client-info, capabilities. Elke machine kan elk verzoek beantwoorden, en het maakt niet uit welke de vorige keer antwoordde.
Even precies zijn over de claim. Dit is stateless op de protocollaag, niet op de applicatielaag. Je kunt er nog steeds stateful dingen bovenop bouwen. HTTP is een stateless protocol en het hele web draait er prima op.
Wat je dat oplevert
Gebruik je alleen AI-tools, dan hoef je niets te doen. Je client regelt het. Je zou externe verbindingen iets sneller moeten merken, omdat er een round trip verdween, en betrouwbaarder, omdat een serverherstart je niet langer midden in een taak eruit gooit.
Rol je MCP-servers uit, dan is dit de release waar je op wachtte. Gewone round robin werkt. Geen sticky sessions, geen gedeelde sessieopslag. Je kunt servers draaien op Lambda, Cloudflare Workers, Cloud Run of Vercel en ze naar nul laten schalen als niemand ze gebruikt. GitHub leverde vroeg support en gooide zijn Redis-sessielaag er volledig uit. Hun changelog zei het onomwonden: de databaseschrijfacties bij het verbinden zijn weg, de leesacties bij elke aanroep zijn weg, en niemand is er iets bij verloren.
Bouw je MCP-servers, dan is er werk aan de winkel. Hoeveel hangt volledig af van waarop je hebt gebouwd.
De diepere laag, voor wie er al in zit
De stateless kern komt via twee voorstellen, SEP-2575 en SEP-2567. Het eerste schrapt de initialize-handshake en verplaatst de protocolversie, client-info en capabilities naar _meta, bij elk verzoek. Het tweede haalt het sessieconcept en de Mcp-Session-Id-header volledig uit Streamable HTTP, zonder afbouwperiode. Schone breuk.
Had je status nodig over aanroepen heen, dan maak je die nu zelf aan. Een tool geeft een expliciete handle terug, het model geeft die als een gewoon argument weer mee, en je echte status leeft in Redis of Postgres, geïndexeerd op die handle. Mooi bijeffect: omdat de handle in het transcript staat, overleeft hij een clientherstart, iets wat sessies nooit deden.
Alles wat op een openliggende verbinding leunde, moest opnieuw gebouwd worden. Sampling, elicitation en roots hingen af van de server die terugbelde via een levend kanaal. Ze zijn vervangen door Multi Round-Trip Requests. De server geeft een resultaat terug met de markering input_required en een ondoorzichtige requestState, de client verzamelt de antwoorden en probeert daarna dezelfde aanroep opnieuw, met de antwoorden erbij. Elke instantie kan die herhaling oppakken. Supabase, dat stateless draait, zegt dat het hierdoor elicitations eindelijk überhaupt kan ondersteunen.
De rest van de release bestaat grotendeels uit de gevolgen van die beslissing:
- Elk resultaat draagt nu een
resultType. Servers op oudere specs worden alscompletebehandeld. - Elke POST draagt de headers
Mcp-MethodenMcp-Name, zodat gateways kunnen routeren, rate limiten en auditen zonder de body te parsen. - Lijstresultaten dragen
ttlMsencacheScope, rechtstreeks geleend van HTTP-cachesemantiek. Zetpublicop een lijst per tenant en je hebt een datalek uitgerold, dus voorzichtig daarmee. - Het GET-endpoint en
resources/subscribezijn weg, vervangen door één enkelesubscriptions/listen-stream waarop je je per notificatietype abonneert. - Resumability is weg. Geen
Last-Event-ID, geen event-ID's. Een verbroken stream verliest het lopende verzoek en je stuurt het opnieuw. Duurzaamheid verhuisde naar de Tasks-extensie, die ook de kern verliet en nu via polling werkt. - Roots, sampling en logging zijn afgekeurd, net als het oude HTTP+SSE-transport. Er is eindelijk een formeel afbouwbeleid met een minimumvenster van twaalf maanden, dus niets verdwijnt van de ene dag op de andere.
- Auth werd strenger. Issuer-validatie is nu verplicht, en Client ID Metadata Documents beginnen de dynamische clientregistratie te vervangen.
Alle vier de Tier 1-SDK's leverden support op de dag van publicatie. TypeScript splitste in aparte server- en clientpakketten en levert een codemod. Python hernoemde FastMCP naar MCPServer. Go veranderde nauwelijks.
Het stuk dat niemand mag overslaan
Stateless haalt het werk niet weg. Het verschuift het naar jou.
Er is geen sessie meer die je één keer authenticeert, dus elk verzoek moet geauthenticeerd worden. De dreigingsonderzoekers van Akamai wezen op de voor de hand liggende gevolgen: _meta-velden die de client bepaalt en die geen handtekening dragen, secrets die per ongeluk in headers belanden en dus zichtbaar zijn voor elke proxy en elke log onderweg, en goedkope taakcreatie als denial-of-service-vector. Hun samenvatting is fair. De beveiligingsgrenzen hangen nu volledig af van hoe elke ontwikkelaar ze implementeert. Ze verkopen ook producten in deze hoek, weeg het dus mee.
De migratie zelf is echt. The Register was er niet mals over dat zelfgebouwde implementaties een flinke klus te wachten staat, en de hoofdmaintainer van MCP zei hardop dat een groot deel van wat MCP MCP maakte, weg is. Hij heeft gelijk. Schreef je je eigen transport, reken dan op een week en verwacht verrassingen. Oude clients en nieuwe servers kunnen niet praten zonder een bewuste fallback aan één kant.
En de eerlijkste kritiek die rondgaat: als een externe MCP-server nu op een gewone stateless HTTP-service lijkt, waar is MCP dan eigenlijk voor? Het eerlijke antwoord is dat de waarde nooit het transport was. Het zijn discovery, tool-schema's en een gedeeld autorisatieverhaal. Deze release zorgt er alleen voor dat je niet langer tegen het transport hoeft te vechten.
Waar ik uitkom
De framing waar ik steeds op terugkom, is dat dit achttien maanden kostte, niet één release. Streamable HTTP maakte stateless servers al mogelijk in maart 2025. Deze spec maakte stateless het enige model. Het gat tussen die twee data is het gat tussen iets dat technisch ondersteund wordt en iets dat echt zo werkt.
Eén leveranciersonderzoek zet 41% van de softwareorganisaties op MCP in productie, in een of andere vorm. Dat is de reden dat het protocol volwassen moest worden. Je kunt zoveel teams niet vragen om Redis te draaien voor een handshake.
De interessante problemen in MCP zijn geen transportproblemen meer. Het zijn autorisatie, verbruiksmeting en attributie. Uitzoeken wie wat mag aanroepen, en wie betaalt.
Zo ziet een protocol eruit als het geen demo meer is.
Gebaseerd op de MCP-spec van 2026-07-28 en de voorstellen SEP-2575 en SEP-2567, de engineeringverslagen van Google en GitHub over het draaien ervan, het dreigingsonderzoek van Akamai via SecurityWeek, de release notes van Supabase en Anthropic, de berichtgeving van The Register, en één leveranciersonderzoek over adoptie in productie. Een momentopname van 9 augustus 2026. Specs bewegen, dus check modelcontextprotocol.io voor je me citeert over de naam van een header.