LLaDA-UI stilletjes uitgebracht: Diffusion GUI Agent van inclusionAI is nu downloadbaar

LLaDA-UI — een mixture-of-experts-GUI-agent van inclusionAI met ruwweg 16,7 miljard parameters — verscheen op 6 september 2026 op Hugging Face, zonder aankondiging. Wat het de moeite waard maakt om opnieuw te bekijken, is niet de stilte maar het onderliggende mechanisme: in tegenstelling tot de autoregressieve vision-language-modellen die het computergebruiksonderzoek domineren en hun volgende actie één token tegelijk schrijven, ontruist LLaDA-UI per stap een volledig blok actietokens in diffusiestijl en legt het zich pas daarna op het antwoord vast. De leverancier presenteert het als een praktische, open-gewicht diffusie-GUI-agent. Alle onderstaande onderdelen zijn voorzien van een label dat aangeeft wat ze zijn: repository-feiten die je zelf kunt controleren, beweringen uit het technisch rapport die niemand buiten het lab heeft gereproduceerd, en hiaten — waarvan een ontbrekende licentie de voornaamste is — die nog steeds werkelijk onopgelost zijn.

Het releasekader is belangrijk omdat dit nu een patroon is. inclusionAI is het aan Ant Group gelieerde lab achter de LLaDA-familie van diffusietaalmodellen, en in dezelfde week dat het de LLaDA-Image- en LLaDA-Image-Turbo-beeldcheckpoints (4 september) en het LLaDA2.2-mini-agentmodel (5 september) publiceerde, creëerde het op 6 september de inclusionAI/LLaDA-UI-repository. Drie modelfamilies in drie dagen, geen ervan voorafgegaan door een aankondigingspost. Specifiek voor LLaDA-UI is het bewijs van een daadwerkelijke release de repository zelf: de safetensors-gewichten zijn aanwezig en laadbaar, de inferentiecode en een SGLang-servingrecept worden meegeleverd, en er bestaan een technisch rapport en een projectpagina. Wat er niet is, is een aankondiging van de leverancier, een licentie, of — op het moment van schrijven, met downloads nog in de enkele cijfers — enig teken dat de bredere wereld het al heeft opgemerkt.

Verzonden, maar niet aangekondigd.

De repository inclusionAI/LLaDA-UI is op 6 september om 05:08 UTC aangemaakt en is een complete, op zichzelf staande modeluitgave in plaats van een placeholder. Er staan eenentwintig bestanden in de boom: zeven BF16-safetensors-shards die samen ongeveer 16,9 miljard parameters bevatten (de modelkaart rondt af naar ~16.7B totaal), de tokenizer- en configuratiebestanden, en — belangrijker — de eigen Python-broncode van het model (modeling_llada2_vl_moe.py en configuration_llada2_vl.py). De architectuur wordt geregistreerd als LLaDA2MoE_VLForConditionalGeneration onder een modeltype llada2vl, en omdat die bestanden in de repository worden meegeleverd, is dit geen standaard-Transformers-architectuur: om het te laden moet je de aangepaste code ophalen, hetzij door de repository te klonen, hetzij via het remote-code-pad van de hub.

Wat de repository niet bevat, is minstens zo informatief. Er staat geen licentielabel op de modelkaart en er staat geen LICENSE-bestand in de bestandsboom, dus de standaardvraag die een commercieel team als eerste stelt — wat mag ik met deze gewichten doen? — heeft nog geen antwoord. Het paper is een technisch rapport dat als PDF in de GitHub-repository is verspreid en vanaf een projectpagina wordt gelinkt; het is niet op arXiv verschenen (de pagina zegt nog steeds 'SOON'). En er is geen inference-provider te vinden die het model aanbiedt: de Hugging Face-kaart vermeldt geen actieve inference-provider, wat betekent dat LLaDA-UI voorlopig een release is om te downloaden en zelf te hosten, niet iets dat je via een API kunt aanroepen. Wij hosten het ook niet — niets in dit stuk mag worden opgevat als een bewering dat we dat doen.

Een GUI-agent die decodeert als een beeldmodel.

Het ontwerp is het verhaal, dus het loont om precies te zijn over hoe LLaDA-UI verschilt van de autoregressieve GUI-modellen waartegen het wordt afgemeten. Een conventioneel model voor computergebruik — Qwen2.5-VL-7B of Qwen3-VL-8B bijvoorbeeld, of de VLM achter een gehost product voor computergebruik — neemt de schermafbeelding en de instructie aan en voorspelt vervolgens één token tegelijk, van links naar rechts, totdat de actietekenreeks compleet is. De latentie schaalt dus mee met het aantal tokens in het antwoord. LLaDA-UI behandelt de volledige respons daarentegen als een blok dat aanvankelijk is gemaskeerd en geleidelijk wordt gedenoised: elke decoderingstap verfijnt veel tokens parallel, en na een vast aantal stappen (het referentiescript gebruikt 32 stappen met een bloklengte van 32) wordt de volledige redenering-plus-actietekenreeks onthuld. Dat is dezelfde conceptuele stap die het lab bij beeldgeneratie zette, nu toegepast op GUI-acties.

