Ternary Bonsai 2 27B: Wat er in 5,9 GB past, en wat de 98,2% je niet vertelt

Ternary Bonsai 2 27B is een multimodaal taalmodel met 27,36 miljard parameters dat Prism ML op 17 september 2026 aankondigde, en wat je ervan moet begrijpen, is dat de taalgewichten precies een van drie waarden aannemen. Het basismodel is Qwen3.8 27B — een 27B hybride-attentiemodel — en Bonsai behoudt die architectuur, die training en die vorm, en vervangt de matrixgewichten van het taalmodel door een ternaire representatie. Het geleverde bestand is 5,93 GB. De referentie op volledige precisie is 53,81 GB. De belangrijkste claim van de leverancier is dat het 98,2% van het benchmarkgemiddelde van het origineel behoudt.

Begin met het deel waar de meeste berichtgeving overheen zal glijden: dat 98,2% is Prism ML's eigen cijfer, gemeten op Prism ML's eigen suite van 20 benchmarks, met Prism ML's eigen testomgeving, en niemand buiten het bedrijf heeft het gereproduceerd. Dat is geen beschuldiging — het is de normale gang van zaken, één dag na een release, en het is precies de status die je eraan moet toekennen. Wat je vandaag onafhankelijk kunt verifiëren, is het bestand: de Hugging Face API vermeldt Ternary-Bonsai-2-27B-PTQ1_0.gguf op 5,947 GB tegenover de FP16-referentie van 53,808 GB, wat een reductie van 9,05x is en overeenkomt met het "ongeveer 9x" van de leverancier, zonder dat je iemand hoeft te vertrouwen. De grootte is een feit. Het behoud van kwaliteit is een leveranciersmeting. Het interessante materiaal zit ertussenin — de uitsplitsing per categorie, die precies laat zien waar de compressie gratis is en waar niet.

Er is ook een tweede kant aan deze release. Op 18 september, één dag na de aankondiging, publiceerde OrcaRouter een runtime-abliterated variant van hetzelfde model — de OrcaRouter Ternary Bonsai 2 27B Uncensored — die tijdens de inferentie een aangeleerde weigeringsrichting verwijdert en de gewichten bit-identiek laat. Hieronder wordt het in een eigen sectie behandeld, omdat de techniek het interessante deel is en omdat de beperkingen ervan net zo leerzaam zijn als de resultaten.

Het is een gecomprimeerde Qwen3.8 27B, geen nieuw getraind model.

Dit onderscheid is het verschil tussen het uitleggen van de release en het herhalen van een persbericht. Prism ML heeft geen 27B-model vanaf nul getraind en heeft geen nieuw pretrainingsrecept uitgevoerd. Wat het deed, was Qwen3.8 27B nemen en de numerieke representatie veranderen waarin de gewichten worden opgeslagen en berekend.

De architectuur is ongewijzigd, en het is die van het basismodel: een hybride-aandachtsontwerp dat ongeveer 75% lineaire aandacht en 25% volledige aandacht is, met SwiGLU MLP-blokken, RoPE en RMSNorm. Die hybride backbone is ook de reden waarom de context van 262K tokens wordt beschreven als geschikt voor volledige context in plaats van louter ondersteund — grotendeels lineaire aandacht is wat een lange context betaalbaar houdt op een apparaat. Het model is een visie-taalmodel: het accepteert zowel afbeeldingen als tekst, en de visietoren is de standaard, niet-gekwantiseerde Qwen-toren, apart verpakt.

Wat Prism ML heeft bijgedragen, zijn twee dingen. Het eerste is de ternaire representatie zelf plus de quantisatiebewuste training die het werkbaar maakt. Het tweede zijn de kernels — aangepaste low-bit-kernels voor die hybride attention-stack op Apple Silicon en CUDA, die rechtstreeks op de gepackte gewichten werken in plaats van ze uit te pakken naar FP16 en te vermenigvuldigen. Zonder de tweede bijdrage is de eerste een opslagformaat zonder enige manier om het op snelheid te gebruiken.

De eigen whitepaper van Prism ML rapporteert de parameterverdeling als 24,35B in de taalbackbone, verdeeld over 64 blokken, 2,54B in de embedding en LM-head, en 0,47B in de visietoren met 27 blokken, voor een totaal van 27,36B. De visietoren is het enige onderdeel dat werkelijk een ander artefact is: de GGUF-release verpakt deze als een 4-bits mmproj-bestand van ongeveer 0,63 GB, dat alleen wordt geladen wanneer er daadwerkelijk een afbeelding binnenkomt, zodat het nooit wordt meegenomen bij het serveren van alleen tekst.

