Flint v1.0 vs North Mini Code: twee open codeer-MoE's die vechten om je laptop

De meeste "versus"-pagina's op deze site zetten dingen naast elkaar die nooit echt rivalen waren. Deze is anders. Recursive Flint v1.0 en Cohere North Mini Code zijn hetzelfde soort object: sparse mixture-of-experts-codeermodellen, gepubliceerd onder Apache 2.0, klein genoeg om te draaien op hardware die een ontwikkelaar al in bezit heeft, en beide gepositioneerd als de lokale optie in plaats van de frontier-optie. Flint verscheen op 21 oktober 2026 met 39,8 miljard totale parameters en ongeveer 2,5 miljard actief per token. North Mini Code verscheen op 9 juni 2026 met 30 miljard totaal en 3 miljard actief. Dat ligt dicht genoeg bij elkaar dat de keuze neerkomt op wat er in het bestand zit en wat er daadwerkelijk is gemeten — en op beide punten is het antwoord niet wat de lanceerberichtgeving suggereert.

De twee bestanden, dimensie voor dimensie

Begin met wat er in de doos zit, want voor twee zelfgehoste modellen is dit de vergelijking die de toets der werkelijkheid doorstaat.

• Totale parameters — Flint: 39,8B. North Mini Code: 30B.

• Actieve parameters per token — {{1}}Flint{{/1}}: ongeveer {{2}}2,5 miljard{{/2}}, met {{3}}2,2 miljard{{/3}} in het hoofdgedeelte en de rest in de output-head. {{4}}North Mini Code{{/4}}: {{5}}3 miljard{{/5}}. Vrijwel identiek, en dit is het getal dat de inferentiekosten bepaalt.

• Expertroutering — Flint: 256 gerouteerde experts, 6 geselecteerd per token plus 1 gedeelde, over 47 MoE-lagen en 2 dense lagen. North Mini Code: 128 experts, 8 actief per token.

• Aandacht — Flint: een mix van sliding-window- en globale lagen met attention sinks. North Mini Code: een 3:1 sliding-window-tot-globale verhouding. Beide zetten in op dezelfde gok, dat de meeste tokens alleen lokale aandacht nodig hebben en een paar het hele venster.

• Context — Flint: 262.144 tokens gedocumenteerd op de modelkaart, waarbij de aankondiging tot 512K vermeldt en 256K aanbeveelt. North Mini Code: 256K invoer, 64K maximale uitvoer.

• Modaliteit — Flint: tekst in, tekst uit. North Mini Code: tekst in, tekst uit. Geen van beide accepteert afbeeldingen, wat belangrijk is als je werk screenshots omvat.

• Licentie — beide Apache 2.0, gewichten inbegrepen, geen omzetdrempel.

• Gepubliceerde formaten — Flint: BF16, int4 safetensors, int4 GGUF, NVFP4 GGUF. North Mini Code: BF16, FP8 en W4A16.

• Schijf en geheugen — Flint: 79,59 GB in BF16, 22,86 GB als NVFP4, en ongeveer 24 GB geheugen om te draaien. North Mini Code: ongeveer 20 tot 24 GB gekwantiseerd, waarbij Cohere's eigen demo op een Mac Studio draait met ongeveer 20 GB.

Geheugen is de eerste bezuiniging, en het ligt dichterbij dan de parameteraantallen suggereren.

De naïeve lezing van 39,8B versus 30B is dat Flint een derde meer geheugen nodig heeft. Dat is niet zo, omdat beide sparse zijn en beide agressieve gekwantiseerde builds publiceren. Waar je feitelijk tussen kiest, is een NVFP4-bestand van 22,86 GB en een gekwantiseerde build van ongeveer 20 GB — dicht genoeg bij elkaar dat dezelfde kaart van 24 GB beide kan draaien, en dicht genoeg bij elkaar dat geen van beide op basis van alleen de geheugenvoetafdruk de voor de hand liggende keuze is.

