Clef vs Qwen3.8-27B: één backbone, twee outputcontracten

Clef kan geen zin schrijven, en het is gebouwd op basis van een model dat dat wel kan. Cloudflare/clef is een multimodaal beslissingsmodel met 27 miljard parameters: je geeft het een toestand en een schema van getypeerde vragen, en het retourneert een waarschijnlijkheid voor elke toegestane optie zonder ook maar één token proza te produceren. De ruggengraat eronder is Qwen3.8-27B, een dense vision-language-model met open gewichten, bevroren op zijn plaats met een klein extra head eraan vastgemaakt. Dat maakt dit een van de weinige model-tegen-model-pagina's waar de twee partijen helemaal geen rivalen zijn — het zijn een checkpoint en zijn afgeleide, die 55 gigabyte aan gewichten delen en het oneens zijn over of het antwoord iets is dat je leest of iets waarmee je rekent.

De gewichten van beide werden openbaar voordat er ook maar iets werd gezegd. Cloudflare creëerde de Cloudflare/clefrepository op Hugging Face om 21:15 UTC op 30 september 2026, onder Apache-2.0, en publiceerde de volgende middag de aankondigingspost — "Introductie van Clef: onze opensource-beslissingsmodellen, en een nieuw RL-finetuningplatform". Ongeveer achttien uur lang was een model van 55 gigabyte downloadbaar en draaide het op Cloudflares eigen edge-gpu's voordat de leverancier er iets over zei. Binnen drie dagen had het een Ollama-bibliotheekpagina achter Ollama 0.35.1, waar dit stuk het aantrof, en NVFP4-, FP8-, EXL3-, INT8-, Q4- en Q8-builds van een dozijn verschillende uploaders.

Wat uit de repository kenbaar is, is ongewoon volledig, en het is de moeite waard dat te scheiden van wat niet kenbaar is. Kenbaar: de architectuur, het basischeckpoint, de licentie, een referentie-implementatie die draait, en een volledige evaluatiematrix. Niet kenbaar: of een van die cijfers standhoudt bij een rerun door iemand die niet Cloudflare is. Elke score die hieronder aan Clef wordt toegeschreven, komt uit de eigen run van de leverancier van een suite die de leverancier host. Die asymmetrie tegenover een model met een maand onafhankelijk gebruik achter zich is de eerlijke ruggengraat van deze vergelijking, en de rest van het stuk gaat over waar het echt pijn doet.

De twee repositories, naast elkaar

Begin bij de download, want dat ze hetzelfde zijn, is juist het punt. De safetensors van Clef komen neer op 54,97 GB verdeeld over twaalf shards. Die van het moedermodel komen neer op 55,56 GB verdeeld over achttien. Clef behoudt de vision encoder van Qwen3.8-27B — de processor, de vision tower, de hele multimodale front-end — dus er is niets weggehaald om het kleiner te maken. Wat Cloudflare heeft toegevoegd, is een gezamenlijke schema-head van 256 MB: vier lagen, 1.024 breed, zestien heads, een feedforward van 4.096 breed, twee routeringslagen die de laatste hidden states van de backbone lezen. Het trainingsrecept is een bevroren backbone, die head, en low-rank-adapters met rang 256, met label-smoothed cross-entropie voor geldige schema-antwoorden, gekoppeld aan een Brier loss om de kalibratie aan te scherpen.

Dan de divergentie, die volledig zit in wat het model mag emitteren.

• Parameters — Clef 27B, nagetraind vanaf Qwen/Qwen3.8-27B. Qwen3.8-27B 27B dense, 64 lagen, 5.120 hidden, vocabulaire van 248.320 tokens, 16 × (3 × Gated DeltaNet → FFN) afgewisseld met Gated Attention.

• Uitvoer — Clef: één logit per toegestane optie, softmax toegepast per vraag, helemaal geen generatiepad. Qwen3.8-27B: tokens, toolaanroepen en een redeneerblok dat standaard is ingeschakeld.

• Vraagvormen — Clef accepteert 1 tot 64 getypte vragen per verzoek in drie vormen: noul (waarschijnlijkheid dat het waar is), choice (2 tot 255 benoemde opties), score (2 tot 10 geordende niveaus, die een met waarschijnlijkheid gewogen waarde retourneren die daartussen kan uitkomen). Qwen3.8-27B heeft een dergelijk contract niet; je krijgt proza en je schrijft de parser.