Dit is de tweede generatie Bonsai uit hetzelfde lab; de eerste Bonsai 27B verscheen in juli 2026, ongeveer twee maanden eerder, en de vergelijking tussen de twee generaties is een logische vraag — die we in de head-to-head met Bonsai 27B behandelen in plaats van hier te dupliceren.

Wat "ternary g128" concreet betekent

Als je nog nooit ternaire gewichten bent tegengekomen, is dit de alinea die al het andere leesbaar maakt, dus hier is die zonder steno.

Een gewoon gewicht in een neuraal netwerk is een 16-bits drijvendekommagetal — ongeveer 65.536 onderscheidbare waarden in een bruikbaar bereik, die elk 16 bits kosten om op te slaan. Een ternair gewicht is geen kleine float. Het is een keuze uit drie symbolen: −1, 0 of +1. Dat is de volledige woordenschat. Als je zo'n symbool naïef opslaat, zou je twee bits per gewicht gebruiken, aangezien twee bits vier toestanden opleveren en je er maar drie nodig hebt.

Op zichzelf zou dat een catastrofaal verlies van expressiviteit zijn, en daarom is het formaat nooit alleen het symbool. Elke groep van 128 opeenvolgende gewichten deelt één FP16-schaalfactor, en de werkelijke gewichtswaarde is het ternaire symbool vermenigvuldigd met die schaal:

• w = ssub>g/sub> · t, waarbij t ∈ {−1, 0, +1} en ssub>g/sub> is één gedeelde FP16-schaal voor de groep van 128

Dus het model representeert nog steeds een breed scala aan groottes — het representeert ze alleen in grove, groepsgewijze stappen in plaats van per gewicht. De 0 is geen afrondingsartefact; het is een echte derde toestand, en het hebben ervan is wat een groep van 128 gewichten grotendeels stil laat zijn wanneer dat nodig is.

De geroteerde basis is het onderdeel dat mensen verrast. Voordat de ternaire toewijzing plaatsvindt, wordt elke gewichtsmatrix bloksgewijs getransformeerd door een orthogonale rotatie — een Walsh–Hadamard-matrix gecombineerd met een vaste diagonaal van ±1-tekens, met blokgrootte 1024 — en de ternaire waarden worden in die geroteerde ruimte gekozen. De rotatie wordt tijdens de voorbereiding in de opgeslagen gewichten verwerkt, dus het kost geen extra bits en geen extra gewichtsverkeer. Bij inferentie past de runtime in plaats daarvan de overeenkomstige transformatie toe op de activaties, en het verpakte model verklaart zijn rotatie in zijn metadata, zodat een runtime ofwel de overeenkomstige transformatie toepast ofwel weigert het bestand te laden.

Waarom de moeite? Omdat een Hadamard-rotatie de energie van een gewichtsmatrix gelijkmatiger over de coördinaten spreidt, waardoor de daaropvolgende drie-niveaukwantisatie veel minder schadelijk is dan op de ruwe verdeling met scherpe pieken. De rotatie is geen decoratie; ze is de reden dat een ternair model überhaupt nog iets van de kwaliteit van het moedermodel kan behouden. De prijs is dat de transformatie op het kritieke pad ligt van elke projectie bij batchgrootte 1, wat een echt engineeringprobleem is — Prism ML fuseert de tekenomkering in het laadpad van de transformatie op Metal en paralleliseert deze over een volledige threadblock op CUDA om te voorkomen dat die het decoderen domineert.

De getallen, zorgvuldig: 1.585, 1.71, 1.72, 1.76

Er circuleren vier cijfers over bitbreedte rond deze release, ze zijn allemaal correct, en ze meten vier verschillende dingen. Ze met elkaar verwarren is de gemakkelijkste fout in dit verhaal. Hier is elk ervan en wat het daadwerkelijk omvat.

• 1,585 bits per gewicht — de informatie-inhoud van één ternair symbool, log₂3. Dit is een eigenschap van het formaat, niet van een bestand. Niets dat is uitgebracht draait op 1,585 bits/gewicht.

• 1,71 bits per gewicht — alleen de ternaire tensoren. Tel de 16-bits FP16-groepsschaal erbij op, geamortiseerd over 128 gewichten, en je krijgt log₂3 + 16/128 ≈ 1,71. Nog steeds geen cijfer uit een uitgebrachte versie; het zijn de ternaire tensoren op zichzelf.

