Ik Testte GLM5 Pony Alpha — Het Is Niet Wat Ik Verwachtte

Ik Testte GLM5 Pony Alpha — Het Is Niet Wat Ik Verwachtte

Drie nachten geleden stuitte ik op een model genaamd Pony Alpha op Open Router. Geen aankondiging. Geen hype-thread op X. Geen officieel blogbericht. Gewoon een mysterieuze vermelding die stil op de programmeerleaderboard zat — op de tiende plaats — met een 200K contextvenster en prestatiecijfers die me deden stoppen met scrollen.

Ik opende het, voerde mijn gebruikelijke battery aan coderingstests uit en binnen vijfenveertig minuten staarde ik naar iets dat nog niet had moeten bestaan. Een geanimeerde SVG-vlinder met fotorealistische vleugelbeweging. Een volledig interactieve landingspagina met vloeiende overgangen en dynamische elementen. Een op browsers gebaseerd besturingssysteem met werkende apps — een tekenprogramma, een mijnenveger, een weerwidget, allemaal gegenereerd vanuit één prompt.

Dit was geen proof-of-concept demo-model. Dit was iets serieus dat zich achter een gekke naam verborg.

Na het grootste deel van drie dagen met het testen van Pony Alpha — coding-uitdagingen, frontend-generatie, game-ontwikkeling, complexe simulaties — ben ik ervan overtuigd dat dit eigenlijk GLM5 is, het volgende basismodel van Zhipu AI. En als ik gelijk heb, is het open-source AI-landschap zojuist een stuk interessanter geworden. Maar er is een vangst die de meeste berichtgeving over het hoofd ziet, en ik kom er straks op terug.

Waarom Een "Stealth Model" Meer Telt Dan Je Denkt

Dit is het ding over stealth-releases in AI — ze zijn geen ongelukken. Wanneer een model opduikt op platforms zoals Open Router, Arena en Hilo zonder marketingpush, zonder zelfs een juiste naam, is dat een bewuste strategie. Het team erachter wil real-world prestatiegegevens van ontwikkelaars die niet weten wat ze testen. Geen placebo-effect. Geen hype-bias. Gewoon eerlijke benchmarks van mensen zoals jij en ik die echte problemen erop gooien en kijken wat blijft kleven.

Ik heb Chinese AI-modellen gevolgd sinds de originele ChatGLM-lancering, en Zhipu AI heeft dit trucje eerder uitgehaald. Hun GLM4 verscheen weken voor de officiële aankondiging onder een ander alias op verschillende benchmarkplatforms. Het patroon is onmiskenbaar.

Wat me deze keer aandacht liet schenken? De cijfers klopten niet — op een goede manier. De reacties van het model waren sneller dan ze zouden moeten zijn voor iets dat zo capabel is. De codekwaliteit wedijverde met wat ik krijg van Claude Opus 4.5 bij bepaalde taken. En dat 200K contextvenster was niet alleen een marketingcijfer — ik voedde het daadwerkelijk een codebase van 150K tokens en het behield coherent begrip gedurende.

Als je Chinese AI-modellen hebt afgewezen als eeuwige runners-up, kan dit je dwingen te heroverdenken. De kloof sluit sneller dan de meeste westerse ontwikkelaars beseffen. En het feit dat het gratis te testen is op dit moment? Dat is een venster dat niet voor altijd openblijft.

Maar voordat ik je de resultaten laat zien, moet je begrijpen wat er onder de motorkap zit — want de architectuur verklaart waarom dit model zo ver boven zijn gewichtsklasse uitkomt.

745 Miljard Parameters en de Truc Die Het Praktisch Maakt

Laat me wat cijfers op je loslaten. Pony Alpha — of GLM5, zoals ik het hierna zal noemen — wordt geschat op ongeveer 745 miljard totale parameters. Dat is enorm. Groter dan DeepSeek V3. Potentieel het grootste Chinese Mixture of Experts-model ooit gebouwd.

Maar hier is het deel dat er echt toe doet: slechts 44 miljard parameters zijn op elk moment actief.

