Qwen3.8-27B: lokale AI-prestaties en eerste tests

De grootste lokale AI-release van deze week is niet “Owen 3.8 27B”. Het is Qwen3.8-27B, een compact multimodaal model met 27 miljard parameters en een native contextvenster van 262.144 tokens. De eerste resultaten wijzen op bruikbare lokale prestaties, snelle ondersteuning voor quants en voldoende tegenstrijdig bewijs om te concluderen dat een definitieve rangschikking nog voorbarig is.

Qwen3.8-27B verscheen met een native contextvenster van 262K

Om te beginnen de feiten die van invloed zijn op implementatiebeslissingen:

De modelgewichten verschenen op 14 augustus. Daardoor zijn de meeste claims uit de releaseweek gebaseerd op ongeveer één dag aan openbare tests. De megathread van de releasedag verzamelde vrijwel direct modelgewichten, gequantiseerde bestanden, templates, installatie-instructies en eerste indrukken.

Het onderscheid tussen native context en uitgebreide context is belangrijk. Native ondersteuning betekent dat het model is ontworpen om die sequentielengte te verwerken. Een configuratie voor één miljoen tokens kan afhankelijk zijn van positionele schaling en geschikte runtime-ondersteuning. Een groot geadverteerd contextvenster betekent bovendien niet dat elke lokale machine het ook daadwerkelijk kan benutten. De key-value-cache groeit mee met de sequentielengte. Een systeem dat het model zonder context probleemloos laadt, kan tijdens een lange sessie dus alsnog zonder geheugen komen te zitten.

Waarom dit belangrijk is: Qwen3.8-27B brengt multimodale inferentie met een lange context dichter bij lokale hardware, maar het volledige contextvenster blijft op systeemniveau een geheugenvraagstuk.

Een build van 17 GB verlaagt de instapdrempel, niet de operationele kosten

De claim over lokale implementatie die de meeste aandacht krijgt, is eenvoudig: een dynamische quant van Unsloth kan naar verluidt draaien met 17 GB RAM. In de releaseaankondiging van Unsloth werden ook GGUF- en NVFP4-builds uitgelicht.

Beschouw dat getal als de ondergrens om het model te laden, niet als een volledige hardwareaanbeveling. De modelgewichten moeten het geheugen delen met de runtime, de contextcache, multimodale invoer, het besturingssysteem en een eventuele grafische interface. Een machine met 17 GB beschikbaar geheugen kan mogelijk een gecomprimeerde build laden, maar houdt weinig ruimte over voor lange prompts. Ook kunnen lagen tussen CPU en GPU worden uitgewisseld, waardoor de generatie trager verloopt dan bij een configuratie die volledig in het GPU-geheugen past.

Dat levert drie praktische hardwareniveaus op:

Het opvallende aan deze release is niet alleen dat een 27B-model kan worden gecomprimeerd. Vooral de snelheid waarmee verschillende verpakkingsopties beschikbaar kwamen, springt eruit. Daardoor werd de periode tussen publicatie van de modelgewichten en echte lokale tests aanzienlijk korter.

Die snelheid heeft ook een keerzijde. Vroege bestanden kunnen verschillende quantisatiemethoden, kalibratiekeuzes, chattemplates of runtime-aannames gebruiken. Twee bestanden van vergelijkbare grootte kunnen daardoor merkbaar verschillen in uitvoerkwaliteit.

Waarom dit belangrijk is: De grens van 17 GB maakt het model toegankelijker, maar teams hebben nog steeds geheugenmarge en werklastspecifieke tests nodig voordat ze een configuratie werkelijk bruikbaar kunnen noemen.

De kwaliteit van quants lijkt onder 10 GB sterk af te nemen

Kies een quant van Qwen3.8-27B niet uitsluitend op basis van de bestandsgrootte. Uit een gecontroleerde vergelijking van 36 quantisaties met dezelfde BF16-logits bleek dat de kwaliteit onder 10 GB sterk afneemt. Volgens het quantonderzoek met vier RTX 5090's verschilden Q6- en Q8-bestanden van meer dan 25 GB alleen binnen de meetruis.

Dat wijst op een scherpe compressiegrens in plaats van een geleidelijke kwaliteitscurve. De laatste paar gigabytes besparen aan de onderkant kan meer modelkwaliteit kosten dan overstappen tussen twee grotere quantniveaus.