• 1,72 bits per gewicht — elke parameter in het taalmodel, inclusief de kleine set die boven de low-bitrepresentatie wordt gehouden. Prism ML houdt 26.238.464 parameters — 0,0976% van het taalmodel, ongeveer 52 MB bij bf16 — in hogere precisie, grotendeels het pad van de recurrente toestand in de linear-attentielagen plus normalisatiegewichten. Die tensoren worden noch geroteerd noch gekwantiseerd, en zij zijn wat de waarde van 1,71 naar 1,72 brengt. Bij 1,72 is de geïdealiseerde voetafdruk 5,80 GB, een reductie van ongeveer 9,3x. Dit is de "True Ternary"-rij van Prism ML, en het is een doel in plaats van een bestand dat je downloadt.

• 1,76 bits per gewicht — de daadwerkelijk geleverde GGUF. Efficiënte kernels hebben een packingformaat nodig, en Prism ML's PTQ1_0 pakt trits dicht opeen en komt uit op 1,76 bits/gewicht in 5,93 GB, ongeveer 9,1x. Dit is het bestand achter zowel de "5,9 GB" als de "9x kleiner" die de aankondiging citeert, en het is degene die de bovenstaande metingen bevestigen.

De tweede packing is PQ2_0, die elke trit opslaat in een slot van 2 bits in plaats van dicht opeengepakt. Het kost meer ruimte voor goedkoper uitpakken: 2,16 bits/gewicht in 7,25 GB, ongeveer 7,4x. Geen van beide packings is uniform sneller — PTQ1_0 verplaatst per stap ongeveer 18% minder gewichtsdata, maar betaalt rekenwerk voor het uitpakken van dichte trits, dus het wint op de Ada-generatiekaarten en de L4, waar geheugen de beperkende factor is, en verliest op Hopper, Blackwell en Apple silicon, waar batch-1-decodering juist wordt beperkt door instructiedoorvoer. Promptverwerking geeft overal de voorkeur aan PQ2_0, omdat die rekenkrachtgebonden is.

Twee administratieve opmerkingen voor wie deze tegen de bronnen controleert. Ten eerste: de eigen documenten van Prism ML ronden iets anders af — de opslagtabel in het whitepaper geeft PTQ1_0 als 1,76 bits/gewicht bij 5,93 GB, terwijl de GGUF-modelkaart op Hugging Face 1,75 en 5,95 GB geeft, en het gemeten bestand is 5,947 GB. Dit is hetzelfde bestand, beschreven met verschillende precisie, geen inhoudelijk meningsverschil. Ten tweede: de aangekondigde reductie van "meer dan 9x" is die van de leverancier; gemeten tegen de werkelijke bestanden is het 53,808 / 5,947 = 9,05x, wat consistent is.

Het benchmarkbeeld: niet het gemiddelde, de vorm

De kop is een gemiddelde van 83,9 tegenover 85,4 voor de Qwen3.8 27B FP16-baseline, wat 98,2% is. Het gemiddelde is het minst interessante deel ervan. De vorm daaronder is waar de echte informatie zit, en die is niet uniform.

• Instructieopvolging — 82,66 vs 81,25. Dit is de enige categorie waarin het gecomprimeerde model het wint van zijn moedermodel met volledige precisie. Het is geen ruis die iemand achteloos kan wegverklaren; het is een categoriewinst op de eigen suite van de leverancier.

• Wiskunde — 96,57 tegen 97,06, en programmeren — 81,58 tegen 82,17. Beide vrijwel gelijk: een half punt en zes tienden van een punt op de categoriegemiddelden. Voor een model met een negende van de voetafdruk zijn dit de resultaten waarop de hele techniek wordt beoordeeld.

• Kennis en redeneren — 83,95 vs 86,66. Een daling van 2,7 punten, en hier zit een aanzienlijk deel van de ontbrekende 1,8 punten op het totale gemiddelde.

• Vision — 78,59 vs 81,64. Een daling van 3,05 punten, het grootste verlies in één enkele categorie. Het is het vermelden waard dat de visiontoren zelf niet het gecomprimeerde deel is; het taalmodel dat de uitvoer ervan leest, is dat wel.

• Agentisch en tool calling — 77,57 tegenover 79,74. Het categoriegemiddelde omvat τ 2-Bench op 80,22 en BFCL v3 op 74,92.