Als je niet bekend bent met Mixture of Experts (MoE)-architectuur, denk er dan zo over na. Stel je voor dat je een ziekenhuis runt. Je kunt één dokter inhuren die een beetje van alles weet — een huisarts met brede maar ondiepe kennis. Of je kunt vijftig specialisten inhuren en elke patiënt doorsturen naar de twee of drie experts die het meest relevant zijn voor hun aandoening. Het ziekenhuis heeft vijftig artsen in dienst, maar een individuele patiënt ziet er maar een paar.

Dat is MoE. GLM5 heeft deze enorme pool van gespecialiseerde "expert" netwerken, maar voor een gegeven input activeert het alleen de subset die het meest relevant is. Het resultaat is een model dat de kennisbreedte heeft van een 745B-parameter gigant maar de inferentiesnelheid van iets veel kleiner.

Het specifieke mechanisme dat GLM5 gebruikt heet DC sparse attention — een techniek die specifiek is ontworpen voor het efficiënt verwerken van extreem lange invoersequenties. De meeste transformermodellen kampen ermee wanneer contextvensters groot worden omdat de aandachtsberekening kwadratisch schaalt. DC sparse attention omzeilt dat knelpunt door selectief te zijn over welke tokens aandacht besteden aan welke andere tokens. Het model leert welke verbindingen ertoe doen en negeert de rest.

Dit is waarom GLM5 een echt 200K contextvenster kan bieden zonder dat de reactietijden onbruikbaar worden. Ik testte het met progressief grotere inputs — 50K tokens, 100K, 150K — en hoewel de latentie wel toenam, bleef die binnen een bereik dat ik praktisch zou vinden voor ontwikkelingswerk. Vergeleken met het voeren van dezelfde lange context aan andere grote modellen die ik heb gebruikt, was het verschil merkbaar.

De vergelijking met GLM4.5 is opvallend — ruwweg dubbele totale parameters met aanzienlijk verbeterde langcontextverwerking. Dat is geen incrementele upgrade. Dat is een generatiesprong.

De architectuur is indrukwekkend op papier. De vraag is of die zich vertaalt in echte outputkwaliteit. Dus voerde ik mijn standaard gauntlet van tests uit — dezelfde die ik gebruik wanneer een nieuw model beweert competitief te zijn. Wat eruit kwam, verraste me meer dan eens.

De SVG-Test — Waar Kunst Kunst Ontmoet Code

Wanneer ik een coderingsmodel evalueer, is mijn eerste test altijd SVG-generatie. Waarom? Omdat SVG's zitten op het snijpunt van visuele creativiteit en precieze codesyntax. Het model moet geometrie, animatietiming, kleurtheorie en XML-structuur tegelijkertijd begrijpen. De meeste modellen kunnen een basis SVG-cirkel produceren. Heel weinig kunnen iets produceren wat je eigenlijk zou willen bekijken.

Mijn prompt was eenvoudig: "Maak een geanimeerde vlinder met fotorealistische kleuring en natuurlijke vleugelbeweging."

GLM5 produceerde een vlinder die me werkelijk verraste. De vleugelgeometrie was complex — meerdere gelaagde paden die diepte en doorzichtigheidseffecten creëerden. De animatie gebruikte CSS-keyframes met easing-curven die het licht onregelmatige ritme van echte vluchtvlinders nabootste. De kleuring betrof verloopvullingen met meerdere kleurstops die een overtuigend monarchvlinderpatroon creëerden.

Was het perfect? Nee. Wanneer ik het naast wat Opus 4.6 genereert voor dezelfde prompt vergeleek, had de Opus-versie iets meer verfijnde paddefinities en vloeiendere verloopovergangen. Maar de kloof was kleiner dan ik verwachtte. Misschien 85% van de weg — en voor een model dat vermoedelijk nog een vroeg checkpoint is, is dat opmerkelijk.

Ik drong verder. Een stadsgezicht bij zonsondergang. Een geanimeerde oceaangolf. Een mechanische wijzerplaat met bewegende tandwielen. GLM5 verwerkte ze allemaal met competente, soms indrukwekkende resultaten. De wijzerplaat toonde in het bijzonder sterk begrip van rotationele mechanica — elk tandwiel meshte goed met zijn buren en roteerde op de correcte relatieve snelheden.

Het patroon dat ik merkte: GLM5 blinkt uit in structurele nauwkeurigheid — de code compileert, de animaties werken, de verhoudingen kloppen. Waar het iets tekortschiet vergeleken met topmodellen is in de artistieke verfijning — de subtiele details die een SVG er gepolijst in plaats van slechts correct doen uitzien.