Het verschil zit in de speelruimte. North Mini Code zou een 4-bit GGUF draaien op een Ryzen 7 met 32 GB DDR4 — een echt gewone desktop, geen workstation. Flints laptopbewering is specifieker: de doorvoercijfers van Recursive zijn gemeten op een M4 Pro MacBook Pro en op een 64 GB RTX Spark, beide premium machines. Het bestand van 22,86 GB laadt op een kaart van 24 GB. Of het draait met een snelheid die je acceptabel vindt, is een aparte vraag, en dat hangt sterk van de engine af.

Als je uitgangspunt "de machine die ik al bezit" is, zijn er meer meldingen dat North Mini Code op onopvallende hardware draait. Als je uitgangspunt "de beste machine die ik bezit" is, is Flint de nieuwere architectuur en de snellere bij korte context.

Een van deze heeft een onafhankelijk scorebord.

Dit is het deel van de vergelijking dat de meeste verslagen overslaan, en het is juist het deel dat een inkoopbeslissing zou moeten bepalen.

North Mini Code is gemeten door Artificial Analysis. Het scoort 33,4 op de AA Coding Index en 27,6 op de AA Intelligence Index, met SWE-bench Verified op 67,6 pass@1 en 80,2 pass@10, en 61,0 op mini-SWE-Agent. Dit zijn metingen door derden die volgens een consistent protocol zijn uitgevoerd, wat betekent dat ze kunnen worden vergeleken met andere modellen op dezelfde index zonder een voetnoot over harnesses.

Flint heeft geen vermelding bij Artificial Analysis. De gepubliceerde scores — 74,2 op SWE-bench Verified, 89,7 op SWE-bench Pro v2, 54,9 op Terminal-Bench 2.1 — komen uit Recursive's eigen harness, en niemand heeft ze opnieuw gedraaid. De methodologie is openbaar gemaakt, wat Recursive siert: mini-swe-agent zonder internet voor de SWE-bench-runs, Terminus 2 met internet voor Terminal-Bench, maar elke via het web opgehaalde oplossing werd als mislukking geteld, pass@1 gemiddeld over ten minste vijf pogingen. Een openbaar gemaakte methodologie is geen geverifieerde methodologie.

Dus kun je 67,6 met 74,2 vergelijken? Niet op verantwoorde wijze. Ze zijn geproduceerd door verschillende organisaties op verschillende harnassen met verschillende regels, en de kloof — 6,6 punten — valt ruim binnen het bereik dat de keuze van het harnas alleen al een score kan laten verschuiven. Wat je wel kunt zeggen, is beperkter en toch nuttig: het cijfer van North Mini Code is gecontroleerd door iemand die het model niet heeft gebouwd, en dat van Flint niet. Als je op basis van bewijs kiest in plaats van op basis van specificaties, is dat de asymmetrie die ertoe doet.

Er is nog een gegeven in de kolom van North Mini Code dat onflatteus is en de moeite waard om te kennen: Artificial Analysis markeerde het als ongewoon breedsprakig; tijdens tests verbruikte het ongeveer 75 miljoen outputtokens, tegen een klassenmediaan van bijna 25 miljoen. Breedsprakigheid is een kostenvermenigvuldiger in een agentloop. Een model dat drie keer zoveel hardop nadenkt, kan per token goedkoper en per taak duurder zijn.

Het snelheidsverhaal verandert volledig bij lange context.

Beide modellen zijn snel bij korte prompts, en beide worden langzamer wanneer de context volloopt. Het verschil is hoeveel.

• Flint — Recursive claimt meer dan 125 tokens per seconde op een M4 Pro MacBook Pro en meer dan 150 op een 64 GB RTX Spark, gemeten bij korte context zonder prefill mee te rekenen. Onafhankelijke tests meldden ongeveer 110 tokens per seconde bij korte prompts, dalend tot ruwweg 9 tokens per seconde bij een context van bijna 115.000 tokens. Dat is het getal waarop je je agent moet ontwerpen, omdat agentisch programmeren het grootste deel van zijn leven in het langcontextregime doorbrengt.

