Muse Glimmer haalt 230 tokens/s op een enkele RTX 5090: SGLang-day-0-ondersteuning is het echte verhaal achter de lancering

Tweehonderddertig tokens per seconde is een hoog aantal voor elk model. Voor Muse Glimmer — Meta's 30B dense, open-gewichten-release van Meta Superintelligence Labs, die op 10 augustus 2026 onder Apache 2.0 werd uitgebracht — is het het getal dat een model dat 'op mijn GPU draait' scheidt van een model dat 'een echte agent bedient'. Op dezelfde dag dat de gewichten beschikbaar kwamen, kondigde SGLang dag-0-ondersteuning voor Muse Glimmer aan, en de gepubliceerde meting op een enkele GeForce RTX 5090 is 236,4 tokens per seconde per gebruiker bij batch 1, met NVFP4-kwantalisatie en Meta's DFlash-drafter voor speculatief decoderen beide ingeschakeld.

Dat ene cijfer vertelt het grootste deel van het verhaal achter deze release, maar het is de moeite waard om bij de rest stil te staan, want het interessante is niet de snelheid die de koppen haalt. Het interessante is dat het model ook direct uit de doos werkt op een RTX PRO 6000, op een NVIDIA DGX Spark en op Apple silicon via MLX — en dat SGLang het werk een samenwerking met Meta Superintelligence Labs noemt in plaats van een achteraf bedacht community-idee. Dit is het eerste Meta-model in lange tijd dat dicht bij de frontier staat en is ontworpen rond de serving-stack, niet alleen rond de gewichten.

Wat "day-0 support" hier eigenlijk betekent

Day-0-ondersteuning in SGLang v0.5.17 betekent dat het model niet achteraf is vastgeschroefd: de runtime-werkzaamheden vielen in hetzelfde releasevenster als de gewichten, met een speciaal gebouwd pad voor de hardware waar Meta daadwerkelijk op mikt. De SM120-backend van SGLang bestrijkt de Blackwell-desktop- en workstationlijn — de RTX 5090, de RTX PRO 6000 en de DGX Spark draaien allemaal hetzelfde geoptimaliseerde pad — terwijl Apple silicon een native MLX-backend krijgt in plaats van een langzame port.

De stack waar SGLang en Meta op hebben getuned, is specifiek. Het model draait als een 18GB NVFP4-checkpoint, samen met een 5GB BF16 DFlash-drafter – het speculatieve-decodering-companionmodel dat Meta voor Muse Glimmer heeft getraind. Die combinatie past met ruimte over in een 32GB-kaart, en het volledige NVFP4-plus-MXFP8-gemengde-kwantisatietraject komt neer op ongeveer 19,5GB aan resident geheugen. Aan de SGLang-kant noemen de release notes drie betrouwbaarheidsmechanismen als onderdeel van hetzelfde verhaal: DFlash-speculatieve decodering, RadixAttention voor prefix-caching en onderbreekbare CUDA-graphs.

Het nummer, en wat het wel en niet is

De door SGLang gepubliceerde RTX 5090-cijfers, allemaal met NVFP4 en het SM120-pad, splitsen zich als volgt op:

• Decodering voor één gebruiker (batch 1) — 63.9 tokens/s standaard, 236.4 tokens/s met DFlash speculatieve decodering. Die 3.7x verbetering is het interactieve getal, het getal dat bepaalt of een lokale agent aanvoelt als een gesprek of als een wachtrij.

• Geaggregeerde output (batch 8) — 501 tokens/s standaard, 1.452 tokens/s met DFlash. Dit is het doorvoergetal voor een lokale server die meerdere verzoeken tegelijk afhandelt.

• Ter vergelijking: een GGUF q4_k_m op dezelfde GPU — het pad dat de meeste mensen zullen gebruiken met llama.cpp-achtige runtimes — haalt 72.6 tokens/s standaard en 140.7 tokens/s met DFlash. Het NVFP4-pad ligt aanzienlijk voor.

Dit zijn de door SGLang en Meta gepubliceerde cijfers vanaf de lancering, geen onafhankelijke reproducties — het eerlijke label is door leverancier en framework gerapporteerd, en community-verificatie zal in de komende weken volgen. Maar het patroon over de twee stacks die cijfers hebben aangekondigd is consistent. In llama.cpp rapporteerde Meta 74,9 tot 233,4 tokens/s op een RTX 5090 met DFlash, een 3,1x verbetering; de M5 Max gaat van 26,6 naar 50,2; de M4 Max van 23,7 naar 37,8. Twee verschillende runtimes, twee verschillende meetmethoden, dezelfde grootteorde: een 30B-model dat met meer dan 200 tokens per seconde decodeert op een enkele consumenten-GPU, en DFlash dat de doorvoer op elke Nvidia-opstelling met gepubliceerde cijfers ruwweg verdrievoudigt.

Waarom "serves" belangrijker is dan "runs"

De hardwareblog van Meta doet een scherpere bewering dan de desktopcijfers. Bij NVIDIA Blackwell Ultra — de datacenter-generatie, niet de desktopkaart — citeert de blog meer dan 20.000 tokens per seconde per GPU op BF16/NVF4, waarbij zowel SGLang als vLLM worden genoemd als ondersteunde open-source stacks. Dat is een andere klasse, en het is de aanwijzing voor wat Meta werkelijk bouwt: dezelfde gewichten zijn bedoeld om overal te draaien, van een laptop tot een GPU-serverrack, en de serving-frameworks werden vanaf dag één als eersteklas behandeld, in plaats van als ports die later geschreven moesten worden.