• Licentie — Apache-2.0 op beide, wat de reden is dat de kwantisatie door derden in een weekend gebeurde.

• Kosten van de bevroren helft — de head van Clef is 256 MB tegenover 54,97 GB aan backbone. Bijna de hele download is het bovenliggende model. Als je Qwen3.8-27B al op schijf hebt staan, download je het een tweede keer om een andere mening te krijgen over hoe je moet antwoorden.

Wat het hernoemen kost, in twee cijfers

Cloudflares evaluatie is de Decision Index 0.2.1-suite, intern uitgevoerd, en het is een tabel over beslissingsmodellen — zes kolommen: Clef, Clef-flash, Jev, DiffusionGemma Jev, Kev 9B en Laya. Qwen3.8-27B heeft er geen rij in, en Clef heeft geen rij in de Artificial Analysis Intelligence Index. Er is dus geen gedeeld scorebord en dit stuk zal er geen verzinnen.

Er is echter één benchmark die beide partijen hebben doorlopen, en het verschil is groot genoeg om het meest beslissingsrelevante getal in de release te zijn. Op GPQA Diamond — wetenschapsvragen op graduate-niveau, meerkeuze — meet Cloudflare Clef op 48,0. Het bovenliggende model staat op 90,5 op de harness van Artificial Analysis en 89,2 op de eigen modelkaart van de leverancier. Dat is een kloof van veertig punten op algemene kennis, en het is geen mysterie: Clef antwoordt door een vaste reeks opties die het aangereikt krijgt te scoren, en meerkeuzevragen over algemene kennis liggen ongeveer zo ver van "dit ticket routeren" als je dezelfde gewichten maar kunt richten. Beschouw de vergelijking als indicatief, niet als gecontroleerd — twee harnesses, twee labs, noch die van de leverancier, noch die van de tracker. Maar de richting staat niet ter discussie, en het is de prijs van het contract.

Hetzelfde patroon is te zien in de rest van Clefs general-purpose-cellen. MMLU-Pro 65,9; BBH 73,7; CLINC150 met out-of-scope-afhandeling 97,4 voor de 27B tegen Jevs 89,3 — die laatste is de zeldzame cel waar het afgeleide model het oudere beslissingsmodel ronduit verslaat, en dat is belangrijk omdat het weigeren te classificeren de moeilijke helft van routering is. Waar Clef sterk is, is het precies sterk waar een in-house getrainde classifier zou moeten zijn: BANKING77 intent macro-F1 op 94,2, BFCL case-exact op 98,5, API-Bank op 91,9. Waar het zwak is, verslaat een tekstueel beslissingsmodel van een concurrerend lab — TypeSafe's Jev — het met dertig punten op GPQA Diamond, terwijl het een tarief rekent van $0,042 per miljoen inputtokens in onze eigen catalogus, wat een nuttige herinnering is dat "27B" op zich geen argument is.

Wat de parent bijhoudt, is alles waar de Decision Index niet naar vraagt. Op zijn eigen kaart en in de rijen met AA-bron bevat onze catalogus: Terminal-Bench 2.1 met 73,0, SWE-bench Pro 61,7, LiveCodeBench v6 90,3, OSWorld-Verified 84,3, DeepSWE 1.1 met 42,2, AA Coding 68,1 op positie 35 van 138 gesamplede modellen. Geen daarvan heeft een Clef-rij, omdat Clef ze niet kan proberen. Het heeft geen pad voor tool-aanroepen, geen langetermijnplanning, geen manier om de patch te genereren.

Wat één beslissing kost, en waarom de outputregel het hele argument is

De Workers AI-modelpagina vermeldt precies één eenheidsprijs voor Clef: $0,24 per miljoen invoertokens. Er is geen uitvoerregel, en de reden staat in de responses. Het eigen gedocumenteerde voorbeeld van Ollama — een supportticket dat langs drie vragen wordt geleid — komt terug met "usage": {"input_tokens": 1204, "output_tokens": 3}. Drie uitvoertokens voor drie vragen. Of Cloudflare die drie tokens in rekening brengt, is vrijwel irrelevant: de uitvoerkosten van een beslissing zijn geen tarief, het is een aantal vragen.

Zet dat tegenover de tariefkaart van de parent in onze eigen catalogus, die $0,33 per miljoen inputtokens en $2,40 per miljoen output is, met een venster van 262.144 tokens. Dezelfde toestand van 1.204 tokens, dezelfde enkele routeringsbeslissing:

• Clef — 1.204 invoertokens tegen $0,24 per miljoen is ongeveer $0,00029 per beslissing, en ongeveer $289 per miljoen beslissingen. Dat aantal verandert nauwelijks wanneer het antwoord moeilijker wordt, alleen wanneer de state langer wordt.

• Qwen3.8-27B met denken uitgeschakeld — dezelfde toestand kost ongeveer $0,00040 aan invoer, plus ruwweg tien uitvoertokens tegen $2,40 per miljoen. Noem het $0,00042, of $421 per miljoen. Clef is ongeveer 1,5× goedkoper, wat niet het verhaal is dat men vertelt.

• Qwen3.8-27B met thinking ingeschakeld — wat de standaard is op dit checkpoint. Als het model 400 tokens besteedt aan redeneren over in welke van vier buckets een e-mail voor het opnieuw instellen van een wachtwoord thuishoort, is dat nog eens $0,00096 en komt de beslissing uit op ongeveer $0,0014, ofwel $1.357 per miljoen. Die 400 tokens zijn een aanname, geen meting, en de multiplier beweegt daar lineair mee.

Dus de eerlijke versie van het prijsargument is nauwer dan het op het eerste gezicht lijkt. Tegenover een generalist die draait met de denkfunctie uit, wint Clef het op dollars met een factor van ongeveer anderhalf — echt, maar niet transformatief. Tegenover hetzelfde model in zijn standaardconfiguratie is de kloof een functie van breedsprakigheid, en breedsprakigheid is precies wat een taalmodel heeft en een scorers-over-options-ontwerp helemaal niet heeft. Dat is de structurele claim: Clefs kosten worden begrensd door de lengte van de state, en die van de parent door hoeveel de parent besluit te zeggen.

Het ene nummer dat niet dichtbij is

Cloudflare rapporteert een mediane requestlatentie van 209,3 ms voor Clef en een p95 van 238,6 ms, gemeten over de 43 benchmarks in zijn run, op zijn eigen edge-GPU's. Niemand buiten Cloudflare heeft dit gereproduceerd, en de infrastructuur van de leverancier is de reden dat het getal zo laag is — dit model is ontworpen om op hetzelfde netwerk als de aanroeper te zitten.

Voor het bovenliggende model kunnen we beter doen dan een door de leverancier opgegeven cijfer, want het is een van onze routes. Over het venster van zeven dagen dat eindigt op 2 oktober 2026 mat de eigen playground van OrcaRouter Qwen3.8-27B op een p50 van 1.929 ms en 235,8 outputtokens per seconde, op 136,3 miljoen tokens aan verkeer in dat venster. De dagelijkse reeks is het interessante deel: p95 ligt op precies 10.000 ms op zes van de zeven dagen, wat leest als een plafond in plaats van een meting, en de p50 schommelt tussen 1.751 ms en 4.296 ms, afhankelijk van de dag. Behandel de mediaan als ongeveer negen keer die van Clef, en behandel de staart als niet-informatief totdat iemand een echte verdeling publiceert.

Dat verschil is geen kwestie van tuning en zal dat ook niet worden. Een prefill-only pass plus een parallelle scoring-head is in één sweep klaar; een autoregressief model is klaar wanneer het niets meer te zeggen heeft. De absolute cijfers van de leverancier voor Clef verdienen het gebruikelijke voorbehoud, maar de rangorde is een eigenschap van de architectuur, niet van de hardware van Cloudflare.

Voor een van hen wordt de context op drie manieren aangehaald.

Beide modellen accepteren tekst, JSON, afbeeldingen en video. De vensters zijn niet hetzelfde, en een van beide wordt afhankelijk van waar je het leest inconsistent opgegeven.

• Clef, gehost — 65.536 tokens, volgens de Workers AI-modelpagina en het aankondigingsbericht. Dat is het aantal dat bindend is voor een API-aanroeper, en Cloudflares eigen framing is vergelijkend: tweemaal de state die het 32K-venster van Jev bevat.

• Clef, op schijf — de vrijgegeven config.json declareert max_position_embeddings van 262.144, omdat de bevroren backbone die van het bovenliggende model is en nog steeds het positieplafond van het bovenliggende model draagt. De meegeleverde encode_record helper staat standaard op max_length=16,384, met max_state_tokens beschikbaar om de state afzonderlijk te begrenzen. Geen van die drie getallen is fout; ze beantwoorden verschillende vragen, en een runtime-overzicht dat 256K adverteert, leest de config, niet het endpoint.