Dat is een oplosbaar probleem met fine-tuning. De fundering is solide.

Hier wordt het echter echt interessant. SVG's zijn een partijtruc. Wat ik eigenlijk wil weten, is of een model dingen kan bouwen die echte gebruikers mee zouden interageren.

Frontend-Generatie Die Me Deed Dubbelchecken

Mijn tweede test is altijd een volledige landingspagina. Ik gaf GLM5 deze prompt: "Bouw een moderne, volledig interactieve landingspagina voor een fictieve AI-startup genaamd NeuralFlow. Voeg een hero-sectie toe met geanimeerde achtergrond, feature-kaarten met hover-effecten, een prijstabel met schakelaar tussen maandelijks en jaarlijks, testimonialcarrousel en een contactformulier met validatie."

Wat terugkwam was — en ik weeg mijn woorden zorgvuldig hier — productieklare code. De lay-out was schoon, responsief en goed gestructureerd. De geanimeerde heldenachtergrond gebruikte een subtiel deeltjessysteem dat de browserprestaties niet vernietigde. Feature-kaarten hadden vloeiende schaal-en-schaduw hover-overgangen. De prijsschakelaar werkte daadwerkelijk, waarbij alle drie de tier-prijzen werden bijgewerkt met een mooie cross-fade animatie.

De testimonialcarrousel roteerde automatisch met pauzeren-bij-hover-gedrag. Het contactformulier valideerde e-mailformaat en verplichte velden met inline foutmeldingen die verschenen met een zachte neerwaartse sliding animatie.

Ik opende de ontwikkelaarstools en verwachtte een rommel van inline stijlen en spaghetti-JavaScript te vinden. In plaats daarvan vond ik redelijk georganiseerde CSS-aangepaste eigenschappen, semantische HTML en JavaScript dat moderne patronen gebruikte. Niet vlekkeloos — er waren een paar redundante event listeners en één z-index probleem waardoor de mobiele nav achter de hero-sectie renderde. Maar dit zijn het soort bugs die je zou vinden in code geschreven door een competente junior ontwikkelaar, niet het soort structurele problemen die aangeven dat een model webontwikkeling niet begrijpt.

Mijn volgende test verhoogde de moeilijkheid. "Bouw een celebrity portfolio-landingspagina — kies een echte publieke figuur en maak een pagina die aanvoelt als hun persoonlijk merk." GLM5 koos autonoom, stijlde alles vanaf nul, voegde meerdere secties met verschillende visuele behandelingen toe, inclusief vloeiend scrollgedrag, en bedraadde interactieve elementen. De ontwerpkeuzes waren coherent en eigenzinnig op een manier die intentioneel aanvoelde in plaats van willekeurig.

Ik heb genoeg tijd besteed aan het reviewen van AI-gegenereerde frontends om te weten waar ik op moet letten. De verradelijke tekens van een model dat componentpatronen heeft gememoriseerd versus een model dat lay-outprincipes werkelijk begrijpt. GLM5 toonde echt begrip. Toen ik het vroeg om de testimonials boven de prijssectie te verplaatsen, deed het niet alleen knippen en plakken — het paste de visuele stroom aan, updatde de scroll-gebaseerde animaties om op de nieuwe posities te triggeren en wijzigde de kleurovergang tussen secties om visuele coherentie te behouden.

Dat niveau van contextueel bewustzijn tijdens modificatie is wat een goed coderingsmodel van een geweldig model onderscheidt. En dit is verondersteld de pre-releaseversie te zijn.

Een Volledig OS in de Browser Bouwen — Vanuit Één Prompt

Hier is de prompt die gewoonlijk uitdagers van pretendenten onderscheidt: "Bouw een browsergebaseerd besturingssysteem met een werkend bureaublad, taakbalk en minimaal vijf functionele applicaties. Voeg een webbrowser, weer-app, spel, tekenprogramma en systeemmonitor toe. Laat het eruitzien als een mix van macOS en Windows."

Ik noem dit mijn "stresstest van de hel." Een model moet vensterbeheersystemen, statusbeheer over onafhankelijke applicaties, UI-rendering voor volledig verschillende apptypes coördineren en visuele consistentie behouden — allemaal in één generatiepass.

