MCP vs RAG vs AI-agents vs A2A: de 2026-stack

MCP, RAG, AI-agents en A2A worden tegenover elkaar gezet als concurrenten om uit te kiezen — en juist dat is de denkfout. Het zijn vier lagen van één stack, geen vier opties: RAG levert kennis, een agent plant en handelt, MCP is hoe die agent bij tools en data komt, en A2A is hoe agents met elkaar samenwerken. De echte kunst is weten in welke laag uw probleem eigenlijk zit.

De vier, in één regel elk

• RAG (retrieval-augmented generation): geef een taalmodel op het moment van antwoorden uw eigen documenten, zodat het uit feiten antwoordt in plaats van uit geheugen.
• AI-agents: een LLM in een lus die plant, handelt, het resultaat leest en bijstuurt — software die meerstapswerk doet, niet alleen chat.
• MCP (Model Context Protocol): een open, standaard interface voor hoe een model of agent verbindt met tools en data — zie het als USB-C voor AI-tools.
• A2A (Agent2Agent): een open protocol voor hoe losse agents elkaar vinden, taken delegeren en coördineren — agent-tot-agent, over teams en leveranciers heen.

RAG — de kennislaag

RAG is een pijplijn: de vraag wordt geëmbed en herschreven, de best passende stukken worden uit een vectorstore gehaald, geherrangschikt en gefilterd, en dan bij de vraag in de prompt gestopt zodat het model uit die context antwoordt en die citeert. Uw beleid, producthandleidingen en oude tickets op het moment van antwoorden injecteren is precies wat hallucinaties terugdringt. Wilt u vooral gegronde antwoorden over uw eigen inhoud, dan hebt u RAG nodig — geen agent. In 2026 is het zelden naïef: hybride zoeken (trefwoord plus vector), rerankers, GraphRAG over gekoppelde entiteiten en evals die de zoekkwaliteit echt meten scheiden een werkend systeem van een demo. Vraagt iemand of finetunen niet beter is, dan is het antwoord meestal eerst ophalen.

AI-agents — de regellus

Een agent is de lus plan → handel → observeer → reflecteer rond een model, met geheugen en tools eraan. U geeft een doel; hij plant stappen, roept een tool aan, leest wat terugkomt en bepaalt de volgende zet — closed-loop-uitvoering in een echt systeem, geen los antwoord. De knop die telt is autonomie: van een strak gescript proces waarin het model alleen gaten invult, tot open-einde autonomie, wat u in productie zelden wilt. Qua frameworks is het beeld in 2026 helder: LangGraph is een toonaangevende productiekeuze voor stateful, controleerbare workflows — een gerichte graaf met checkpointing en goedkeuringsstappen; CrewAI doet rolgebaseerde "crews"; de OpenAI Agents SDK kiest voor expliciete overdrachten; Microsoft Agent Framework en Google ADK maken het veld compleet. In gereguleerd of belangrijk werk kiest u degene die u determinisme, een audittrail en een menselijke poort geeft, en houdt u de lus zo strak als de taak toelaat — de meeste agent-projecten mislukken door te veel autonomie, niet te weinig.

MCP — de toollaag

Een agent is niet nuttiger dan waar hij bij kan, en MCP standaardiseert dat bereik. Een MCP-host — een IDE, een desktop-assistent, uw eigen app — draait een MCP-client die het MCP-protocol spreekt met MCP-servers, die tools en resources (een CRM, een SQL-warehouse, een file drive) achter één interface aanbieden. In plaats van per tool een maatwerkkoppeling te bouwen, wijst u de agent naar een MCP-server en kan hij opsommen en aanroepen wat er is. De actuele stand telt: de stabiele spec is van 25 november 2025, en de release candidate van 28 juli 2026 maakt het protocol stateless in de kern en voegt Tasks, MCP Apps, een Extensions-framework en hardere autorisatie toe — de Streamable HTTP-transportlaag draagt nu Mcp-Method- en Mcp-Name-headers zodat gateways kunnen routeren zonder de body te lezen. Ook het bestuur werd multi-vendor: in december 2025 ging MCP naar de Agentic AI Foundation onder de Linux Foundation, gesteund door Anthropic, OpenAI, Google, Microsoft en anderen, met een ecosysteem van zo'n 10.000 publieke servers en circa 97 miljoen SDK-downloads per maand. We gingen dieper in op die verschuiving in onze notitie over de stateless MCP-spec van 2026.

A2A — de coördinatielaag