Het gemelde resultaat legt ook een veelgemaakte evaluatiefout bloot. Perplexiteit of gelijkenis tussen logits kan schade door compressie aantonen, maar geen van beide bewijst dat twee quants zich hetzelfde gedragen bij programmeren, toolgebruik, beeldverwerking of retrieval over een lange context.

De beste aanpak is om te beginnen met de grootste quant die nog voldoende geheugen overlaat voor de beoogde context. Vergelijk vervolgens kleinere builds met vaste prompts, deterministische instellingen en taakspecifieke scores. Voor een programmeerassistent kan die testset bestaan uit navigatie door repositories, het genereren van patches, het herstellen van tests en het opvolgen van instructies. Bij documentanalyse horen daar tests voor correcte bronverwijzingen, retrieval vanaf ver uit elkaar liggende contextposities en het percentage niet-onderbouwde claims bij.

Op basis van de eerste resultaten zijn vooral Q5 en Q6 relevante vergelijkingspunten. Q5 kan meer werkgeheugen vrijhouden, terwijl Q6 een stabielere uitvoer kan bieden als het systeem voldoende capaciteit heeft.

Waarom dit belangrijk is: Qwen3.8-27B lijkt een praktische ondergrens voor compressie te hebben. Extreme quantisatie kan daardoor juist de mogelijkheden aantasten waarvoor gebruikers het model lokaal wilden draaien.

Strix Halo haalde 10,5 tokens per seconde met een Q5-quant van 20 GB

Een Strix Halo-systeem met 128 GB geheugen genereerde bij een lege context 10,5 tokens per seconde met een Q5-build van 20 GB. Bij een context van 32K bedroeg de generatiesnelheid 9,4 tokens per seconde in dezelfde Strix Halo-prestatietest.

Dat komt neer op een daling van de generatiesnelheid met ongeveer 10 procent tussen een lege context en een context van 32K. Dit resultaat is nuttiger dan alleen een piekwaarde bij een lege context, omdat tokens zich tijdens echte gesprekken en programmeersessies blijven opstapelen.

De tester meldde ook dat de doorvoer van Q5 binnen 2,5 procent bleef van die van Qwen3.6-27B met dezelfde configuratie. Die vergelijking suggereert dat Qwen3.8-27B op deze hardware mogelijk geen grote snelheidsstraf oplevert ten opzichte van zijn voorganger.

Generatiesnelheid vertelt slechts een deel van het verhaal. Gebruik met een lange context omvat ook promptevaluatie: de fase waarin de runtime de bestaande invoer verwerkt voordat een nieuw token wordt gegenereerd. Een model kan na het inlezen van 32K tokens genereren met 9,4 tokens per seconde, terwijl de verwerking van de oorspronkelijke prompt toch merkbaar lang duurt. Bij repositoryanalyse en workflows met meerdere documenten moet u daarom zowel de tijd tot het eerste token als de stabiele generatiesnelheid meten.

Strix Halo is bovendien een platform met gedeeld geheugen. Een losse GPU met 24 GB VRAM, een Mac met gedeeld geheugen en een workstation dat vooral op de CPU leunt, kunnen andere resultaten opleveren, zelfs als ze allemaal hetzelfde bestand van 20 GB laden.

Voor meer context over de rol van lokale modellen in ontwikkelstacks voor agents kunt u het wekelijkse overzicht van AI- en developertrends raadplegen.

Waarom dit belangrijk is: Qwen3.8-27B behaalt op één consumentenplatform met veel geheugen bruikbare, interactieve snelheden. De doorvoer bij een lege context blijft echter een onvolledige capaciteitsmaatstaf.

Programmeerdemo's ogen capabel, maar bepalen geen rangorde

Twee voorbeelden van de releasedag trokken de aandacht: een webwinkel voor een bakkerij die naar verluidt op een RTX 3090 werd gegenereerd en een speelbare retrogame met tien levels die op een M2 Max met twee prompts tot stand kwam. Deze demonstraties werden verzameld in de belangrijkste discussie over de release van Qwen3.8-27B.

Beide demo's suggereren dat gequantiseerde lokale builds samenhangende softwareprojecten met meerdere bestanden kunnen produceren. Ze laten niet zien of het model consequent fouten herstelt, bestaande architectuur respecteert of de kwaliteit over meerdere runs vasthoudt.