GLM5 produceerde wat het "Pony OS" noemde. En eerlijk gezegd? Ik was onder de indruk.

Het bureaublad renderde met een schone achtergrond, dock-stijl taakbalk onderaan en een bovenste menubalk met een klok. Op app-pictogrammen klikken opende versleepbare, vergrootte vensters met correct z-index beheer — op een achtergrondvenster klikken bracht het naar voren. De minimaliseer- en sluitknoppen werkten.

Laat me elke app doorlopen:

De Webbrowser — had een adresbalk, navigatieknoppen en renderde een standaard startpagina. Het kon geen echte webinhoud ophalen (dat zou server-side proxy vereisen), maar de UI was compleet en het navigatiestatusbeheer was correct.

Weer-app — toonde een fictieve vijfdaagse weersvoorspelling met temperatuurgrafieken en weericonen. De gegevens waren hardgecodeerd, maar de UI was gepolijst met correct lay-out en responsief kaartontwerp.

Mijnenveger — volledig speelbaar. Rechtsklikken om te markeren, linksklikken om te onthullen, correct flood-fill algoritme voor lege cellen, mijnteller en een timer. Ik speelde daadwerkelijk drie rondes. Won er twee.

Tekenprogramma — op canvas gebaseerd tekenen met kleurkiezer, penseelgrootteschuifregelaar, gumgereedschap en een wis-knop. Het tekenen was vloeiend met correcte muisgebeurtenisverwerking. Niet Photoshop, maar werkelijk functioneel.

Systeemmonitor — toonde geanimeerde CPU- en geheugengebruiksgrafieken met willekeurige gegevens. De grafieken werden in real time bijgewerkt met vloeiende lijnrendering.

Werkte alles vlekkeloos? Nee. De donkere modus schakelaar in het instellingspaneel veranderde het thema niet daadwerkelijk — het schakelde een klasse die niet was verbonden aan de CSS-variabelen. Sommige vensters konden buiten de viewport worden versleept zonder grensdetectie. Het gumgereedschap van het tekenprogramma liet artefacten achter aan de randen van streken.

Maar neem een stap terug en bedenk wat er eigenlijk is gebeurd. Één model, in één generatiepass, produceerde een gecoördineerde multi-applicatie desktopomgeving met werkende spellen, tekengereedschappen en systeemhulpprogramma's. De HTML, CSS en JavaScript kwamen eruit als één coherent pakket dat in de browser liep zonder aanpassing.

De meeste modellen die ik heb getest weigeren deze prompt geheel, produceren iets dat eruitziet als een bureaublad maar waarbij niets werkt, of genereren apps die onafhankelijk werken maar niet kunnen samenleven in hetzelfde vensterbeheersysteem. GLM5 sloeg het moeilijkste deel — de coördinatie — terwijl er wat polijsting op tafel bleef.

Een Minecraft-kloon en een Melkwegstelsel — De 3D-Grens Aflasten

Twee meer tests. Eerste: "Bouw een Minecraft-achtig voxelspel met Three.js met blokken breken, blokken plaatsen en procedurele terrein generatie met hoogte-gebaseerde bioomkleuring."

GLM5's eerste poging produceerde een werkende 3D-wereld. Je kon bewegen met WASD, rondkijken met de muis en het terrein had zichtbare chunkgrenzen met verschillende hoogteniveaus. Blokken breken werkte — klik op een blok, het verdwijnt. Blokken plaatsen werkte — rechtsklikken om een blok adjacent aan degene die je bekijkt te plaatsen.

De terrein generatie gebruikte Perlin noise voor hoogtekartering, en de bioomkleuring creëerde een verloop van zandkleurige laagvlakten naar groene middengebieden naar grijswitte toppen. Het chunk-laadsysteem renderde terrein rond de speler en culde verre chunks voor prestaties.

Problemen? De eerste versie had z-fighting op sommige blokfaces waar aangrenzende chunks elkaar ontmoetten. De verlichting was plat — geen omgevingsocclusie of schaduweffecten. En de raycast voor blokplaatsing bevestigde blokken af en toe aan het verkeerde vlak bij steile hoeken.