Hebt u meer dan één agent — een service-agent, een finance-ops-agent, een data-analytics-agent — dan moeten ze elkaar kunnen vinden en samenwerken zonder maatwerklijm. A2A is die laag: elke agent publiceert een ondertekende Agent Card met zijn vaardigheden, een registry of directory doet de discovery, een gateway of router bewaakt beleid, auth en routering, en agents wisselen taken, artefacten (rapporten, tickets), statusgebeurtenissen en overdrachten uit. Google maakte A2A en schonk het aan de Linux Foundation, die in april 2026 v1.0 stable uitbracht — ruim 150 organisaties, SDK's in vijf talen, ondertekende Agent Cards, een bijbehorend Agent Payments Protocol (AP2), en algemene beschikbaarheid in Microsoft Copilot Studio, Azure AI Foundry en Amazon Bedrock AgentCore. Waar het vandaag al draait is veelzeggend — supply chain, financiële dienstverlening, verzekeringen en IT-operations, allemaal omgevingen met veel autonome systemen die over tools, teams en leveranciers heen moeten samenwerken in plaats van binnen één applicatie. Het is echt, maar het is de laag die de meeste teams als laatste bereiken.

Ze stapelen — het is een stack, geen keuzevraag

Zet ze samen en de "versus" verdampt. Een verzoek komt binnen; de agent (de regellus) plant; hij gebruikt RAG om de nodige feiten te halen; hij bereikt zijn tools via MCP; en overstijgt de klus meerdere specialismen, dan draagt hij over aan een andere agent via A2A. RAG zit ín de lus — vaak zelf bereikt via een MCP-server vóór uw vectorstore; MCP is de verticale verbinding omlaag naar tools en data; A2A is de horizontale verbinding tussen agents. Het echte verhaal van 2026 is dat zowel MCP als A2A nu open, Linux-Foundation-protocollen zijn: de AI-stack beleeft zijn Kubernetes-moment, waar leverancier-neutrale standaarden het zelf-bouwen vervangen. Ontwerpt u de productie-AI-stack, ontwerp hem dan als lagen.

Maak het concreet. Een klant mailt “waar blijft mijn terugbetaling?” Een service-agent pakt het op, gebruikt RAG om uw retourbeleid en de klanthistorie te lezen, roept via een MCP-server uw ordersysteem aan om de betaling te checken, en — omdat de terugbetaling akkoord nodig heeft — draagt de taak via A2A over aan een finance-ops-agent, die een artefact (de goedkeuring) teruggeeft waarmee de service-agent antwoordt. Eén verzoek, vier lagen, elk doet waarvoor het gebouwd is.

In welke laag zit uw probleem?

Haal de merknamen weg en het komt neer op vier vragen. Beantwoord ze eerlijk en de keuze maakt zichzelf — en meestal hebt u minder lagen nodig dan de verkoop suggereert.

• Accurate antwoorden uit uw eigen inhoud? Dat is RAG. Bouw geen agent voor een Q&A-bot.
• Meerstapswerk met controles onderweg? Dat is een agent — maar begin met de strakste lus die het oplost; de meeste "agent"-taken zijn een proces met één of twee modelstappen.
• Een model koppelen aan uw tools en data? Gebruik MCP in plaats van een eenmalige koppeling, zodat het werk overdraagbaar is en u lock-in vermijdt.
• Meerdere gespecialiseerde agents coördineren, of agents over leveranciers heen? Dat is A2A — en de meeste organisaties zijn hier nog niet. Het loont pas als u echt meerdere agents draait die moeten samenwerken.

Wat dit betekent voor het Nederlandse mkb

Voor het mkb is de volgorde vrijwel altijd van onder naar boven, niet de top-down van de hype. Begin met RAG voor gegronde antwoorden over uw eigen documenten; voeg één agent met een smalle, door mensen gecontroleerde lus toe wanneer een echte meerstapstaak dat rechtvaardigt; koppel die aan uw Nederlandse stack — Exact, AFAS, een ordersysteem — via MCP in plaats van maatwerkcode; en grijp pas naar A2A zodra u echt meerdere agents, of partner-agents, te coördineren hebt. Sla het verhaal van "een zwerm autonome agents" over voor een eerste project — de teams die leveren, meten een werkend systeem in productie, geen slides. De winst van beide open protocollen is concreet voor kleinere bedrijven: standaard interfaces, minder lock-in en overdraagbare koppelingen. Houd een mens in de lus waar geld of gegevens veranderen — precies zoals wij AI-automatisering aanpakken.

Veelgestelde vragen