Vooral een gelikte webpagina wordt al snel ten onrechte gezien als een brede programmeerbenchmark. Visuele samenhang kan ongeldige toegankelijkheidsmarkup, onveilige dependencies, dubbele logica of layouts die buiten het vastgelegde viewport mislukken aan het zicht onttrekken.

De game die met twee prompts werd gemaakt, vormt een sterkere test voor statusbeheer en iteratie, maar belangrijke details zijn niet gecontroleerd. De formulering van de prompts, handmatige bestandswijzigingen, runtimefouten en mislukte generaties kunnen de interpretatie wezenlijk veranderen.

Teams die Qwen3.8-27B voor ontwikkelwerk evalueren, hebben een vaste acceptatiesuite nodig. Per taak moeten het slagingspercentage, de testuitvoering, het compilatieresultaat, het tokengebruik, de latency en het aantal correctierondes worden vastgelegd.

Hetzelfde principe geldt voor mediaworkflows die door agents worden aangestuurd. Visueel indrukwekkende uitvoer is minder belangrijk dan herhaalbaarheid, bewerkbare bronbestanden en betrouwbare uitvoering, zoals besproken in de analyse van de video-shotcraft-agentworkflow.

Waarom dit belangrijk is: De eerste demo's bewijzen dat Qwen3.8-27B lokaal omvangrijke projecten kan maken, maar niet dat het model betrouwbare prestaties levert bij softwareontwikkeling.

De benchmarkresultaten zijn nu al tegenstrijdig

De verzamelde modelkaarten vermelden een score van 73,0 op Terminal Bench 2.1 en 61,7 op SWE-bench Pro. Deelnemers aan de gecombineerde benchmarkdiscussie vroegen zich af of deze resultaten vergelijkingen met veel grotere frontiermodellen rechtvaardigen.

Voor een lokaal, compact 27B-model zijn dat sterke scores. Toch zijn de exacte evaluatieharness, prompttemplate, toolconfiguratie, inferentie-instellingen en scoremethode nodig voordat teams de resultaten kunnen reproduceren.

Terminal- en software-engineeringbenchmarks zijn gevoelig voor de agentinfrastructuur eromheen. Een betere retry-loop, betere repositorytools of een andere time-out kan de gemelde score verhogen zonder dat de onderliggende modelgewichten veranderen.

Domeinspecifieke tests maken het verhaal rond de release nog ingewikkelder. In een medische en kennisevaluatie presteerde Qwen3.6-27B beter dan Qwen3.8-27B in zeven van de tien tests, met thinking uitgeschakeld en greedy decoding ingeschakeld. Dat blijkt uit de vergelijking van medische benchmarks.

Bij greedy decoding wordt bij elke stap het token met de hoogste waarschijnlijkheid geselecteerd. Dat verbetert de reproduceerbaarheid, maar door thinking uit te schakelen kunnen mogelijkheden worden onderdrukt waarop het nieuwere model bij complexe vragen rekent. Het medische resultaat bewijst niet dat Qwen3.8-27B over de hele linie zwakker is. Het laat zien dat een nieuwer model op specifieke domeinen of in bepaalde inferentiemodi achteruit kan gaan, zelfs als de geaggregeerde scores op de modelkaart stijgen.

Het patroon dat zich aftekent, is een verschuiving van mogelijkheden, geen universele verbetering. Qwen3.8-27B kan vooruitgang boeken bij agentgestuurd programmeren of multimodale taken, maar tegelijkertijd terrein verliezen bij specifieke kennistests of inferentie-instellingen.

Waarom dit belangrijk is: Het benchmarkverhaal is nog niet compleet. Implementatiebeslissingen moeten daarom worden gebaseerd op evaluaties per taak, niet op één positie in een ranglijst.

MTP-ondersteuning kan de snelheidsverhoudingen veranderen

Gebruikers melden dat multi-token prediction, oftewel MTP, werkt met de huidige GGUF-builds. Dat blijkt uit meldingen die zijn verzameld in de thread met ervaringen rond de release.

Met MTP kan een draftcomponent meerdere toekomstige tokens voorstellen, die vervolgens door het hoofdmodel worden gecontroleerd. De mogelijke snelheidswinst hangt af van het acceptatiepercentage. Als het hoofdmodel veel voorgestelde tokens accepteert, neemt de uitvoersnelheid toe. Als het model ze vaak afwijst, kan de extra verificatielast een groot deel van de winst tenietdoen.

