Web & Ontwikkeling

MCP wordt stateless: Wat de 2026-protocolveranderingen betekenen voor AI-agentontwikkelaars

MCP Goes Stateless: What the 2026 Protocol Changes for AI Agent Developers

Het Model Context Protocol is verder gegaan dan zijn oorspronkelijke sessie-gebaseerde architectuur. De specificatie van 2026-07-28 maakt MCP stateless, gemakkelijker schaalbaar achter standaard HTTP-infrastructuur, en beter geschikt voor productie-AI-agents. Hier is wat er is veranderd, waarom het belangrijk is, en wat ontwikkelaars moeten bekijken in bestaande MCP-servers.

Het Model Context Protocol is snel geëvolueerd van een handige manier om AI-modellen aan tools en data te koppelen naar een serieus onderdeel van agentinfrastructuur.

Deze evolutie bracht echter een probleem met zich mee.

De eerste generaties van externe MCP-servers waren gebaseerd op sessies op protocolniveau. Een client startte een verbinding, de server gaf een sessie-id, en daaropvolgende verzoeken bleven aan die sessie gekoppeld.

Dit werkt goed wanneer een AI-client communiceert met één serverproces. Het wordt echter minder aantrekkelijk wanneer dezelfde MCP-service over meerdere containers, regio's of cloud-instanties moet draaien.

De 2026-07-28 MCP-specificatie verandert deze architectuur fundamenteel: het moderne MCP-lifecycle is stateless op protocolniveau.

Voor ontwikkelaars die productie AI-agents bouwen, is dit meer dan een protocoldetail. Het verandert hoe MCP-services kunnen worden geïmplementeerd, geschaald en geïntegreerd met conventionele HTTP-infrastructuur.

Waarom moest MCP stateless worden?

Eerdere versies van MCP gebruikten een initialisatiehandshake. Een client verbond zich met een MCP-server, stuurde een initialize-verzoek en onderhandelde over capaciteiten en een protocolversie. Met Streamable HTTP kon een server ook een Mcp-Session-Id uitgeven die de sessie bij latere verzoeken identificeerde.

Als er meerdere MCP-serverinstanties achter een load balancer zitten, kan de infrastructuur daarom sticky routing of gedeelde sessieopslag nodig hebben. De nieuwe architectuur verwijdert deze vereiste uit het protocol zelf.

Wat is er veranderd in MCP op 28-07-2026?

De sessie op protocolniveau verdwijnt uit de moderne lifecycle. De initialize-handshake die door de vorige protocolepoch werd gebruikt, maakt niet langer deel uit van die lifecycle, en het Mcp-Session-Id-mechanisme is verwijderd.

In plaats daarvan ontdekken moderne clients een server en sturen ze verzoeken die genoeg protocolinformatie bevatten om onafhankelijk te worden verwerkt. Het praktische resultaat is belangrijk: verzoek A en verzoek B hoeven niet langer hetzelfde MCP-serverinstantie te bereiken alleen omdat ze tot dezelfde protocol-sessie behoren.

Een conventionele load balancer kan ze verdelen over beschikbare instanties.

Stateless MCP betekent niet dat applicaties stateless zijn

Het verwijderen van de MCP-protocolsessie betekent niet dat een applicatie geen status meer kan bijhouden.

Stel je een MCP-tool voor die een winkelmandje aanmaakt. In plaats van een verborgen winkelwagen op te slaan in een MCP-sessie, kan de tool een expliciete identificatie teruggeven:

basket_id: basket_84721

Een latere toolcall kan die identificatie accepteren:

add_item(
    basket_id: "basket_84721",
    product_id: "product_42"
)

De status bestaat nog steeds. Het behoort gewoon toe aan de applicatie en niet aan het transportprotocol. Dit patroon zal bekend aanvoelen voor webontwikkelaars: REST API's publiceren routinematig identificatiecode voor winkelwagens, jobs, conversaties, bestanden of workflows in plaats van te verwachten dat een HTTP-verbinding zelf de applicatiestatus onthoudt.

Waarom is dit belangrijk voor horizontale schaalbaarheid?

Stel je een externe MCP-server voor die op drie applicatie-instanties draait:

AI client
    |
Load balancer
    |
+---------+---------+
|         |         |
MCP #1   MCP #2   MCP #3

Met sessiestatus op protocolniveau kan de infrastructuur een bepaalde client aan één instantie moeten koppelen of zijn sessiegegevens moeten repliceren. Met de moderne stateless lifecycle kan elk compatibel verzoek onafhankelijk worden verwerkt.

Dat maakt round-robin load balancing, autoscaling, ephimerale containers, rolling deployments, serverless runtimes en multi-instance Kubernetes deployments eenvoudiger toepasbaar.

Discovery vervangt een deel van het oude initialisatiemodel

Als er geen langdurig initialisatie-uitwisselingsproces is, moet een client toch weten wat de server ondersteunt. De nieuwe lifecycle introduceert server discovery.

In plaats van te vertrouwen op informatie die eenmaal is onderhandeld en als sessie status wordt bewaard, kunnen moderne MCP-implementaties hun capaciteiten via het discovery-model blootstellen. De specificatie uit 2026 introduceert ook TTL-informatie voor lijstresultaten, zodat clients weten hoe lang ontdekte informatie redelijkerwijs kan worden hergebruikt.

