Clef-Flash vs Qwen3-8B: 38 milliseconden tegen de 8B die iedereen al draait

Er is een specifieke, weinig glamoureuze taak die veel teams toevertrouwen aan Qwen3-8B: lees dit ticket, deze logregel, dit formulier, en vertel me in welke van mijn vier buckets het thuishoort. Het is een classificatietaak vermomd als een gesprek, en Qwen3-8B is er goed genoeg in dat niemand de moeite heeft genomen om het te vervangen. Op 30 september 2026 publiceerde Cloudflare de gewichten voor Cloudflare/clef-flash, een 9B-model dat is gebouwd om die ene taak te doen en niets anders, en de interessante vraag is niet of het slimmer is dan Qwen3-8B. Het gaat erom of wat je nu van een 8B-generalist krijgt, het überhaupt waard is om in gegenereerde tokens voor te betalen.

Clef-Flash beantwoordt die vraag met structuur in plaats van een benchmark. Het neemt een toestand en een schema van maximaal 64 getypeerde vragen en retourneert een logit voor elke toegestane optie in één niet-autoregressieve pass — geen tussenliggende tekst, geen parsing, geen uitvoer behalve waarschijnlijkheden. Cloudflare mat hiervoor een mediane requestlatentie van 38,8 ms, tegenover ongeveer 500 ms voor Jev, het beslissingsmodel van TypeSafe waartegen het werd gebenchmarkt. Qwen3-8B staat niet in die tabel, omdat Qwen3-8B dat spel niet speelt: het schrijft een antwoord, en jij leest het.

Wat deze koppeling een volledige vergelijking waard maakt, in plaats van een pagina met specificatieregels, is dat de twee modellen helemaal geen benchmark delen. Elk Clef-Flash-cijfer dat circuleert, is geproduceerd door Cloudflare, op een index die door een concurrent is gepubliceerd, en niemand buiten Cloudflare heeft er ook maar iets van gereproduceerd. Qwen3-8B heeft drie generaties onafhankelijk gebruik achter zich en een openbare staat van dienst waarover je kunt discussiëren. Die asymmetrie, niet het latentieverschil, zou moeten bepalen of je de overstap maakt.

Twee outputcontracten, geen twee maten

De parameteraantallen hier liggen dicht genoeg bij elkaar om een afleiding te vormen — 9B voor Clef-Flash tegenover 8,2B voor Qwen3-8B, waarvan 6,95B niet-embedding. Het verschil dat ertoe doet, is wat elk model mag uitsturen.

Qwen3-8B is een causaal taalmodel. Geef het een supportticket en het produceert tokens, en standaard produceert het eerst een redeneerblok, omdat de denkmodus aanstaat tenzij je die uitschakelt. Het kan classificeren, uitleggen, escaleren, een antwoord opstellen of je vertellen dat je taxonomie een geval mist — allemaal vanuit dezelfde gewichten, zonder dat er een schema nodig is. Op de modelkaart staan 36 lagen, grouped-query attention met 32 query-heads naar 8 KV-heads, 100+ talen en een contextlengte van 32.768 tokens native, uitbreidbaar tot 131.072 via YaRN. Het is het model waar de meeste teams naar grijpen, omdat het het model is dat alles kan.

Clef-Flash is een post-train, geen gesprekspartner. Cloudflare heeft de Qwen3.5-9B-backbone bevroren — inclusief de vision-encoder — en daarbovenop een gezamenlijke schema-head getraind: 243,5 MB aan head-gewichten tegenover vier gesharde backbonebestanden die samen ongeveer 18,8 GB groot zijn. De head leest de laatste verborgen toestanden van de backbone, routeert bewijs vanuit de toestand naar elke vraag en scoort alle opties van alle vragen samen. Beperkingen zijn de functie. Cloudflare beperkt het ertoe alleen waarschijnlijkheden uit te voeren, waardoor het basismodel wel in zijn afstammingslijn voorkomt maar nooit in zijn uitvoer.

Let op wiens afstamming dit is. Clef-Flash stamt af van Qwen3.5-9B, de generatie na de Qwen3-lijn waartoe Qwen3-8B behoort. Dit is dus niet het verhaal van een fine-tune van zijn eigen basis dat een 9B-afgeleide meestal krijgt — het is een andere tak van dezelfde stamboom, opnieuw getraind volgens een ander contract.

Dezelfde taak, op twee manieren uitgevoerd

