Een heldere uitleg van hoe AI-agents de stap maken van vragen beantwoorden naar werkende applicaties opleveren: wat het Model Context Protocol echt doet, hoe scoped tokens agents binnen de lijnen houden, de exacte loop die een agent doorloopt om een app te maken, te valideren en te publiceren, en wat agent-native platforms onderscheidt van haastige ombouwsels.
Founders, developers en operationele mensen die agents willen begrijpen of inzetten die echte software bouwen en onderhouden, en niet alleen chatten.
- Een mentaal model van MCP in gewone taal en waarom elk groot AI-lab het heeft omarmd
- Een eerlijk beeld van het veiligheidsmodel: wat een scoped token wel en niet toestaat
- De loop van zes stappen die een agent doorloopt van briefing tot gepubliceerde applicatie
Een AI-agent die vragen beantwoordt is handig. Een agent die een werkende applicatie bouwt, die aan een database koppelt en op een echt domein publiceert, is een compleet ander soort gereedschap. De brug tussen die twee is een kleine, bewust saaie standaard genaamd MCP, plus een permissiemodel dat het geheel veilig genoeg maakt om te gebruiken. Zo werkt het echt, zonder buzzwords.
MCP, het Model Context Protocol, is een open standaard waarmee een AI-agent externe tools kan gebruiken. Een dienst publiceert een menu van acties die hij kan uitvoeren: een app aanmaken, een bestand bewerken, een validatie draaien. Elke agent die MCP spreekt kan dat menu lezen en die acties aanroepen. Het wordt vaak de USB-C van AI genoemd: één connector die werkt tussen alle modellen en diensten, in plaats van een aparte kabel voor elk paar.
Een taalmodel op zichzelf kan alleen tekst produceren. Het heeft geen handen: het kan geen database aanraken, geen API aanroepen en geen website publiceren. Anthropic bracht MCP eind 2024 uit als open standaard om het op een gestandaardiseerde manier handen te geven, en de adoptie ging ongewoon snel. Binnen twee jaar ondersteunde elk groot AI-lab het, passeerde het publieke register enkele duizenden servers en werden de SDK's tientallen miljoenen keren per maand gedownload.
De reden dat het zich verspreidde is economisch, niet technisch. Vóór een gedeeld protocol betekende N modellen koppelen aan M diensten het bouwen en onderhouden van N keer M maatwerkintegraties. Met één standaard levert een dienst één MCP-server en werkt hij meteen met elke capabele agent, en een agent krijgt alle diensten erbij op de dag dat hij het protocol spreekt. Dezelfde rekensom dreef USB, en het liep hetzelfde af: de connector won.
De eerste verstandige reactie op een machine die software kan maken en publiceren is bezorgdheid, en het eerlijke antwoord is dat veiligheid volledig afhangt van het permissiemodel. Het mechanisme dat dit beheersbaar maakt is het scoped token, en het loont om dat precies te begrijpen, want het is het verschil tussen delegeren en roekeloosheid.
Wanneer je een agent aan een platform koppelt, geef je niet je account uit handen. Je maakt een token aan, een sleutel met specifieke, beperkte permissies, en de agent opereert strikt binnen dat hek. Alles wat hij doet is herleidbaar tot dat token, en jij bepaalt waar het hek staat.
Een founder wil dat een agent het aanmeldformulier van haar boekingsapp repareert. Ze maakt een token aan dat alleen voor die ene app geldt, met permissies voor bewerken en valideren, maar zonder publiceren. De agent voert de wijziging door en draait de validatie; de founder bekijkt de diff, publiceert zelf en trekt daarna het token in. Totale blootstelling: één app, twee permissies, twintig minuten. Zo ziet delegeren met een hek eruit.
Een agent die echte software bouwt, produceert niet alles in één heroïsche generatie. Hij draait een loop die sterk lijkt op hoe een zorgvuldige engineer werkt, alleen samengeperst van dagen naar minuten.
Een model kan altijd code produceren die er goed uitziet. Wat door agents gebouwde software betrouwbaar maakt, is de controle na elke wijziging: een echte poort die zegt dat het werkt, of precies aanwijst wat er brak. Zonder die poort drijven agents vol zelfvertrouwen kapotte toestanden in. Met die poort worden fouten binnen de loop gevangen, precies zoals goede menselijke engineers voorkomen dat ze live gaan.
Genoeg producten hebben een MCP-server vastgeschroefd op een interface die is ontworpen voor mensen die op knoppen klikken. Technisch werkt dat, maar het is niet hetzelfde als een platform dat voor agents is gebouwd. Drie signalen maken het verschil.
De symmetrietest is het snelste filter: op een agent-native platform kan een agent met een goed gescoped token in wezen alles doen wat een mens via de interface kan: een applicatie aanmaken, bestanden wijzigen, valideren, versioneren en publiceren. Is het agentpad een smalle zijdeur met de helft van de mogelijkheden, dan behandelt het platform automatisering als demofeature, en dat plafond voel je binnen een maand echt gebruik.
Wanneer het omzetten van een beschreven behoefte in werkende software geen mens meer vereist die zich door een builder klikt, verandert de economie van kleine software. Een operations-team kan een intern tool hebben op de dag dat het dat tool kan beschrijven, in plaats van het kwartaal nadat het een prioriteringsgevecht wint. Een founder kan 's avonds een ruwe briefing aan een agent geven en 's ochtends een werkende eerste versie beoordelen. Een bedrijf kan zich software veroorloven die exact op één workflow is toegesneden, omdat dat toesnijden niet langer meer kost dan de workflow waard is.
Niets hiervan schakelt menselijk oordeel uit. Iemand beslist nog steeds wat het bouwen waard is, beoordeelt wat er terugkwam en is eigenaar van het resultaat. Wat verandert is de kostprijs van de afstand tussen een heldere beschrijving en een werkend product. Die afstand werd vroeger gemeten in weken en facturen. Nu wordt hij gemeten in minuten en één review, en bedrijven die dit vroeg doorhebben, zullen simpelweg meer software hebben, beter passend bij hoe ze werken, dan bedrijven die wachten.
Het Model Context Protocol is een open standaard waarmee AI-agents de tools van een dienst kunnen ontdekken en aanroepen: een app aanmaken, een bestand bewerken, een controle draaien. Zo kan elke capabele agent werken met elke dienst die een MCP-server publiceert.
Ja, mits het platform echte tools met een validatiepoort biedt: de agent maakt het project aan, bouwt het datamodel en de pagina's, valideert na elke wijziging, herstelt wat de controle vindt en publiceert. Het betrouwbare deel is de loop met verificatie, niet één gigantische generatie.
Het scoped token waaronder hij werkt. Je beperkt hem tot specifieke applicaties en specifieke acties, elke aanroep wordt vastgelegd en je kunt het token direct intrekken. Een agent met een token voor bewerken en valideren van één app kan geen andere projecten verwijderen en niet publiceren zonder jou.
Pas de symmetrietest toe: kan de agent met een goed gescoped token in wezen alles wat een mens kan, dus aanmaken, bewerken, valideren, versioneren en publiceren? Is het agentpad een smalle subset van de menselijke interface, dan was automatisering een bijzaak en loop je snel tegen het plafond aan.