Voor grote implementaties vermindert het cachen van ongewijzigde toollijsten onnodige overhead.

Server-naar-client interacties moesten ook veranderen

Naar stateless gaan creëert een moeilijker uitdaging voor interacties die door de server worden geïnitieerd. Stel je voor dat een tool wordt uitgevoerd en extra informatie van de gebruiker nodig heeft.

De MCP-architectuur uit 2026 introduceert Multi Round-Trip Requests (MRTR) om interacties te ondersteunen die extra clientinvoer vereisen zonder het herstellen van een permanente protocolsessie.

Serverinitieerde verzoeken moeten ook gekoppeld zijn aan een actief clientverzoek. Dat maakt interacties gemakkelijker om te begrijpen vanuit zowel een infrastructuur- als beveiligingsperspectief.

MCP wordt makkelijker voor gateways om te begrijpen

Moderne MCP-verzoeken kunnen routinginformatie in HTTP-headers blootstellen, inclusief informatie over de MCP-methode die wordt aangeroepen. Een API-gateway of rate limiter kan daarom beslissingen nemen zonder elke JSON-RPC-body te parseren.

Voor infrastructuurteams opent dit de deur naar conventionele routing, observability, quotas, rate limiting en traffic analysis.

Het werk van Google's Apigee illustreert deze richting: gatewayinfrastructuur kan operaties uit een OpenAPI-specificatie als MCP-tools blootstellen en protocoltranslatie verwerken in plaats van een volledig aparte MCP-stack te vereisen.

Beveiliging wordt een belangrijk aspect van deployment

Schaalbaarheid van MCP is alleen nuttig als de toegang tot tools ook veilig kan worden gecontroleerd.

Het werk uit 2026 omvat autorisatieverhardingen rond OAuth- en OpenID Connect-concepten, waaronder sterkere issuer-validatie, credential-isolatie en scope-handling.

Het bredere ecosysteem voegt ook administratieve controles toe rond welke MCP-servers kunnen worden gebruikt. GitHub, bijvoorbeeld, introduceerde in augustus 2026 enterprise MCP-allowlists, zodat administrators MCP-servers die door ondersteunde GitHub Copilot-clients worden gebruikt, centraal kunnen controleren.

MCP-servers kunnen databases, deploymentsystemen, bedrijfsapplicaties of andere bevoorrechte capaciteiten blootstellen aan een AI-agent. Authenticatie, autorisatie, toolpermissies en auditability horen daarom in de architectuur thuis.

Moeten bestaande MCP-servers opnieuw worden geschreven?

Niet per se.

De overgang wordt ondersteund door officiële SDK's. Implementaties kunnen moderne verkeersstromen ondersteunen terwijl ze compatibiliteitsgedrag voor clients uit de eerdere protocolepoch behouden, waardoor een geleidelijke migratie mogelijk is in plaats van een abrupte migratie.

Een verstandige migratie-strategie is om te bepalen of een bestaande MCP-server daadwerkelijk afhankelijk is van protocol-sessies. Conventionele request/response-tools kunnen eenvoudig te migreren zijn. Sessiespecifieke data, abonnementen of oudere server-naar-clientgedragingen kunnen meer architectonisch werk vereisen.

Wat moeten ontwikkelaars nu beoordelen?

Als je een MCP-server onderhoudt, audit dan vijf gebieden.

Ten eerste, identificeer applicatiegegevens die impliciet worden opgeslagen tegen een MCP-sessie en bepaal of ze in plaats daarvan een expliciete applicatie-identificatie moeten hebben.

Ten tweede, controleer je MCP SDK-versie en ondersteuning voor de 2026-07-28 protocolrevisie.

Ten derde, beoordeel server-naar-client interacties en neem het nieuwere round-trip model over waar nodig.

Ten vierde, beoordeel authenticatie en autorisatie in plaats van protocolmigratie te behandelen als een transport-only wijziging.

Ten slotte, test achter meer dan één applicatie-instantie. Achtereenvolgende verzoeken moeten veilig verschillende instanties kunnen bereiken.

MCP wordt infrastructuur, niet alleen een ontwikkelaarprotocol

MCP begon als een interoperabiliteitslaag tussen modellen en externe capaciteiten. Het wordt nu overgenomen door AI-ontwikkeltools, cloudplatforms en agent-ecosystemen.

Google heeft MCP geïntegreerd in ontwikkelaars producten en API's, terwijl OpenAI's Apps SDK op MCP is gebouwd om externe tools en data te combineren met interactieve ervaringen binnen ChatGPT.

Naarmate de adoptie toeneemt, moet MCP-infrastructuur workloads ondersteunen die zeer verschillen van de lokale integraties waarvoor vroege implementaties waren geoptimaliseerd.

Het stateless maken van de protocolkern is daarom een belangrijke stap in de maturatie.

Voor ontwikkelaars is de boodschap eenvoudig: een MCP-server moet steeds meer worden ontworpen als een schaalbare webservice, met expliciete applicatiestatus, duidelijke autorisatiegrenzen en infrastructuur die niet afhankelijk is van één langdurige protocolsessie.

Dat maakt MCP minder ongewoon om te bedienen – en aanzienlijk praktischer voor de volgende generatie productie AI-agents.