Ik vroeg om versie 2. GLM5 verbeterde de visuals merkbaar — betere textuurachtige kleuring op blokfaces, de artefacten van chunkgrenzen opgelost en een basis hemelverloop toegevoegd. Het raycast-probleem bleef bestaan en introduceerde een nieuw probleem waarbij af en toe twee blokken tegelijkertijd werden geplaatst. Solide verbetering, maar geen volledige oplossing.

Mijn eerlijke beoordeling: de 3D-output is waar GLM5 zijn leeftijd toont vergeleken met topmodellen. De code is architecturaal solide — het chunksysteem, het raycasting, de op noise gebaseerde generatie zijn allemaal correct geïmplementeerd. Maar de randgevallen en visuele polijsting die een 3D-applicatie afgewerkt doen voelen, zijn er nog niet. Voor prototyping en proof-of-concept werk is het uitstekend. Voor verzending zou je betekenisvolle menselijke verfijning nodig hebben.

De zonnestelsel-simulatie was anderzijds een echte lichtpunt. De prompt was eenvoudig — "simuleer het zonnestelsel met accurate relatieve groottes, baanperioden en visuele stijl" — en GLM5 produceerde een prachtige Three.js-scène met alle acht planeten die op correcte relatieve snelheden cirkelen, getextureerde sferen, baanspoorlijnen en een gloeiende zon met een puntlicht dat verlichting wierp op de planetoppervlakken. De Saturnusringen waren een mooie aanraking die ik niet expliciet had gevraagd.

Snel, nauwkeurig en visueel aantrekkelijk. Dit is waar de kracht van het model in het combineren van wiskundige precisie met visuele output werkelijk uitblinkt.

Het Eerlijke Gesprek Dat Niemand Voert Over GLM5

Ik moet iets aanpakken dat steeds terugkomt wanneer Chinese AI-modellen opduiken, want het negeren ervan zou oneerlijk zijn.

Er zijn hardnekkige geruchten — en op dit punt meer dan geruchten — dat modellen zoals GLM5 zijn getraind op synthetische gegevens gegenereerd door Amerikaanse AI-bedrijven. Outputs van Anthropic's Claude, Google's Gemini en OpenAI's GPT-modellen vormen naar verluidt deel van de trainingsmix. Dit is een bekende praktijk in de Chinese AI-industrie, en Zhipu AI is niet het enige bedrijf dat dit doet.

Wat betekent dit praktisch? Voor de meeste ontwikkelaars die evalueren of ze GLM5 voor hun projecten gebruiken, waarschijnlijk niet veel. Je geeft om outputkwaliteit, snelheid, kosten en betrouwbaarheid. De herkomst van trainingsgegevens is een ethische en juridische vraag die boven het betalingsniveau van een individuele ontwikkelaar ligt.

Maar ik denk dat het de moeite waard is om er transparant over te zijn. Wanneer ik zeg dat de codeoutputkwaliteit van GLM5 "wedijvert met Opus 4.5," is er een reden daarvoor. Het model heeft waarschijnlijk enorme hoeveelheden hoogwaardige outputs gezien van — en van geleerd — precies die modellen. Dat is niet per se een kritiek. Alle modellen leren van bestaande tekst. Maar de specifieke dynamiek van Chinese labs die trainen op Amerikaanse modeloutputs creëert een gecompliceerd landschap waarmee de industrie zich nog niet volledig heeft verzoend.

Mijn persoonlijke standpunt? Ik evalueer modellen op hun output, niet op hun herkomstverhaal. Als GLM5 betere code genereert voor mijn gebruik dan het alternatief, gebruik ik het. Maar ik ga erin met open ogen over wat het model is en hoe het daar is gekomen.

Het andere ding waarvoor ik eerlijk wil zijn: de naam "Pony Alpha" en de stealth-release suggereren dat dit nog een vroeg checkpoint is, niet het uiteindelijke model. Sommige ruwe randen die ik tegenkwam — de donkere modus schakelaar die niet werkt, de raycast-bugs in de Minecraft-kloon, af en toe breedsprakigheid in codecommentaren — deze kunnen worden opgelost voor de officiële GLM5-lancering. Of niet. Gokken op toekomstige verbeteringen is een spel dat ik eerder heb verloren.