Onder de motorkap bestaat de stack uit: een vision-encoder op native resolutie, een ruimtelijke projector en een diffusietaalmodel. De vision-encoder is een ViT, geïnitialiseerd vanuit SigLIP, voorzien van 2D-roterende positie-embeddings en uitgevoerd op de native beeldverhouding van de schermafbeelding — de kaart stelt een IMAGE_MAX_PIXELS van 12.845.056 in, dus ruwweg 12,8 megapixels aan invoer vóór downscaling, wat eraan bijdraagt dat kleine klikdoelen in dicht opeengepakte desktop-UI's vindbaar blijven. De uitvoer wordt ruimtelijk vier-op-een gegroepeerd en via een tweelaagse MLP-projector geleid naar een taalbackbone: het LLaDA2.0-mini MoE-diffusietaalmodel. Wat de Hugging Face-zijbalk als '17B params' toont, is dus een mixture-of-experts-model; slechts een fractie van de parameters is actief bij een willekeurige forward pass, wat mede verklaart waarom het onderstaande latencyverhaal überhaupt aannemelijk is.

Het trainingsrecept is het vermelden waard omdat het op papier ongewoon zuinig is. Volgens het technisch rapport werd de multimodale backbone voorgetraind op ongeveer 145 miljard tokens in een curriculum van drie fasen — een korte aligneringsfase met alleen projector, gevolgd door volwaardige modelfasen met de nadruk op perceptie en redenering — voordat een GUI-agent-gefinextunde supervisie plaatsvond op meer dan zes miljoen samples uit het UI-Venus-project, dat meer dan 100 Chinese mobiele applicaties, meer dan 70 Engelstalige mobiele applicaties, plus desktop- en webdata omvat. De leverancier stelt dat 145B tokens een fractie is van wat autoregressieve concurrenten verbruikten (het rapport noemt 4,1T voor Qwen2.5-VL en 2,2T voor Qwen3-VL). Beschouw de tokenaantallen en de datasamenstelling als de eigen weergave van het lab; wat onafhankelijk controleerbaar is, is alleen dat het model bestaat en draait.

Wat het daadwerkelijk uitstraalt

LLaDA-UI heeft twee uitvoermodi, en het verschil is belangrijk voor hoe je het in een pipeline zou inpassen. In de grondingsmodus retourneert het model een enkel punt: integercoördinaten genormaliseerd naar een [0, 999]-bereik voor het doelwit, bijv. [742, 186], die het referentiescript ook als een 0-tot-1-fractie afdrukt om te vermenigvuldigen met de breedte en hoogte van het screenshot. Als het gevraagde doelwit niet in de afbeelding aanwezig is, is het model getraind om [-1, -1] te antwoorden in plaats van een locatie te hallucineren — een kleine maar belangrijke betrouwbaarheidseigenschap voor een agent-lus. In de agent/navigatiemodus genereert het model een redeneringstag gevolgd door een gestructureerde actie:

<think>De zoekbalk bevindt zich bovenaan de pagina,{{1}} onder het logo.{{/1}}</think><action>Click(box=(742, 186))</action>

De actiewoordenschat is per platform gedefinieerd — mobiel, desktop en web — en ondanks de veldnaam bevat box een enkele interactiecoördinaat in plaats van een rechthoek. De denk/actie-splitsing is wat het model in staat stelt om zijn beslissing te grondvesten op het huidige scherm voordat het overgaat tot een klik, en de op coördinaten gebaseerde uitvoer is wat het resultaat machine-leesbaar houdt in plaats van een vrije-vorminstructie die een aparte parser moet interpreteren.

De benchmarkclaims, gelabeld

De belangrijkste resultaten uit het technisch rapport zijn een reeks beweringen dat een diffusie-GUI-model autoregressieve modellen verslaat in hun eigen spel. Hieronder exact weergegeven zoals de leverancier ze rapporteert, uit het technisch rapport en de projectpagina — niets hiervan is onafhankelijk gereproduceerd, en de cijfers hieronder zijn LLaDA-UI versus Qwen3-VL-8B, tenzij anders vermeld:

• ScreenSpot-Pro (grounding) — LLaDA-UI 52.9 vs Qwen3-VL-8B 52.7, een nipte voorsprong.

• AndroidWorld (mobiele agent) — LLaDA-UI 53.5 versus Qwen3-VL-8B 47.9.