De betrouwbaarheidshelft van het verhaal is net zo belangrijk als de snelheid. Een lokale agent die halverwege een taak crasht omdat de servicelaag haperde, is niet wezenlijk beter dan een cloudagent die te maken kreeg met rate-limiting. De mechanismen in de day-0-stack — speculatieve decodering die onderbreekbaar is, prefixcaching die lange agentcontexten goedkoop maakt om opnieuw te betreden, en een draftmodel dat is afgestemd op het basismodel — zijn precies de onderdelen die altijd-actieve lokale agenten kunnen laten overleven. Dit is de 'snelheid en betrouwbaarheid' waarnaar de lancering heeft gewezen, en het is een echt technisch standpunt, geen marketingterm.

Wat je er eigenlijk mee kunt doen

Muse Glimmer is een 30B dicht multimodaal model — tekst- en beeldinvoer via een bevroren perceptie-encoder, tekstuitvoer — getraind in meer dan 100 talen, met een contextvenster van 131.072 tokens en een kennisafsluitdatum van 4 januari 2026. Zijn opdracht is het onopvallende agentwerk: functieaanroepen, toolgebruik, agenda- en bestandsbeheer, LLM-als-beoordelaar-evaluatie en meerstapstaken met foutherstel — wanneer een toolaanroep faalt, is het model getraind om te diagnosticeren en opnieuw te proberen in plaats van te stoppen. Het biedt redeneerinspanningsniveaus (laag tot xhoog) die je instelt in de systeemprompt, waarmee je latentie tegen diepte kunt afwegen op dezelfde gewichten.

Het cijfer van 230 tokens per seconde is wat dat alles bruikbaar maakt op één machine. Onder ruwweg 50 tokens/s voelt een interactieve agent aan als een externe foutopsporingssessie; boven de 200 voelt het als een lokaal hulpmiddel. Dat is het hele argument voor het model in één getal, en het is de reden dat de hardwarelijst — RTX 5090, RTX PRO 6000, DGX Spark, MLX Macs — leest als een koopgids voor het lokale-agenttijdperk in plaats van een compatibiliteitsvoetnoot.

Wat het kost

Muse Glimmer zelf is gratis — Apache 2.0-gewichten op Hugging Face onder meta-models/Muse-Glimmer-30B, met GGUF-kwantizaties die al zijn gepubliceerd voor llama.cpp-achtige runtimes en geen openbare Meta API. De echte kosten zitten in de hardware eronder: een NVFP4-checkpoint van 18 GB plus de drafter van 5 GB betekent dat je een kaart van 24 GB of 32 GB nodig hebt, of een high-end M-series Mac. Als je die al bezit, zijn de marginale kosten van een altijd-aan lokale agent elektriciteit. Zo niet, dan is de GPU de kostenpost, en dat is de eerlijke manier om een "gratis model" te vergelijken met een gehoste API.

Wanneer u die vergelijking maakt, bereken beide kanten eerlijk. Bij OrcaRouter is de prijs die u ziet voor elk van de meer dan 200 gehoste modellen de catalogusprijs van de aanbieder, doorberekend met 0% opslag, dus een prijsverlaging van de leverancier is hier dezelfde dag live — dat houdt de lokale-versus-gehoste rekenkunde eerlijk. Muse Glimmer zelf staat vandaag niet op OrcaRouter, omdat geen enkele inferentieprovider het nog aanbiedt; het wordt geleverd als download. Op het moment dat een provider het wel gaat aanbieden, zal dezelfde sleutel die de rest van de catalogus bereikt ook dit model bereiken, en automatische failover is het mechanisme dat het veilig maakt om productieverkeer te richten op een gloednieuw, door de leverancier gerapporteerd model voordat het een onafhankelijke staat van dienst heeft.

Het grotere verhaal achter de snelheid

Lees de day-0 SGLang-ondersteuning als een signaal, en de release is niet langer een enkel model. Muse Glimmer is een gedistilleerde versie van Meta's propriëtaire vlaggenschip Muse Spark 1.2, en Meta heeft gezegd dat de gewichten van het teachermodel 'in de komende weken' komen. Een 30B lokale agent met een afgestemde serving-stack, een teachermodel dat binnenkort open-source gaat, en een communityfonds van $1 miljard dat er samen mee is aangekondigd — dat is geen point release. Dat is het begin van een open-weight line-up die zich rechtstreeks op de lokale-agentmarkt richt, en de framework-ondersteuning die op dag één landt, is het deel dat zegt dat Meta wil dat mensen het ook echt draaien, niet alleen downloaden.

De kanttekening die we niet uit het oog mogen verliezen: elk snelheids- en benchmarkcijfer dat tot nu toe aan deze lancering is gekoppeld, is door de leverancier of het framework gerapporteerd. De doorvoercijfers zijn consistent over twee onafhankelijke stacks, wat geruststellend is, maar het zijn onafhankelijke benchmarks, een Artificial Analysis-notering en reproducties in de praktijk die het verhaal van 230 tokens per seconde moeten bevestigen — en die verschijnen meestal binnen enkele weken na een release als deze.

Waar je op moet letten, grofweg in volgorde van snelheid: de Muse Spark 1.2 open-weights-release (de strategische interpretatie van 'Meta is terug' hangt ervan af); de eerste onafhankelijke throughput-reproducties op non-Nvidia-hardware, waar vooral het MLX-pad in de gaten moet worden gehouden; en de eerste inference-provider die een Glimmer-endpoint opzet — dat is het moment waarop de argumenten 'gratis lokaal model' en 'gehoste API' ophouden hypothetisch te zijn en een keuze worden die je met één toets kunt maken.