Nog een gedachte die misschien impopulair is. Er zweeft een ander stealth-model rond — Aurora Alpha — dat minder indrukwekkend presteert en GPT-stijl outputs lijkt na te bootsen. Als de lekken nauwkeurig zijn en dit op de een of andere manier verbonden is met het OpenAI-ecosysteem, kijken we naar een heel schaduw-ecosysteem van AI-modellen die anoniem worden getest op openbare platforms. Dat is ofwel opwindend of zorgwekkend afhankelijk van je perspectief. Voor mij is het voornamelijk fascinerend.

Wat me het meest bezighoudt, is wat je vandaag daadwerkelijk met dit model kunt doen. Hier is hoe je het in handen kunt krijgen.

Aan de Slag Met GLM5 Pony Alpha — Een Praktische Gids

Op dit moment heb je meerdere paden om GLM5 gratis te proberen. Hier is de snelste manier om van nul naar lopende prompts te gaan:

1. Open Router (Eenvoudigste Pad)

Ga naar Open Router en zoek naar "Pony Alpha" in de modellijst. Je kunt het direct gebruiken via de Open Router-speeltuin zonder enige setup. Het model verschijnt onder zijn stealth-naam — zoek niet naar "GLM5" want het staat nog niet onder die identificatie.

# Als je de Open Router API gebruikt:
curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "pony-alpha",
    "messages": [{"role": "user", "content": "Your prompt here"}],
    "max_tokens": 4096
  }'

Pro-tip: Stel max_tokens hoger in voor coderingstaken — 8192 of zelfs 16384 als je prompt het genereren van complete applicaties vereist. GLM5 heeft de neiging om grondige, complete implementaties te produceren in plaats van verkorte fragmenten, dus het ruimte geven om te werken loont.

2. Arena (Voor Blinde Vergelijking)

LMSys Arena laat je GLM5 testen in blinde A/B-vergelijkingen met andere modellen. Dit is eigenlijk hoe ik het voor het eerst opmerkte — ik bleef hetzelfde "mysterymodel" kiezen als winnaar in codering-vergelijkingen, en toen ik de onthulling controleerde, was het elke keer Pony Alpha.

3. API-Toegang via Kilo

Voor programmatische toegang met hogere snelheidslimieten biedt Kilo API-eindpunten. Het setupproces is vergelijkbaar met elke OpenAI-compatibele API — wissel de basis-URL en API-sleutel, behoud hetzelfde berichtformaat.

4. Testaanbevelingen

Op basis van mijn ervaring, hier is waar te beginnen:

• Frontend-generatie — dit is de sweet spot van GLM5. Geef het complexe UI-beschrijvingen en wees specifiek over interacties en animaties. De resultaten zullen je verrassen.
• Code refactoring — voed het een rommelige functie en vraag om een schone herschrijving. Het 200K contextvenster betekent dat je volledige bestanden voor context kunt opnemen.
• SVG en visuele code — geweldig voor het programmatisch genereren van illustraties, diagrammen en geanimeerde afbeeldingen.
• Langcontextanalyse — gooi je hele codebase erop en stel vragen. Het DC sparse attention-mechanisme verwerkt dit werkelijk goed.

Wat nu te vermijden: Taken die extreem precieze numerieke berekening vereisen, real-time gegevenstoegang (het is een LLM, geen zoekmachine), en alles wat meerstaps agentisch gedrag met gereedschapsgebruik vereist — het model is sterk bij generatie in één pass maar heeft hetzelfde niveau van polijsting in multi-turn agentische workflows nog niet getoond.

5. Veelvoorkomende Valkuilen

Eén ding dat ik opmerkte: GLM5 reageert beter op gedetailleerde, specifieke prompts dan op vage. "Bouw een landingspagina" geeft je iets generisch. "Bouw een landingspagina voor een AI-startup met een deeltjesanimatie hero, drie feature-kaarten met hover lift-effecten, een prijstabel die schakelt tussen maandelijks en jaarlijks met geanimeerde prijswijzigingen, en een donker kleurenschema met marineblauwen en elektrisch blauw" geeft je iets dat de moeite waard is te verzenden.

Ook — en dit struikelde me aanvankelijk — het model genereert soms code met Chinese variabelenamen of commentaren wanneer het ambiguïteit in de prompttaal detecteert. Het toevoegen van "gebruik Engels voor alle code, commentaren en variabelenamen" aan je systeemprompt elimineert dit volledig.