• MobileWorld (mobiele agent) — LLaDA-UI 25.6 vs Qwen3-VL-8B 9.4, de grootste kloof op het bord.

• WebVoyager (webagent) — LLaDA-UI 56.9 tegen Qwen3-VL-8B 45.2.

Dat zijn vier van de zes gerapporteerde GUI-benchmarks; het rapport geeft eerlijk toe dat LLaDA-UI op de andere twee Qwen3-VL-8B niet verslaat — ScreenSpot-V2 zit dichtbij, en OSWorld-Verified blijft een hiaat, dat de auteurs toeschrijven aan prestatieverlies bij zeer grote screenshots met kleine doelen. Tegenover de oudere Qwen2.5-VL-7B is de claim onvoorwaardelijk: winst op alle zes gerapporteerde benchmarks. Daarnaast is er ook een snelheidsclaim, door het lab gemeten op gepaarde, niet-gecachte serving-runs op identieke hardware: 4,8 tot 6,4 seconden per respons voor LLaDA-UI tegenover 17 tot 53 seconden voor Qwen3-VL-8B, vermeld als gemiddelde versnellingen van 3,58x voor webinvoer, 6,83x voor desktop en 8,95x voor mobiel — terwijl er per aanroep meer tokens worden gegenereerd, aldus het rapport, omdat parallelle blokdecodering het qua kloktijd wint, zelfs wanneer het antwoord langer is.

Lees de claim over latentie met hetzelfde scepticisme als de nauwkeurigheidscijfers. Het parallelle-blokvoordeel van diffusiedecodering is mechanistisch reëel, en de richting van het effect — minder opeenvolgende stappen per antwoord — is consistent met hoe de architectuur werkt, maar versnellingen van 3,6x tot 9x zijn gemeten door de bouwers van het model op zelfgekozen hardware, en die zijn niet gerepliceerd. Ook de nauwkeurigheidsverschillen doen ertoe: OSWorld-Verified is de dichtstbijzijnde benadering van een realistische desktop-agenttest die het veld heeft, en dat is precies waar de auteurs zeggen dat het model worstelt: bij grote schermafbeeldingen met kleine doelen. Een GUI-agent die mobiel en web feilloos aankan maar struikelt bij drukke desktop-UI's, is een specifiek sterkteprofiel, geen algemeen.

Hoe het uit te voeren, en wat er nog ontbreekt

Als je LLaDA-UI zelf wilt uitproberen, geldt: eerst de gewichten. De checkpoint is ongeveer 32 GB in BF16. De referentieomgeving is Python 3.10, PyTorch 2.5.1, Transformers 4.51.0 en FlashAttention 2.7.4.post1, en de quickstart draait een single-image grounding-pass met --gen-length 32 --steps 32 --block-length 32. Serving is mogelijk via SGLang, maar alleen via de eigen launcher van het lab: de repository bevat een serve_llada_ui.sh en een clientscript die uitgaan van LLaDA-UI-specifieke multimodale diffusiepatches, en op de modelkaart staat expliciet dat het niet vanuit een standaard SGLang-installatie gestart kan worden. Grote screenshots kunnen er ook voor zorgen dat de standaard --max-length van 8192 verhoogd moet worden. Dit is een model voor mensen die zich op hun gemak voelen bij het clonen van een repo, het bouwen van FlashAttention tegen hun CUDA-installatie en het debuggen van een diffusie-decode — nog geen API-aanroep met één commando.

Vier dingen zouden veranderen wat een lezer met LLaDA-UI kan doen, en geen daarvan is op dit moment van schrijven gebeurd. Een expliciete licentie zou de commerciële vraag oplossen waarop momenteel geen antwoord bestaat. Een arXiv-inzending zou het technische rapport in de repository omvormen tot iets citeerbaars en door vakgenoten controleerbaars. Een onafhankelijke reproductie van de ScreenSpot-Pro-cijfers via WebVoyager zou de werkelijke capaciteit van de architectuur scheiden van de evaluatie door de auteurs. En een provider die het model daadwerkelijk serveert, zou het testbaar maken zonder een download van 32 GB en een GPU. Als en wanneer die laatste stap gebeurt, wordt de routeringsvraag routine — één API-sleutel voor alle modelcatalogi, de lijstprijzen van de provider doorberekend zonder opslag, en automatische failover zodat een drie dagen oud checkpoint nooit alleen op een productiepad staat. Tot die tijd is LLaDA-UI een ongewoon interessant open-gewichtenmodel om te volgen: een diffusie-GUI-agent met echte benchmarkclaims, een specifieke en eerlijk openbaar gemaakte zwakte, en zonder het juridische of operationele raamwerk dat de meeste teams in staat zou stellen het vandaag te adopteren. Houd de repository in de gaten voor de licentie en het artikel, in die volgorde.