Beide modellen kunnen een supportticket routeren. Ze falen op verschillende manieren, en die faalwijzen zijn precies wat een migratie kost.

Bij Qwen3-8B zit het werk in de prompt en de parser. Je beschrijft je categorieën, vraagt om er één terug te krijgen en handelt vervolgens het geval af waarin het model teruggeeft: "dit lijkt op facturatie, hoewel het technisch zou kunnen zijn" — een echt antwoord op een echte ambiguïteit die je downstreamcode niet kan verwerken. De eigen richtlijn van de kaart is expliciet: denkmodus moet worden uitgeschakeld voor efficiëntiewerk, greedy decoding verslechtert de output, en wanneer denken aanstaat, moet je het redeneerblok niet meenemen in de geschiedenis met meerdere beurten. Elk van die instructies is een beslissing die een model voor algemene doeleinden je opdringt.

Met Clef-Flash verschuift het werk naar het schema. Je declareert tussen twee en 26 opties per vraag voor een keuzevraag, of tussen twee en 26 niveaus voor een scorevraag, en je krijgt de gekozen optie terug, een waarschijnlijkheid voor elke optie, en een betrouwbaarheidswaarde. Drie details in dat contract zijn meer waard dan het opvallende latentiegetal. Ten eerste: betrouwbaarheid is niet correctheid — de documentatie van Cloudflare zegt duidelijk dat het meet hoe geconcentreerd de waarschijnlijkheden zijn, niet de kans dat het antwoord juist is. Ten tweede: gelijke scores worden beslecht in de volgorde van je opgegeven opties, dus als twee opties echt overlappen, heb je stilzwijgend de beslissing genomen door de lijst te ordenen. Ten derde, en dit is degene die het hardst bijt: er is geen "geen van bovenstaande", tenzij je er zelf een hebt opgenomen. Een beslissingsmodel scoort de opties die het heeft gekregen; een ticket over een privacyverzoek, met een schema van facturatie, technisch en sales, komt terug als de minst slechte van die drie in plaats van als een weigering.

Dat laatste punt snijdt aan twee kanten, en het is de eerlijke kern van deze vergelijking. Qwen3-8B zal je vertellen dat je taxonomie kapot is. Clef-Flash niet, en in een pipeline is dat een echte regressie — het soort dat je een maand later ontdekt in een verkeerd geroute wachtrij. De afweging is echte latentie en echt determinisme tegenover een model dat de vraag kan opwerpen die je niet had bedacht.

Wat de cijfers wel en niet zeggen

De gepubliceerde resultaten van Clef-Flash komen uit de run die Cloudflare uitvoerde met de Jev Decision Index 0.2.1-suite, en dezelfde run vormt de basis voor de blogpost van de leverancier. De sterke cellen verdienen een precieze vermelding: BFCL case-exact 98,8, API-Bank-nauwkeurigheid 93,1, de simulator voor huishoudelijke apparaten op 97,7, ContractNLI macro-F1 84,3, RouterBench geselecteerde kwaliteit 79,9. Op de vier end-to-end bedrijfsworkflows in de eigen evaluatiesuite van TypeSafe scoort Clef-Flash 77,0 op klantenservice, tegenover 76,0 voor Jev en 76,3 voor de grotere 27B Clef, en verliest het bij factuurverwerking met 57,1 tegenover 61,8 voor Jev en 64,7 voor Clef.

De zwakke cellen zijn even informatief als de sterke. CLINC150 met out-of-scope-afhandeling zet Clef-Flash op 66,8 macro-F1, tegenover 97,4 voor de 27B Clef en 89,3 voor Jev — een afgrond van dertig punten op precies de benchmarkvorm die test of een model weet wanneer het moet afzien van een antwoord. When2Call, 65,6 tegenover 81,0 van Jev. GPQA Diamond, 51,0 tegenover 78,3. POP909-CL komt uit op 1,6, een getal dat de kaart niet verklaart.

Nu het deel dat de tabellen je niet zullen vertellen: Qwen3-8B heeft in geen enkele daarvan een rij. Geen van beide modellen is gescoord op de benchmarks van het andere. Het eigen MMLU-cijfer van Clef-Flash, 91,8, en de GSM8K van 67,3 werden geproduceerd via diens harnas voor getypeerde beslissingen, dat niet het harnas is waarop Qwen zijn cijfers heeft gerapporteerd, en het vergelijken van de twee zou een categoriefout zijn vermomd als een vergelijking. De eerlijke positie is dus dat er geen gedeeld scorebord bestaat en dat dit artikel er geen zal verzinnen. Wat bestaat, is een latentieverschil dat de leverancier op zijn eigen infrastructuur heeft gemeten, een kostenstructuur die structureel anders is, en een verzameling Decision Index-cellen die niemand buiten Cloudflare heeft gereproduceerd.