• North Mini Code — ongeveer 199 tot 210 outputtokens per seconde op Cohere's API, met ongeveer 0,25 seconden tot het eerste token, en ongeveer 2,8 keer de doorvoer van vergelijkbare kleine modellen in dezelfde test. Op lokale hardware hangen de cijfers volledig af van je engine en kwantisatie, maar het patroon is hetzelfde: snel bij korte context, langzamer naarmate het venster voller raakt.

De eerlijke vergelijking is niet 'welke is sneller', maar 'welke is sneller voor de manier waarop een agent daadwerkelijk werkt'. Een model dat een token in 8 milliseconden schrijft bij een context van 4K en in 110 milliseconden bij 115K is een ander product dan een model dat geleidelijker achteruitgaat. Geen van beide leveranciers publiceert een curve. Als agentisch werk met een lange context jouw toepassing is, meet het dan op je eigen repository voordat je je eraan vastlegt — het is een middag werk en het vertelt je meer dan welk lanceringsbericht dan ook.

Momentum versus frisheid

North Mini Code passeerde medio augustus 2026 de 150.000 downloads, twee maanden na de release. Dat is een echt signaal: een model met zoveel adoptie is gedraaid op hardware die de makers nooit hebben getest, er zijn in de community fixes verzameld en de ruwe randjes zijn gedocumenteerd door mensen die er geen belang bij hebben om vriendelijk te zijn. Cohere heeft het cijfer gerapporteerd, dus beschouw het aantal als door de leverancier verstrekt, maar de richting wordt ondersteund door het volume aan afgeleide quantisaties dat in omloop is.

Flint is vier dagen oud. Het heeft betere headline-specificaties, een snellere decode bij korte context, een langer gedocumenteerd contextvenster en een interessanter ontwikkelingsverhaal. Het heeft ook een bekende chat-templatebug in het GGUF-pad voor llama.cpp, een doorvoerklif bij lange context die niemand heeft verklaard, en vrijwel geen communitygeschiedenis. Vroege adoptie van een vier dagen oud model is een gok op de ontwikkelingsrichting in plaats van een beoordeling van het artefact.

Wat je maandag kunt downloaden

• Kies North Mini Code als je het model wilt met een onafhankelijke score eraan verbonden, als je hardware bescheiden is, als je taken gewone software-engineering in een repository zijn die comfortabel in de context past, en als je twee maanden community-bugreports belangrijker vindt dan een nieuwere architectuur. Houd rekening met de breedsprakigheid ervan.

• Kies Flint als je een premium laptop of een kaart met 24 GB hebt, als je het langere contextvenster wilt, als snelheid bij korte context is wat je workflow daadwerkelijk benut, en als je bereid bent een early adopter te zijn in ruil voor een model dat over een maand waarschijnlijk het betere is.

• Kies geen van beide als je enige optie. Beide zijn modellen met 2,5 tot 3 miljard actieve parameters. Ze zijn uitstekend in afgebakende taken en het zijn geen frontier-codeassistenten, en Recursive zegt dat ook over zijn eigen model. Het werk dat geen van beide goed zal doen, is het werk waarvoor een gehost frontier-model nodig is — en de verstandige architectuur is een lokale standaard met een escalatiepad, niet één model dat alles moet zijn.

Dat escalatiepad is waar routing zijn bestaansrecht verdient. OrcaRouter serveert geen van deze twee modellen, dus niets hier is een pleidooi voor een route ernaartoe. Wat een routinglaag doet voor een local-first opzet, is de andere kant op werken: het laat je de taken die een groter gehost model nodig hebben, in hetzelfde aanroeppad samenbrengen, met een fallback-keten voor de verzoeken waarbij het lokale model vastloopt of de context overloopt. Goed geconfigureerd doet het lokale model het routinewerk en wordt het dure model alleen bereikt wanneer het echt nodig is — en dat is de enige versie van deze architectuur die geld bespaart.

Het saaie antwoord is het juiste. Beide bestanden zijn gratis, beide draaien op hardware die je waarschijnlijk hebt, en de enige manier om erachter te komen welke bij je repository past, is ze allebei daarop uit te proberen. Het verschil in benchmarks tussen de twee is kleiner dan het verschil tussen elk van hen en je werkelijke werklast.