Ook de hardware beïnvloedt het resultaat. Een systeem dat wordt beperkt door geheugenbandbreedte kan anders profiteren dan een GPU die tegen zijn rekenlimiet aanloopt. Tegelijkertijd hebben de contextlengte en batchgrootte invloed op zowel de draft- als de verificatiefase.

Gemelde aantallen tokens per seconde zijn alleen vergelijkbaar als de tests de MTP-status, draftconfiguratie, contextlengte, het quanttype, de runtimeversie en samplinginstellingen vermelden. Een gewone Q5-meting en een Q5-meting met MTP gebruiken verschillende inferentiepaden.

MTP kan bovendien de geheugenbehoefte vergroten. De draftgewichten, buffers en het verificatieproces hebben ruimte nodig die anders beschikbaar zou zijn voor een langere context of een quant van hogere kwaliteit.

Waarom dit belangrijk is: MTP kan de volgende betekenisvolle lokale snelheidswinst opleveren, maar ongedocumenteerde instellingen kunnen prestatievergelijkingen misleidend maken.

Praktische stappen

Begin hier

Download één quant van Qwen3.8-27B die ten minste 20 procent van het systeemgeheugen vrijlaat en voer vervolgens vijf representatieve taken uit met een contextlimiet van 8K.

Snel resultaat

• Meet met dezelfde prompt de tijd tot het eerste token en de generatiesnelheid bij een lege context en bij een context van 8K en 32K.
• Vergelijk één Q5- en één Q6-build met tien deterministische taken. Tel vervolgens het exacte aantal geslaagde taken in plaats van de uitvoer informeel te beoordelen.

De diepte in

• Stel een evaluatieset van 30 taken samen die het opvolgen van instructies, programmeren, retrieval over een lange context en beheersing van hallucinaties bestrijkt.
• Herhaal de evaluatie met thinking in- en uitgeschakeld. Zo kunt u veranderingen in modelcapaciteiten scheiden van veranderingen door inferentie-instellingen.

Nuttige bronnen

• Qwen3.8-27B Release-Day Megathread - Centrale index voor modelgewichten, formaten, templates, configuratierapporten en eerste tests.
• Unsloth Qwen3.8-27B Builds - Release-informatie voor dynamische GGUF- en NVFP4-varianten.
• Qwen3.8-27B Quant Comparison - Gecontroleerde vergelijking van 36 gequantiseerde builds met BF16-logits.
• Strix Halo Performance Results - Q5- en Q8-metingen bij een lege context en een context van 32K.
• Qwen3.8-27B Medical Evaluation - Vroege domeinvergelijking met Qwen3.6-27B onder gecontroleerde decoding.

Om in de gaten te houden

• Onafhankelijke reproductie van de gemelde score van 73,0 op Terminal Bench 2.1.
• Nauwkeurigheid van retrieval over een lange context vlak bij de native limiet van 262.144 tokens.
• Geheugen- en latencygegevens voor de uitbreiding naar één miljoen tokens.
• MTP-snelheidswinst op CUDA, Apple Silicon en AMD-systemen met gedeeld geheugen.
• Herhaalbare vergelijkingen tussen Qwen3.8-27B en Qwen3.6-27B met identieke templates en runtimes.

Conclusie

Qwen3.8-27B is nu al een belangrijke release voor lokaal gebruik. Het model combineert 27 miljard actieve parameters, multimodale ondersteuning, een native context van 262K en gequantiseerde builds die al met 17 GB RAM kunnen worden geladen. Een Q5-build van 20 GB behaalde bovendien 10,5 tokens per seconde op een Strix Halo-systeem met 128 GB geheugen.

Het bewijs is echter nog steeds afkomstig van de releasedag. Agressieve quants gaan snel in kwaliteit achteruit, programmeerdemo's blijven anekdotisch, medische tests laten regressies zien en opvallende benchmarkscores moeten nog onafhankelijk worden gereproduceerd.

Wat is dus de belangrijkste conclusie? Qwen3.8-27B lijkt praktisch genoeg om nu te testen, maar is nog niet volwassen genoeg voor een overtuigende rangschikking. De komende week met gecontroleerde evaluaties zal zwaarder wegen dan de eerste dag vol screenshots en vergelijkingen van ranglijsten.