• Qwen3.8-27B — 262.144 native, uitbreidbaar tot 1.000.000 met de juiste servingconfiguratie, volgens de leverancierskaart en onze catalogusrij. Minimaal vier keer het gehoste Clef-venster.

Het praktische gevolg is kleiner dan de verhouding doet vermoeden. Clef verbruikt een toestand — een ticket, een factuur, een schermafbeelding — niet een gesprek, en een van zijn verkoopargumenten is dat je er een grote afgeplatte payload aan kunt geven en er vierenzestig vragen over kunt stellen zonder voor elke vraag opnieuw voor de payload te betalen. De parent heeft het venster nodig omdat het de geschiedenis, de toolresultaten en zijn eigen redenering moet bevatten. Andere vereisten, andere plafonds.

Ze zien beiden dezelfde pixels

De vision-encoder is overgenomen, dus dit is niet een geval waarin het ene model multimodaal is en het andere niet. Clef accepteert tot vier afbeeldingen per verzoek, base64-gecodeerde PNG, JPEG of WebP, gedeeld door elke vraag in de payload, en videoframes kunnen worden toegevoegd als framearrays — het kassabonvoorbeeld in de modelkaart stelt een ja/nee-vraag over of een totaal leesbaar is, wat het ontwerp in miniatuur is. Qwen3.8-27B is een native vision-languagemodel met OmniDocBench 1.5 op 91,1, RealWorldQA op 85,9 en CharXiv op 78,8 op de modelkaart van de leverancier.

Het verschil zit in wat je terugkrijgt. Clef geeft je een beslissing per veld met een waarschijnlijkheid eraan verbonden, wat een getypeerd antwoord over een document is. De parent geeft je een beschrijving van het document, die je vervolgens parseert. Voor een grote klasse van documentwerk — controleer dit formulier, lokaliseer deze clausule, is dit totaal boven de drempel — is het getypeerde antwoord de hele klus, en de beschrijving is overhead waarvoor je betaalt en die je daarna weggooit.

Waar de grens daadwerkelijk ligt

• Gebruik Clef — de antwoorden zijn vooraf opsombaar en je wilt liever geen parser schrijven. Routering, triage, gating, beleidscontroles, extractie van documentvelden. Gesloten sets, 2 tot 255 opties per vraag, tot 64 vragen die samen worden gescoord.

• Kies Clef — de beslissing ligt in een hot path en 209 ms tegen 1.929 ms verandert wat de pipeline kan doen. Dit is de allersterkste reden om over te stappen, en het is een kwestie van latentie, niet van nauwkeurigheid.

• Kies Clef — je wilt determinisme. Een optie die je niet hebt gedeclareerd, kan niet terugkomen, want er is geen generatiestap om die te produceren.

• Behoud Qwen3.8-27B — het antwoord is geen keuze uit een lijst: samenvatten, opstellen, redeneren over een nieuw probleem, code schrijven, tools aansturen over een lange horizon. Clef kan niets daarvan, en het zal je dat niet vertellen.

• Houd Qwen3.8-27B — je hebt het model nodig om "geen van deze" te zeggen. Een beslissingsmodel scoort de opties die het heeft gekregen. Geef het een facturatie-/technisch/verkoopschema en een privacyverzoek, en het retourneert de minst slechte van die drie in plaats van een weigering. Het bovenliggende model brengt de vraag naar boven die je niet had bedacht te stellen.

• Behoud Qwen3.8-27B — voor context- of langdocumentwerk. Vier keer het gehoste venster, vóór de miljoen-tokenuitbreiding.

Lees die lijst als een pijplijn in plaats van een oordeel, want dat is wat het is. De architectuur maakt de relatie letterlijk: Clef is de prefill-pass van de ouder met een ander antwoordmechanisme aan het einde. Een verstandig ontwerp zet Clef vooraan — bepaal de route, de prioriteit, de escalatievlag — en houdt Qwen3.8-27B erachter om op de beslissing te handelen. De twee zijn complementen die toevallig een download delen.

Waar u elk ervan kunt uitvoeren