Wat één beslissing kost

De Workers AI-documentatie van Cloudflare vermeldt Clef-Flash tegen $0,09 per miljoen inputtokens en rekent niets voor output, omdat er feitelijk geen output is — het uitgewerkte voorbeeld in de documentatie levert drie outputtokens op voor een verzoek met drie vragen. Een routeringsbeslissing over een ticket van 1.500 tokens kost daarom ongeveer $0,000135 aan input en daarna niets meetbaars. Draai er een miljoen per dag van en je zit op ongeveer $135 per dag, en het bedrag verandert niet wanneer het ticket ingewikkelder wordt, alleen wanneer het langer wordt.

Een autoregressief model heeft geen vergelijkbaar plafond. Elk van die miljoen beslissingen brengt ook kosten voor gegenereerde tokens met zich mee, en als de denkmodus aanstaat — wat bij Qwen3-8B standaard het geval is — kan het model honderden tokens besteden aan het beredeneren in welke van de vier categorieën een e-mail voor het opnieuw instellen van een wachtwoord thuishoort, voordat het antwoordt. De denkmodus uitschakelen met enable_thinking=False of een /no_think-tag is de regel met de meeste impact in elke classificatieprompt die op dat model is gebouwd, en het is makkelijk om die weg te laten. De vergelijking is niet "goedkoop model versus duur model"; het is een vaste prijs voor alleen invoer tegenover een prijs die meeschaalt met hoeveel het model besluit te zeggen.

Context, drie getallen van drie leveranciersoppervlakken.

Het bruikbare contextvenster van Clef-Flash hangt af van welk Cloudflare-oppervlak je bekijkt. De modelpagina van Workers AI vermeldt een contextvenster van 65.536 tokens. De vrijgegeven config.json declareert max_position_embeddings van 262.144 voor de teksttoren. De eigen coderingshelper van de kaart gebruikt standaard max_length=16,384, met max_state_tokens beschikbaar om de toestand afzonderlijk te begrenzen. Een runtime-vermelding van een derde partij die 256K adverteert, leest de configuratiewaarde, niet de serveringslimiet — wat die discrepantie verklaart in plaats van er een mysterie van te maken, maar het praktische getal voor iedereen die het gehoste endpoint aanroept, is 65.536.

Qwen3-8B heeft zijn eigen cijfers, en die zijn al anderhalf jaar stabiel: 32.768 native, 131.072 met YaRN ingeschakeld, en een standaardwaarde in de configuratie van 40.960 die 32.768 reserveert voor output en 8.192 voor prompts. Dus als het ruwe venster je doorslaggevende factor is, kan het kleine autoregressieve model worden uitgebreid tot ongeveer het dubbele van wat het gehoste beslissingsmodel documenteert — terwijl het beslissingsmodel er veel minder van nodig heeft, omdat je state verstuurt, geen gesprek.

Wie moeten ruilen, en wie niet

• Swap — je hebt een vaste taxonomie, drie tot 26 bestemmingen en een supportwachtrij, een triagestap of een agentpoort, waar een mediaan van 38,8 ms en een p95 van 122,4 ms, afgezet tegen een halve seconde generatie, veranderen wat je pipeline kan doen.

• Swap — je parseert momenteel proza uit een 8B en behandelt het antwoord dat één op de vijftig keer voorkomt en niet in je formaat past. Een verdeling over gedeclareerde opties elimineert die faalklasse volledig.

• Niet verwisselen — de antwoordset is niet vooraf bekend, of je hebt het model nodig om je te vertellen dat het het antwoord niet weet. Clef-Flash heeft geen onthoudingspad, tenzij je er een in de criteria inbouwt, en de zwakste gepubliceerde cel is precies het geval buiten scope.

• Niet omwisselen — de workload is redeneren, extractie uit onbeperkte documenten, samenvatten of code. Clef-Flash kan geen zin schrijven, dus alles downstream dat er een verwacht, behoudt Qwen3-8B.