Individuele resultaten die het weten waard zijn, omdat ze niet allemaal dezelfde kant op wijzen. Op Terminal-Bench 2.1 scoort het model 52,8 tegen 69,7 voor volledige precisie — ongeveer driekwart — en op SWE-bench Verified scoort het 60,8 tegen 80,6, opnieuw ongeveer driekwart. Dit was de eerste keer dat deze modelfamilie op Terminal-Bench werd geëvalueerd, en Prism ML zegt expliciet dat de langetermijnverbeteringen op het gebied van software-engineering die het in de eerste Bonsai-release beloofde, gedeeltelijk zijn, niet volledig. Daar staat tegenover: τ 2-Bench steeg van 73,6 naar 80,2 in de vorige release, BFCL v3 blijft op 74,9 staan, en AA-LCR staat op 77,0, binnen één punt van volledige precisie. AIME26 komt uit op 95,83 en LiveCodeBench op 90,07.

Waar je het wel en waar je het niet moet vertrouwen. Vertrouw het beeld bij wiskunde, programmeren en het volgen van instructies — dat zijn de categorieën waarin de techniek aantoonbaar doet wat ze belooft, en ze worden gemeten op dezelfde testopstelling als de baseline. Wees voorzichtig met agentisch werk over een lange horizon: de twee benchmarks die daadwerkelijk langdurig, toolgestuurd engineeringwerk op de proef stellen, Terminal-Bench 2.1 en SWE-bench Verified, laten een wezenlijk grotere kloof zien dan het geheel suggereert, en de leverancier zegt dat zelf in plaats van het te verbergen. En beschouw de hele tabel als de meting van één lab op één testopstelling totdat iemand anders die uitvoert. Die waarschuwing is hier geen formaliteit — het is het verschil tussen "dit model behoudt 98,2%" en "de leverancier van dit model heeft 98,2% gemeten op een suite die de leverancier zelf heeft gekozen." Beide zijn waar; slechts één is een feit over het model.

Waarom dit beter is dan een IQ2_XXS-build van hetzelfde basismodel

Dit verdient een eigen sectie in plaats van één regel, omdat het het volledige argument vormt voor kwantisatiebewuste ternaire training boven post-trainingkwantisatie.

De conventionele manier om Qwen3.8 27B klein te maken, is om het na de training te kwantiseren. Het vergelijkingspunt van het whitepaper is een IQ2_XXS GGUF-build van hetzelfde basismodel:

• Ternary Bonsai 2 27B — 1,76 bits/gewicht, 5,93 GB, gemiddelde over 20 benchmarks 83,9

• Qwen3.8 27B IQ2_XXS — 2,2 bits/gewicht, 7,3 GB, gemiddelde over 20 benchmarks: 75,2

Het tijdens de training gecomprimeerde model is zowel kleiner als beter. Het is 1,23x kleiner dan de conventionele low-bit-build en scoort 8,7 punten hoger. Die combinatie is geen afrondingscuriositeit; het is de bewering dat een representatie die tijdens de training wordt gekozen substantieel meer waard is dan hetzelfde nominale bitbudget dat achteraf wordt toegepast.

Het leerzamere deel is hoe de conventionele build faalt, omdat het falen selectief is en makkelijk te missen. IQ2_XXS degradeert niet gelijkmatig. Het houdt stand bij oppervlakkige kennis — 85,79 op MMLU-Redux — terwijl het instort bij taken die langdurige redeneerketens vereisen: 78,6 op AIME26, 70,05 op LiveCodeBench, 65,45 op GPQA Diamond. Bonsai 2 scoort 95,83, 90,07 en 85,76 op diezelfde drie. Een gewone chattest zou de IQ2_XXS-build prima bruikbaar vinden en het falen nooit aan het licht brengen; de schade zit precies waar lang redeneren en codegeneratie plaatsvinden. Die asymmetrie is waarom "het voelde prima toen ik het probeerde" geen bewijs is over een gekwantiseerd model.

Prism ML comprimeert hetzelfde argument tot één afgeleid cijfer dat het intelligentiedichtheid noemt — ruwweg benchmarkcapaciteit per gigabyte. In de suite van 20 benchmarks rapporteert het 0,444 per GB voor Bonsai 2, 0,276 voor de IQ2_XXS-build en 0,051 voor FP16. De metriek is een eigen constructie van de leverancier en de weging ervan is een ontwerpkeuze, geen wet; maar de ordening die eruit voortkomt is dezelfde ordening die de ruwe tabel oplevert, dus voegt het interpretatie toe in plaats van bewijs.