Clef wordt gehost op Cloudflare's Workers AI tegen het hierboven genoemde tarief van $0,24 per miljoen input, en de Apache-2.0-gewichten zijn van jou om lokaal te draaien. De vermelding in de Ollama-bibliotheek is het nieuwste oppervlak: ollama pull clef vereist Ollama 0.35.1 of nieuwer, omdat het model communiceert via het /v1/systemone-endpoint dat Ollama heeft toegevoegd voor beslissingsmodellen. Let op de tags, niet op de kop — de standaard- en clef:27b-tags zijn 18 GB, een vierbitsbuild van een 55 gigabyte-model; clef:27b-q8_0 is 30 GB, clef:27b-nvfp4 is 18 GB, clef:27b-mxfp8 is 31 GB, en clef:27b-mlx-bf16 is de volledige 55 GB voor Apple silicon. TypeSafe's eigen Python SDK zal ermee communiceren als je hem op een lokale Ollama richt en een willekeurige API-sleutel opgeeft, die de runtime negeert. Eén waarschuwing die in productie gaat bijten: confidence meet hoe geconcentreerd de waarschijnlijkheden zijn, niet de kans dat het antwoord correct is, en gelijke standen worden beslecht in de door jou opgegeven optievolgorde.

De parent is vandaag de gemakkelijkste om achter een API te zetten. Qwen3.8-27B is routeerbaar op OrcaRouter tegen de hierboven gebruikte tarieven van $0,33 en $2,40 per miljoen, met het venster van 262.144 tokens, en het is er één van meer dan 200 die bereikbaar zijn via één enkele OpenAI-compatibele sleutel. Omdat de lijstprijs van de provider tegen 0% opslag wordt doorgegeven, is een prijsverlaging van een leverancier aan weerszijden van deze vergelijking dezelfde dag dat die ingaat live op onze routes.

Clef zelf is geen van onze routes — onze openbare catalogus geeft er niets voor terug, en niets hier mag worden gelezen als een beschikbaarheidsclaim van ons. Wat we wél aanbieden is het model dat het beslissingspatroon bereikbaar maakt zonder een Cloudflare-account: TypeSafe's Jev 1.13 is een vermelde route tegen $0,042 per miljoen inputtokens met een context van 65.536 tokens, gemeten op een p50 van 148 ms over hetzelfde venster van zeven dagen, en het spreekt de identieke POST /v1/systemone requestvorm. Omdat Clef bewust API-compatibel is met Jev, is een pipeline die tegen een van beide is gebouwd slechts een configuratiewijziging verwijderd van de andere — wat precies het geval is dat een routeringslaag bestaat om gratis te maken. Houd beide bereikbaar, meet op je eigen labels, en laat de winnaar een datapunt zijn in plaats van een architecturale toezegging. Als een beslissingsmodel uiteindelijk een agent afschermt, moet het model dat op de beslissing handelt nog steeds bereikbaar zijn, en die helft zit al achter dezelfde sleutel.

Wat zou deze aflezing veranderen?

Drie dingen, in oplopende volgorde van hoeveel impact ze zouden hebben.

Een derde partij moet de Decision Index opnieuw uitvoeren. De suite is openbaar en Cloudflare beschrijft de evaluaties als reproduceerbaar, dus dit is haalbaar — en de CLINC150 out-of-scope-cel is er een om in de gaten te houden, want een 97,4 voor de 27B is ofwel een echt voordeel ten opzichte van Jevs 89,3 op de moeilijkste helft van de routing, ofwel een artefact van een zelfgebouwde harness. Niemand buiten Cloudflare weet het nog.

Iemand moet Clef en Qwen3.8-27B scoren op dezelfde classificatietaak met dezelfde labels. Dat is de enige vergelijking die kan beslechten of de re-heading een kwaliteitsruil dan wel een kwaliteitsverbetering is voor beslissingen met een gesloten set, en geen van beide leveranciers heeft er belang bij om die uit te voeren. Tot dan geldt het gat van veertig punten op GPQA als het beste beschikbare bewijs over wat er is verwijderd, en het is bewijs over de verkeerde taak.

En Clefs latentie moet een p95 onder gelijktijdige belasting hebben. De mediaan van 209 ms werd gemeten door de leverancier, op hardware die de leverancier beheerst, voor een model waarvan het hele verkoopargument is dat het in een hot path zit. De ordening ten opzichte van een autoregressieve ouder is architectonisch en zal standhouden. De absolute milliseconden zijn het getal dat je moet wantrouwen, en dat is precies het getal waarop de hele businesscase rust.

Qwen3.8-27B is een van de meer dan 200 modellen die bereikbaar zijn via één OpenAI-compatibele sleutel — Qwen3.8-27B.