A2UI uitgelegd: wat het Agent-to-UI-protocol doet (en niet).
A2UI is een declaratief JSON-protocol waarmee AI-agents interfaces kunnen beschrijven die een client kan weergeven. Hoe het werkt, welke renderers er zijn en wat het niet doet.
Kern afhaalmaaltijd
A2UI (Agent to UI) is een open, declaratief JSON-protocol gemaakt door Google. Een AI-agent verzendt een beschrijving van een interface en een client geeft deze weer met zijn eigen native componenten in plaats van code van de agent uit te voeren. Het is een manier om de UI-structuur en gegevens over een vertrouwensgrens te verplaatsen, en niet over een animatiesysteem, een componentenbibliotheek of een voltooide renderer. ExodeUI is geen A2UI-renderer en is niet gelieerd aan Google.
Wat is A2UI?
A2UI is een protocol voor agentgestuurde interfaces. In plaats van een muur met tekst terug te sturen of gegenereerde code uit te voeren, verzendt een AI-agent een stroom JSON-berichten die een gebruikersinterface beschrijven: welk oppervlak moet worden gemaakt, welke componenten het bevat en welke gegevens deze vullen. De client ontvangt deze berichten en geeft het resultaat weer met componenten die hij al vertrouwt. A2UI is gemaakt door Google en heeft een Apache 2.0-licentie, met bijdragen van CopilotKit en de open-sourcegemeenschap. Vanaf oktober 2026 was de huidige productiespecificatie v0.9.1 en was v1.0 een release candidate.
Het probleem dat A2UI probeert op te lossen
Agenten zijn goed in het produceren van een nuttig antwoord, maar slecht in het leveren ervan als interface. Een tekstantwoord kan geen vergelijkingstabel, bestelformulier of dashboard tonen. Het genereren van willekeurige HTML of JavaScript lost het presentatieprobleem op en creëert een beveiligingsprobleem, omdat de client nu code uitvoert die hij niet heeft geschreven. A2UI kiest een derde route: de agent beschrijft de gebruikersinterface in een beperkt formaat en de client beslist hoe deze wordt weergegeven. De agent kan alleen componenten gebruiken die de klant heeft goedgekeurd, en de uitvoer bestaat uit gegevens in plaats van uitvoerbare code.
Hoe een A2UI-oppervlak wordt gebouwd
Het protocol maakt gebruik van een kleine set berichttypen. Het exacte schema verandert tussen versies, dus controleer de specificatie voordat u er een implementeert, maar de vorm is stabiel.
- createSurface: vertelt de renderer om een nieuw oppervlak te maken, een gebied van de interface dat de agent kan bijwerken
- updateComponents: voegt componentdefinities op dat oppervlak toe of wijzigt deze
- updateDataModel: wijzigt de gegevens die de componenten weergeven, zonder de structuur opnieuw te verzenden
- deleteSurface: verwijdert een oppervlak wanneer het niet langer nodig is
Renderers en transporten
A2UI is transportonafhankelijk. De specificatie beschrijft de berichten, niet hoe ze reizen. Het project bevat renderer-implementaties voor Angular, Flutter, Lit, React en Markdown, en transportbindingen voor AG-UI, A2A en MCP, waarbij WebSockets, SSE en REST ook bruikbaar zijn. Die flexibiliteit is het punt: dezelfde agentreactie kan worden weergegeven door een webclient, een mobiele app of een desktopapplicatie, elk met behulp van zijn eigen ontwerpsysteem.
Wat A2UI niet doet
A2UI is gemakkelijk te overlezen. Het levert geen componentenbibliotheek die je in een app kunt plaatsen, en het rendert op zichzelf niets: je hebt een renderer en een componentencatalogus nodig die door de client wordt beheerd. Het bepaalt niet hoe de gebruikersinterface beweegt. Het vervangt niet MCP, dat tools en gegevens aan een model blootstelt, of AG-UI, dat de interactiegebeurtenissen tussen een agent en een frontend overdraagt. En het neemt de noodzaak van technische beoordeling niet weg: gegenereerde interfaces moeten nog steeds de laad-, leeg- en foutstatussen, machtigingen en toegankelijkheid afhandelen.
A2UI versus AG-UI versus MCP
Deze drie worden vaak samen genoemd omdat ze verschillende lagen van hetzelfde probleem oplossen. Een handige afkorting: A2UI beschrijft de interface, AG-UI verzorgt de interactie en MCP geeft de agent tools en gegevens. De eigen documentatie van A2UI beschrijft AG-UI als een transportbinding voor A2UI, en A2UI kan ook over MCP reizen. Het zijn complementaire en geen concurrerende normen. Als u voor een integratie kiest, ga dan uit van wat uw klant kan weergeven en welk transport deze al ondersteunt, niet van het protocol met de meeste dynamiek.
Waar animatie en interactie passen
A2UI beschrijft structuur en gegevens. Beweging is een zorg van de klant: de renderer beslist of een oppervlak onmiddellijk verschijnt, vervaagt of overgaat van een vorige staat. Dat is goed nieuws voor productteams, omdat het animatiesysteem in de klant blijft waar het het ontwerpsysteem en de toegankelijkheidsinstellingen kan respecteren. Het betekent ook dat een A2UI-implementatie niet automatisch wordt geanimeerd. Als een gegenereerde interface een druk op de knop, een statusovergang of een mascottereactie nodig heeft, moet de klant voor dat gedrag zorgen. ExodeUI kan interactieve bewegingen in een client afspelen en heeft een MCP-server voor AI-coderingstools, maar het is geen A2UI-renderer en mag ook niet als één worden omschreven.
Productie-implementatiefragment
// Simplified shape of an A2UI message stream (schema differs by version).
{ "createSurface": { "surfaceId": "cart" } }
{ "updateComponents": { "surfaceId": "cart", "components": [ /* ... */ ] } }
{ "updateDataModel": { "surfaceId": "cart", "data": { /* ... */ } } }
{ "deleteSurface": { "surfaceId": "cart" } }Toets Principles in om te onthouden
- A2UI is een JSON-protocol voor door agenten beschreven interfaces, gemaakt door Google en gelicentieerd onder Apache 2.0
- De klant rendert met zijn eigen componenten; de agent voert geen willekeurige UI-code uit
- Het definieert berichten en laat de renderer, het transport en de beweging over aan de klant
- Het is geen animatiesysteem of een drop-in componentenbibliotheek
- ExodeUI is geen A2UI-renderer en heeft geen banden met Google