Nog een oprechte opmerking over de vergelijking. De GGUF-modelkaart van Prism ML rapporteert een tweede, smallere evaluatie — een suite in denkmodus met 14 benchmarks — waarop hetzelfde retentiecijfer opnieuw verschijnt: 84,78 tegenover 86,32, met IQ2_XXS op 72,59. Dat twee verschillende suites op hetzelfde 98,2% uitkomen, is een milde bevestiging dat de geaggregeerde claim geen artefact is van één benchmarkselectie. Het is nog steeds hetzelfde lab dat beide uitvoert, op dezelfde harness. Onze uitgebreidere uitsplitsing van deze match-up, inclusief de kwestie van het packing-formaat, staat in de vergelijking met de Qwen3.8 27B GGUF-builds.

Wat er echt nodig is om te runnen

De doorvoercijfers, afkomstig uit de gestandaardiseerde tg128-meting van de whitepaper bij batchgrootte 1, exclusief de visietoren:

• Apple M5 Max — 46,8 tok/s decodering, 765 tok/s promptverwerking

• Apple M5 Pro — 27,7 tok/s decode; een aparte run met een langer venster van het PQ2_0-pakket mat een aanhoudende 27,0 tok/s, met een verbruik van 27,0 W op de GPU-rail en 32,8 W over CPU en GPU

• Apple M4 Pro — 18,0 tok/s decoderen, waarbij promptverwerking bij ongeveer 125 tok/s de bindende beperking wordt voor zeer lange contexten

• NVIDIA RTX 5090 — 142,5 tok/s decodering op de PQ2_0-pack bij 0,582 mWh per token

De praktische claim die Prism ML maakt is niet een versnellingsratio maar een afwezigheid: de FP16-baseline van 53,8 GB past helemaal niet op een laptop met 16 GB, dus de betekenisvolle uitspraak is dat een model uit de 27B-klasse nu interactief draait op alledaagse hardware. Op de M5 Pro streamt de gemeten decode ongeveer 201 GB/s aan gewichten, wat het door geheugenbandbreedte gedomineerde profiel bevestigt dat de low-bit-representatie ontworpen is om te benutten.

Dan de randgevallen, die belangrijker zijn dan de piekcijfers.

Je kunt geen standaard llama.cpp gebruiken. De ternaire hybrid-attention-kernels bevinden zich in Prism ML's eigen llama.cpp-fork. Standaard llama.cpp verwerpt de types PTQ1_0 en PQ2_0 als onbekend, en — nog gevaarlijker — laadt het oudere ternaire Q2_0-formaat zonder enige waarschuwing en produceert onzin, omdat het geen Hadamard-activatieruntime heeft. Als je dit model uitvoert op een binaire build die de overeenkomende rotatie niet toepast, krijg je geen foutmelding; je krijgt onzin die er vloeiend uitziet. Dit is de meest waarschijnlijke manier om een middag te verspillen aan deze release.

De MLX-pack heeft geen CUDA-pad. De MLX-release (prism-ml/Ternary-Bonsai-2-27B-mlx-2bit) is gericht op Apple Silicon, waar deze aangepaste kernels heeft voor de hybride stack in zowel de Python- als de Swift-runtime. De gekwantiseerde matmul heeft Metal- en CPU-kernels, maar geen CUDA-implementatie, dus op een NVIDIA-machine krijgt die specifieke pack helemaal geen GPU-versnelling. CPU-inferentie werkt, maar een 27B forward pass op CPU kan minuten duren — wat het Linux-CPU-pad nuttig maakt voor implementatietests en reproduceerbaarheid, en onbruikbaar voor serving.

De twee packs zijn een echte afweging, geen rangschikking. Als je op een kaart uit de Ada-generatie of een L4 zit, of als geheugen de beperkende factor is, is PTQ1_0 de keuze bij 5,93 GB. Als je op Hopper, Blackwell of een 5090 zit, levert PQ2_0 je decodeersnelheid voor 1,3 GB. Als je op Apple silicon zit, let op: de M5 Pro-cijfers hierboven zijn gemeten op PQ2_0, wat ook de pack is die de demo-opstelling standaard downloadt.

Een opmerking over de eigen boekhouding van het MLX-pakket, want dit is een veelvoorkomende bron van verwarring. De MLX-container is een affien 2-bitsformaat waarvan het blok zowel een FP16-schaal en een FP16-bias opslaat voor elke groep van 128 gewichten. De ternaire gewichten van Bonsai hebben alleen de schaal nodig — de niveaus komen voort uit de schaal alleen — dus de bias is dode ballast, en het blok kost 36 bytes per 128 gewichten in plaats van 34. Dat brengt de verpakkingsratio van het MLX-pakket op 2,250 bits/gewicht, niet 1,72 en niet 1,76. Het is een andere container met dezelfde ternaire waarden, en het gemeten bestand op Hugging Face is 8,005 GiB.