• Nog niet omwisselen — je moet de cijfers laten controleren door iemand anders dan de leverancier. Er is geen onafhankelijke evaluatie van Clef-Flash, en de suite die de scores heeft geproduceerd, wordt uitgegeven door de leverancier van het model dat het verslaat.

Waar u elk ervan kunt uitvoeren

Beide zijn Apache-2.0, dus beide kun je zelf hosten, en de voetafdrukken liggen ver uiteen. Qwen3-8B in bf16 is ongeveer 16 GB en gequantiseerde builds zijn een stuk kleiner — een Q4-build is 5,2 GB in de Ollama-bibliotheek, waar qwen3:8b 38,7 miljoen downloads en een contextvenster van 40K vermeldt. Clef-Flash heeft de volledige backbone van 18,8 GB nodig plus zijn 243,5 MB grote head, en zijn pagina in de Ollama-bibliotheek verscheen binnen enkele dagen na de release, met een gequantiseerde tag van 11 GB en een aantal shares dat nog steeds in de lage honderden zit; de tabel van Ollama leest de 256K van de config in plaats van de 65.536 van het endpoint. Die downloadratio is geen oordeel over een van beide modellen — de ene pagina staat al achttien maanden online en de andere pas ongeveer een dag — maar het geeft een eerlijk beeld van hoeveel operationele geschiedenis er achter elk van beide schuilt.

Als je de gehoste versie wilt, draait Cloudflare Clef-Flash op Workers AI tegen het hierboven genoemde tarief van $ 0,09 per miljoen, waarbij de gewichten ook downloadbaar zijn vanaf de Hub. Beide modellen communiceren met Ollama's /v1/systemone-endpoint voor Clef-Flash (Ollama 0.35.1 of later) en het standaard generate-pad voor Qwen3 — een overstap is dus een clientwijziging, niet een architectuurwijziging.

Geen van beide modellen is momenteel een van onze routes: de openbare catalogus van OrcaRouter geeft een 404 voor zowel clef-flash als Qwen3-8B, en niets hier mag worden opgevat als een beschikbaarheidsclaim van ons. Wat een routeringslaag wél verandert, is de generatiehelft van de pijplijn. Als een beslissingsmodel uiteindelijk als poortwachter voor je agent fungeert, moet het model dat op de beslissing reageert nog steeds bereikbaar zijn, en dat is waar één API voor 200+ modellen achter één enkele API-sleutel zijn plek verdient — de lijstprijs van de provider wordt tegen 0% markup doorgegeven, zodat een prijsverlaging van een leverancier hier dezelfde dag nog landt, en automatische failover, zodat een slechte middag van één provider geen pad platlegt dat je net opnieuw hebt opgebouwd. Ook de Qwen-lijn is verdergegaan: Qwen3.8-27B kan hier worden gerouteerd tegen $0,40 per miljoen tokens voor invoer en $4,21 per miljoen tokens voor uitvoer met een contextvenster van 262.144 tokens, wat een ander model is dan Qwen3-8B en geen vervanging daarvoor, maar het is dezelfde familie, één generatie hoger.

Wat zou deze interpretatie veranderen?

Drie dingen, in volgorde.

Een onafhankelijke run van de out-of-scope-cellen. Het gat tussen Clef-Flashs 97,7 op appliance-simulatie en zijn 66,8 op CLINC150+OOS beschrijft geen soepel capabele classifier; het beschrijft een model dat sterk is binnen de vormen waarop het is getraind en zwak wanneer het juiste antwoord "geen van deze" is. Als dat standhoudt onder de harness van iemand anders, is het het belangrijkste operationele feit over het model en het staat op niemands highlightlijst.

Een gemeten latentiecijfer van buiten de edge van Cloudflare. De mediaan van 38,8 ms is indrukwekkend en werd gemeten door de leverancier, op infrastructuur die de leverancier controleert, voor een model dat op de edge wordt gehost. De ordening ten opzichte van Jev is waarschijnlijk robuust; het absolute getal is het getal dat je moet wantrouwen.

En een gedeelde benchmark. Totdat iemand Clef-Flash en een klein open LLM op dezelfde classificatietaak met dezelfde labels scoort, hangt de keuze tussen hen af van het outputcontract, de prijsstructuur en op wiens bewijs je bereid bent te handelen. Die drie zijn vandaag genoeg om voor veel pipelines de beslissing te nemen — maar het zijn geen nauwkeurigheidsvergelijking, en dit artikel zal niet doen alsof ze dat zijn.