Wat Dit Betekent Voor de Open-Source AI Race

Neem een stap terug van de individuele testresultaten voor een moment en kijk naar het grotere geheel.

Een jaar geleden was de kloof tussen de beste propriëtaire modellen en de beste open-source alternatieven enorm. Je zou GPT-4 of Claude gebruiken voor serieus werk en open-source modellen voor experimentatie en kostenoptimalisatie. Die rekenmethode verschuift onder ons.

GLM5 — als de parameterramingen nauwkeurig zijn — vertegenwoordigt een nieuwe klasse van open-source modellen. Zevenhonderd vijfenveertig miljard parameters. Niet een fine-tuned versie van iemand anders' fundering. Niet een klein model dat boven zijn gewicht stoot door slimme training. Een werkelijk massief model met architecturale innovaties die het praktisch maken om te draaien en een contextvenster dat concurreert met de beste propriëtaire aanbiedingen.

Dit is wat ik verwacht te zien gebeuren. De officiële GLM5-release — waarschijnlijk deze maand gezien de lekken en GitHub-waarnemingen — zal komen met juiste documentatie, fijn-afgestemde varianten en gekwantiseerde versies geoptimaliseerd voor consumentenhardware. De gemeenschap zal er onmiddellijk op beginnen te bouwen. Binnen weken zullen we GLM5-gebaseerde codeerassistenten, chatbots en gespecialiseerde gereedschappen overal op GitHub zien.

De MoE-architectuur van het model met slechts 44B actieve parameters betekent dat het mogelijk uitvoerbaar is op high-end consumenten-GPU's met agressieve kwantisatie. Dat is het echte verhaal hier. Niet dat een Chinese lab een groot model heeft gemaakt — dat is al jaren aan de gang. Het verhaal is dat een 745B-parameter model misschien toegankelijk is voor individuele ontwikkelaars en kleine teams.

Drie statistieken om te volgen na de officiële lancering: inferentiesnelheid op consumentenhardware, kwaliteit van fine-tunes door de gemeenschap op de 30-daagse markering, en of het 200K contextvenster standhoudt onder diverse real-world werklasten (niet alleen de coderingstaken die ik heb getest).

Ik raakte drie dagen geleden in dit konijnenhol en verwachtte twintig minuten te besteden aan het testen van een ander vergeetbaar model met een rare naam. Ik schrijf er in plaats daarvan vierduizend woorden over, wat je alles vertelt over hoe die twintig minuten werkelijk gingen.

GLM5 Pony Alpha is niet het beste coderingsmodel dat momenteel beschikbaar is — Opus 4.6 houdt die kroon in mijn testen, en de nieuwste Claude-modellen hebben een verfijning in code-architectuur die GLM5 nog niet heeft geëvenaard. Maar het is misschien het beste open-source coderingsmodel dat ik ooit heb gebruikt, en het feit dat het een pre-release checkpoint is, maakt de trajectorie werkelijk opwindend.

De vraag waar ik steeds op terugkom: als dit de vroege versie is, hoe ziet de gepolijste release er dan uit?

Hier is mijn uitdaging aan jou. Ga vanavond naar Open Router. Pull Pony Alpha op. Geef het de moeilijkste single-prompt coding-uitdaging die je kunt bedenken — de uitdaging die je hebt gebruikt als je persoonlijke lakmoestest voor AI-modellen. Voer het uit. Kijk naar de output. Kom dan terug en vertel me wat je vond.

Want de beste evaluaties komen niet van reviewers zoals ik die gestandaardiseerde tests draaien. Ze komen van duizenden ontwikkelaars die hun echte problemen op een model gooien en zien wat breekt. GLM5 is gratis. Het venster staat open. De enige kosten zijn je nieuwsgierigheid.

En eerlijk gezegd? Die vlinder-animatie alleen was de drie dagen al waard.

🤝 Laten We Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je tech-infrastructuur schalen? Ik help je graag.

• 🔗 Fiverr (custom builds & integraties): fiverr.com/s/EgxYmWD
• 🌐 Portfolio: mejba.me
• 🏢 Ramlit Limited (zakelijke oplossingen): ramlit.com
• 🎨 ColorPark (design & branding): colorpark.io
• 🛡 xCyberSecurity (beveiligingsdiensten): xcybersecurity.io