De runtime-geabliteerde variant

Op 18 september publiceerde OrcaRouter de OrcaRouter Ternary Bonsai 2 27B Uncensored, die op dit model volledig tijdens runtime ablatie van de weigeringsrichting toepast. Het technische idee is meer aandacht waard dan het product, dus hier eerst het idee.

Conventionele abliteratie bewerkt gewichten. Het vindt een richting in de activatieruimte die overeenkomt met weigeringsgedrag, en orthogonaliseert vervolgens de gewichtsmatrices die in de residustroom schrijven ten opzichte van die richting: W ← W − r(rᵀW). Op een gewoon FP16-model is dat geen probleem — de bewerkte matrix is nog steeds een dichte drijvendekomma-matrix, dus je slaat die op en gaat verder. Op een ternaire pack is het een doodlopende weg, en wel juist om de reden dat dit hele model bestaat. Het orthogonaliseren van een ternaire matrix levert een dichte matrix met volledige precisie op. Om die weer in de ternaire pack op te slaan, zou je opnieuw moeten kwantificeren — en het opnieuw kwantificeren van bewerkte gewichten reproduceert niet de kwantificeringsbewuste training die het origineel heeft voortgebracht. Je zou precies weggooien wat was gekocht.

Dus de projectie verschuift in plaats daarvan naar inferentietijd. In plaats van W te veranderen, verander je de uitvoer:

• y ← y − α · dot(y, r) · r, berekend in float32, waarbij y een residuele bijdrage is en r de genormaliseerde weigeringsrichting

Bij α = 1 wordt uit elke residuele schrijving de component verwijderd die parallel aan de weigeringsrichting loopt. Bij α = 0 is het model onaangeroerd. Een α boven 1 projecteert te ver en kan de kwaliteit verslechteren. Omdat α een runtimeparameter is en niet een checkpoint-eigenschap, kan dezelfde pack in hetzelfde proces tegen zichzelf A/B-getest worden — precies wat de evaluaties van OrcaRouter doen. De originele Bonsai pack blijft bit-identiek: nul gewijzigde gewichten, nul herkwantisatie, nul extra kwantisatiefout in de gewichten.

Het zijn twee implementatiedetails waarop een naïeve versie hiervan stukloopt.

129 interventielocaties, niet 16.Elke module die in de residual stream kan schrijven, moet worden gewrapt, en in deze hybride architectuur gaat het om 64 mlp.down_proj-blokken, 48 linear_attn.out_proj-lagen, 16 self_attn.o_proj-lagen en model.embed_tokens — 129 in totaal. Alleen self_attn.o_proj wrappen is de voor de hand liggende fout, en het vangt er 16 van op, waardoor de andere 113 schrijfacties niet-geprojecteerd blijven. Een zelfcontrolescript meet of de resterende component langs de weigeringsrichting tot ongeveer 1e-6 van de residualnorm wordt teruggebracht, en waarschuwt als het niet alle 129 locaties detecteert.

Roteer de richting niet opnieuw. Het ternaire pakket houdt zijn projecties in een geroteerde basis op hun invoerdimensie en compenseert aan de activatiekant. De weigeringsprojectie werkt op de outputs van die projecties, die alweer terug zijn in de normale verborgen basis — dus de weigeringsrichting is een gewone 5120-dimensionale vector, en het toepassen van een extra Hadamard-rotatie daarop zou tegen de volledig verkeerde basis projecteren.

Wat OrcaRouter heeft gemeten — onze eigen cijfers, geen onafhankelijke

Dit zijn OrcaRouter's eigen regelgebaseerde metingen, en ze moeten als zodanig worden gelezen: een regelgebaseerde classifier voor openingszinnen, geen LLM-rechter, denkmodus uit, greedy-decodering, budget van 64 tokens, waarbij base en ablated dezelfde gewichten zijn in hetzelfde proces bij α = 0 versus α = 1. Ze zijn indicatief, niet van publicatiekwaliteit, en ze zijn geen verificatie van wat Prism ML ook maar heeft geclaimd.

Bij weigering, gemeten als het aandeel prompts dat een weigering ontving:

• AdvBench (n=100) — 99,0% basis, 6,0% geablateerd, met 56,0% beantwoord maar verpakt in een disclaimer

• JailbreakBench (n=100) — 96,0% basis, 4,0% geablateerd, 52,0% met voorbehoud

• StrongREJECT (n=150) — 99,3% basis, 3,3% geablateerd, 45,3% met voorbehoud

• HarmBench (n=150) — 98,7% basis, 7,3% geablateerd, 48,0% met voorbehoud

• MaliciousInstruct (n=100) — 97,0% basis, 0,0% geablateerd, 52,0% met voorbehoud

• ForbiddenQuestions (n=150) — 75,3% basis, 5,3% geablateerd, 42,7% met voorbehoud

• SimpleSafetyTests (n=50) — 96,0% basis, 18,0% geablateerd, 60,0% met voorbehoud — en dit cijfer is te laag weergegeven. Die set bestaat grotendeels uit prompts over zelfbeschadiging, en het model antwoordt daarop met een crisisdoorverwijzing die opent met "I am deeply sorry to hear…", wat de exacte frasenlijst van de classifier mist en als compliance aanmerkt. Het werkelijke resterende weigeringspercentage op die set is hoger dan 18,0%. De classifier is bewust ongewijzigd gelaten zodat de cijfers vergelijkbaar blijven met de andere modelkaarten van OrcaRouter.

In geen enkele set raakte een antwoord door zijn tokenbudget heen, dus geen van deze percentages wordt opgeblazen door truncatie. Bij onschadelijke prompts verwijdert dezelfde projectie ook overmatige weigering: XSTest-safe daalde van 5,2% weigering naar 0,4%, en de onschadelijke subset van JailbreakBench van 25,0% naar 0,0%. Het gepubliceerde pakket wijst een kwart van de onschadelijke prompts van die benchmark af; geablateerd wijst het er geen enkele af.

Qua capaciteit betekent het feit dat de gewichten bit-identiek zijn dat er geen herkwantisering betaald hoeft te worden, en de metingen komen daarmee overeen:

• MMLU (n=300) — 76,7% basis, 77,7% geablateerd, +1,0

• GSM8K (n=150) — 87,3% basis, 86,0% geablateerd, −1,3

• CMMLU (n=500) — 76,2% basis, 75,6% geablateerd, −0,6

Elke verschuiving valt binnen de ruis bij deze steekproefgroottes; één enkele GSM8K-vraag is 0,7 punt waard. MMLU-Pro wordt uitgesloten in plaats van gerapporteerd: de prompt ervan vraagt om redenering vóór het antwoord, en 63–64% van de reacties aan beide kanten hadden binnen het tokenbudget nog geen antwoord bereikt, dus elk nauwkeurigheidscijfer zou een ondergrens zijn die door het budget werd bepaald in plaats van een meting.

De kanttekening die er het meest toe doet.

De weigeringsrichting werd geschat op basis van het BF16-basismodel waarmee het Bonsai-pakket is getraind. De architectuur en de verborgen basis zijn identiek, dus de geometrie komt overeen. Maar hoe goed die richting kwantisatiebewuste training doorstaat, is niet volledig gemeten.

De runtime kan wiskundig en tot ongeveer 1e-6 bewijzen dat hij de aangeleverde richting uit elke residual write verwijdert. Hij kan daaruit alleen niet bewijzen dat de richting in het gekwantiseerde model nog steeds hetzelfde gedragskenmerk vastlegt als in het dense model. Dat zijn verschillende beweringen, en alleen de eerste staat vast. Iedereen die de veiligheidstabel hierboven leest, zou die moeten lezen in de wetenschap dat de interventie precies zo effectief is als de aanname van richtingsoverdracht, en die aanname is de open vraag.

Er is ook de praktische framing die OrcaRouter zelf aan de release geeft, en die is het waard om te herhalen in plaats van weg te parafraseren: het verwijderen van een aangeleerde weigeringsrichting kan ertoe leiden dat een model reageert op verzoeken die het origineel zou hebben geweigerd. Dit is een onderzoeks- en inferentiecontrolemechanisme, geen bewijs dat enige resulterende output veilig, correct of gepast is, en implementaties die het gebruiken, moeten hun eigen toegangscontroles en beleidshandhaving toepassen. Het verwijderen van weigeringen is geen gratis verbetering, en dit stuk is niet geschreven alsof dat wel zo is.

