AG-UI: het protocol dat AI-agents met je interface verbindt

TL;DR

• Wat: AG-UI is een open protocol dat standaardiseert hoe AI-agents communiceren met gebruikersinterfaces — denk aan chatvensters, dashboards en apps.
• Waarom relevant: Als je AI-agents wilt inzetten in je bedrijf, bepaalt dit protocol hoe die agents straks met je medewerkers en klanten praten via je software.
• Wat je ermee kunt: Vraag je softwareleverancier of ontwikkelaar of ze AG-UI ondersteunen — dat voorkomt vendor lock-in bij het inbouwen van AI-agents.

Ik kwam een tweet tegen van Santiago Valdarrama (@svpino) over het AG-UI-protocol. Zijn stelling: elk groot techbedrijf gebruikt dit inmiddels. Dat triggerde mij om uit te zoeken wat AG-UI precies is, en vooral: wat het betekent als je als ondernemer met AI-agents aan de slag wilt.

Wat is AG-UI precies?

AG-UI staat voor Agent-User Interaction Protocol. Het is een open standaard — MIT-licentie, dus vrij te gebruiken — die vastlegt hoe een AI-agent communiceert met de interface die een mens te zien krijgt. Denk aan een chatvenster in je webshop, een dashboard voor je klantenservice, of een interne tool waarmee je medewerkers vragen stellen aan een AI-assistent.

Het protocol is ontstaan uit het werk van CopilotKit, een bedrijf dat tooling bouwt voor AI-copilots. Ze merkten dat iedereen het wiel opnieuw aan het uitvinden was: elke ontwikkelaar bouwde z'n eigen manier om een AI-agent met een gebruikersinterface te laten praten. AG-UI is hun antwoord daarop — en het is inmiddels door de bredere community overgenomen.

Technisch gezien werkt het zo: een AI-agent op de server stuurt een reeks getypeerde berichten (events) naar de voorkant van je applicatie. Er zijn zo'n zestien standaard event-types, zoals "tekst wordt gegenereerd", "tool wordt aangeroepen", "taak is klaar" of "er is een fout". Vergelijk het met een postbode die niet één grote envelop aflevert, maar je stap voor stap vertelt wat er in het pakket zit terwijl hij het uitpakt.

Het Protocol-Drieluik: MCP, A2A en AG-UI

Wat ik interessant vind, is dat AG-UI niet op zichzelf staat. Er tekent zich een soort drieluik af van protocollen voor AI-agents:

• MCP (Model Context Protocol) — regelt hoe een agent tools en databronnen gebruikt. Stel dat je agent je voorraadsysteem moet raadplegen: dat loopt via MCP.
• A2A (Agent-to-Agent) — regelt hoe agents onderling samenwerken. Denk aan een planningsagent die een inkoopagent aanstuurt.
• AG-UI — regelt hoe de agent communiceert met de mens aan het scherm.

Deze drie protocollen concurreren niet met elkaar. Ze vullen elkaar aan. Een compleet systeem zou alle drie kunnen gebruiken: MCP om je database te benaderen, A2A om taken te delegeren tussen agents, en AG-UI om de gebruiker in real-time te laten zien wat er gebeurt.

Voor mij maakt dit drieluik duidelijk dat we niet meer in de fase zitten van "kijken of AI iets kan". Er worden standaarden gebouwd voor hoe AI-systemen structureel in bedrijfssoftware passen.

Wie zit erachter?

De tweet van Valdarrama noemt grote namen: Anthropic, Google, AWS, Microsoft, LangChain, Mastra, Pydantic. Ik wilde weten of dat klopt, dus ik ben gaan zoeken.

Wat ik kan bevestigen:

• Google's ADK (Agent Development Kit) heeft een officiële integratie met AG-UI.
• AWS Bedrock AgentCore Runtime ondersteunt AG-UI sinds maart 2026.
• Microsoft Agent Framework biedt documentatie over AG-UI-integratie — te vinden op hun Nederlandse learn-pagina.
• Er zijn SDK's beschikbaar in TypeScript, Python, Kotlin, Java en Golang, met Rust in ontwikkeling.
• Het project had op het moment van de bronartikelen meer dan 9.000 GitHub-sterren en 120.000 wekelijkse installaties.

Dat is behoorlijk breed. Ik wil wel een kanttekening plaatsen: "gebruiken" kan variëren van "volledig geïntegreerd in productie" tot "experimentele ondersteuning". De tweet suggereert dat iedereen er al mee werkt. De werkelijkheid is volgens mij genuanceerder — maar de richting is duidelijk.

Wat betekent dit voor jou als ondernemer?

Oké, protocollen en event-types — dat klinkt als ontwikkelaarsjargon. Maar er zit een heel praktische laag onder.

Stel dat je als ondernemer een AI-agent wilt inzetten voor je klantenservice. Die agent moet antwoorden genereren, je CRM raadplegen, en de klant in real-time laten zien dat er aan een antwoord wordt gewerkt. Zonder een standaardprotocol bouw je dat helemaal zelf, of je bent afhankelijk van één leverancier die het op zijn manier doet.

Met AG-UI als standaard wordt het makkelijker om:

Leveranciers te wisselen

Als je agent-backend AG-UI spreekt en je frontend ook, kun je de ene agent vervangen door een andere zonder je hele interface opnieuw te bouwen. Vergelijk het met een USB-standaard: je hoeft niet voor elke muis een andere poort te hebben.

Agents aan bestaande software te koppelen

Omdat AG-UI een open protocol is, kunnen softwareleveranciers het inbouwen in hun bestaande producten. Dat maakt het realistischer dat je boekhoudpakket, je webshop of je planningssysteem straks een agent-interface krijgt die gewoon werkt.

Controle te houden

Eén van de event-types in AG-UI ondersteunt zogenaamde human-in-the-loop workflows. Dat betekent dat de agent op bepaalde momenten pauzeert en de mens om goedkeuring vraagt. Voor een ondernemer die niet wil dat een AI zelfstandig orders plaatst of klanten mailt, is dat een belangrijke eigenschap.

Kun je je voorstellen wat dit betekent als je drie verschillende AI-tools gebruikt die allemaal dezelfde "taal" spreken naar je medewerkers toe? Dat scheelt integratie-hoofdpijn.

Kanttekeningen

Ik wil eerlijk zijn: AG-UI is nog relatief jong. Het protocol is pas in 2025 als open standaard gepubliceerd. Dat het door grote partijen wordt opgepikt is een sterk signaal, maar het betekent niet dat het al overal de norm is.

Daarnaast is het belangrijk om te beseffen dat een protocol geen product is. AG-UI zegt niets over hoe slim je agent is, hoe goed je data op orde is, of hoe je privacy regelt. Het is de afspraak over hoe berichten worden uitgewisseld — niet meer en niet minder.

En voor de volledigheid: CopilotKit — de oorspronkelijke maker — is uiteraard niet neutraal. Ze hebben er belang bij dat hun protocol de standaard wordt. Dat is niet erg, maar het is goed om het te weten.

Tot slot

Wat mij opvalt aan AG-UI is niet zozeer het protocol zelf, maar wat het vertelt over de fase waarin we zitten. Er worden infrastructurele standaarden gebouwd voor AI-agents — het soort onzichtbare afspraken dat ervoor zorgt dat technologie uiteindelijk gewoon werkt, zoals HTTP dat deed voor het web.

Voor mij is dit vooral een signaal dat AI-agents geen hype meer zijn die je kunt negeren, maar iets waar serieuze infrastructuur omheen wordt gelegd. En als je de komende jaren software laat bouwen of aanschaft voor je bedrijf, is het geen gekke vraag om te stellen: ondersteunt dit AG-UI?