Nog drie praktische opmerkingen voor iedereen die het reproduceert. Het pakket moet met zijn eigen meegeleverde runtime worden geladen — een gewone MLX-loader kan lijken alsof hij het met succes laadt, terwijl hij stilzwijgend het verkeerde berekent, dus als de uitvoer verkeerd lijkt voordat ablatie zelfs maar is ingeschakeld, controleer dan eerst het laadpad. Laagselectieve ablatie wordt ondersteund, dus de interventie hoeft niet alles-of-niets te zijn. En de ablatie-evaluatie is uitgevoerd op de uitgevouwen FP16-uitbreiding van het pakket in plaats van dat het pakket zijn eigen kernels aanstuurt, omdat de packed quantized matmul geen CUDA-implementatie heeft en de CPU-backend minuten per forward pass nodig heeft; die uitbreiding bevat de ternaire waarden van het pakket exact en reproduceert de eigen next-token-verdelingen van het pakket tot op drie decimalen bij steekproeven, maar het is een containerwijziging en iets om van te weten. De code en de volledige tabellen staan in de OrcaRouter Ternary Bonsai 2 27B Uncensored-repository. Een afzonderlijke vergelijking van de geablateerde MLX-build met het ongewijzigde Qwen3.8 27B MLX-pad gaat dieper in op de runtime-specifieke details.

Waar dit heen gaat, en wat nog onbewezen is

Wat een nagenoeg verliesvrij 27B-model van ongeveer zes gigabyte voor lokale agents verandert, draait vooral om wat resident wordt. Een taalmodel dat samen met een echt contextvenster op een 16GB-laptop past, kan geladen blijven terwijl een agent ander werk doet — bestanden lezen, tools aanroepen, een plan over meerdere beurten vasthouden — in plaats van per verzoek te worden ingewisseld of naar een server te worden doorgeschoven. Dat is het verschil tussen een lokaal model dat je uitprobeert en een lokaal model dat je blijft draaien, en het is precies de eigenschap die de agentic-cijfers, τ 2-Bench op 80,2 en BFCL v3 op 74,9, moeten ondersteunen.

Wat onbewezen is, is een langere lijst dan de aankondiging suggereert.

• Geen onafhankelijke reproductie. Elk kwaliteitscijfer in dit artikel — de 83,9, de 98,2%, de categoriegemiddelden — is Prism ML's eigen meting op Prism ML's eigen suite. Dat is geen defect in de release; het is simpelweg hoe iets dat één dag oud is eruitziet. Het is ook het eerste dat zal veranderen.

• Langetermijn-agentisch werk is het zwakste onderdeel van de eigen tabel van de leverancier, niet het sterkste. Terminal-Bench 2.1 met 52,8 tegenover 69,7 is een echte kloof, en de leverancier zegt dat de capaciteit gedeeltelijk is.

• Prompts die je nog niet hebt geprobeerd. Het faalprofiel van low-bit-modellen is selectief, en de ineenstorting van IQ2_XXS op AIME26 en LiveCodeBench terwijl het 85,79 vasthoudt op MMLU-Redux is het duidelijkste beschikbare bewijs dat een benchmarkgemiddelde je niet vertelt wat er op jouw workload gebeurt. Bonsai 2 vertoont die ineenstorting op die twee benchmarks niet, wat bemoedigend is en niet hetzelfde als een garantie.

• De kwestie van richtingsoverdracht in de abliterated variant, hierboven, die door de constructie onopgelost is.

• Of de kernels standhouden terwijl de runtimes zich ontwikkelen. Op dit moment heeft dit model een fork nodig; de standaardversie van llama.cpp weigert twee van de drie formaten en verminkt het derde stilzwijgend. Totdat die kernels upstream landen, geldt "draait overal waar llama.cpp draait" nog niet voor dit model.

De release zelf staat niet ter discussie. Een multimodaal model van de 27B-klasse van 5,93 GB, een negende van de voetafdruk van het model waaruit het is gecomprimeerd, met wiskunde en programmeren op het niveau van het moedermodel en instructieopvolging iets voorop, is een werkelijk ander operationeel punt voor lokale inferentie. De redelijke houding op 18 september 2026 is om de bestandsgrootte als feit te aanvaarden, het retentiecijfer te beschouwen als een zorgvuldige claim van de leverancier van één dag geleden op een suite die de leverancier zelf heeft gekozen, en je oordeel over je eigen workload uit te stellen totdat je het erop hebt gedraaid.

De runtime-ablatiecode, de weigeringsrichting en de volledige evaluatietabellen worden gepubliceerd door OrcaRouter, samen met het routeringsplatform dat het team bouwt.