Laatst bijgewerkt: 1 augustus 2026
OpenAI publiceerde op 1 augustus 2026 een claim die de wiskundewereld door elkaar schudde: hun nieuwe model, Astra, loste tien open wiskundeproblemen op met formeel geverifieerde bewijzen in Lean. Geen "het gaf een goed klinkend antwoord" — daadwerkelijke machinegeverifieerde bewijzen die door een wiskundige verificator zijn gecontroleerd en correct bevonden.
Dit is groot. Het is ook omgeven door hype die nauwkeurig van spin moet worden gescheiden. Hier is mijn ontleding als bouwer: wat echt is, wat opgeblazen is, en wat het verandert voor iedereen die dagelijks AI-agenten draait.
Wat OpenAI Astra Daadwerkelijk Publiceerde
Astra loste tien eerder onopgeloste wiskundeproblemen op en produceerde formele bewijzen in Lean 4 — een programmeertaal voor wiskundige bewijzen waarin elke stap machinaal wordt geverifieerd. Dit is fundamenteel anders dan een LLM dat een "bewijs" genereert in natuurlijke taal dat er overtuigend uitziet maar fouten kan bevatten.
Het belangrijkste resultaat: Astra produceerde het eerste bewijs van het bestaan van een niet-sofische groep — een open probleem in de groepentheorie dat wiskundigen decennia had tegengehouden. Dit werd onafhankelijk geverifieerd door wiskundigen buiten OpenAI.
De berekening kostte naar verluidt ~$2.000 aan compute. Dat getal verdient context.
Waarom het Niet-Sofische Groepresultaat Het Enige Is Dat Ertoe Doet
Van de tien problemen is het niet-sofische groepbewijs het significantst omdat het een probleem oplost dat wiskundigen niet alleen niet konden oplossen, maar waarvan velen betwijfelden of het überhaupt oplosbaar was met huidige technieken.
De andere negen resultaten zijn wiskundig geldig maar minder significant — het zijn problemen die waarschijnlijk uiteindelijk door menselijke wiskundigen waren opgelost. Het niet-sofische groepresultaat is het enige waar het model iets deed wat mensen aantoonbaar niet konden.
Wat Is Formele Verificatie, en Waarom Maakt Het de Claims Controleerbaar?
Formele verificatie via Lean betekent dat het bewijs niet op vertrouwen draait. Elke logische stap wordt gecontroleerd door de Lean-verificator — een stuk software dat wiskundige logica afdwingt. Als het bewijs door Lean komt, is het correct. Geen interpretatiemarge, geen "het ziet er goed uit" — het is wiskundig waterdicht.
Dit is wat Astra onderscheidt van eerdere AI-wiskundeclaims: het is controleerbaar. Je hoeft OpenAI niet op hun woord te geloven — je kunt het bewijs zelf door Lean halen.
Waar het $2.000-Getal Uit Elkaar Valt
OpenAI claimt dat Astra de tien bewijzen produceerde voor ~$2.000 aan compute. Dat klinkt indrukwekkend goedkoop. Maar:
De $2.000 is de inference-kost — het draaien van het getrainde model. Het bevat niet de trainingskosten, die naar schatting miljoenen bedragen. Het bevat niet de mislukte pogingen — alleen de succesvolle runs. En het bevat niet de menselijke onderzoekers die het model stuurden en de resultaten verifieerden.
Het eerlijke getal is: $2.000 om de bewijzen te genereren, onbekende miljoenen om het model te trainen, en onbekende menselijke uren om het proces te begeleiden. De $2.000 is echt maar het is niet het hele verhaal.
Hoe Dit Eruitziet Vanuit een Agentenvloot
Hier is waarom dit relevant is als je geen wiskundige bent.
Astra's kernvermogen — lang nadenken over een complex probleem, stappen formeel verifiëren, en doorgaan tot het een bewezen correct antwoord heeft — is precies het patroon dat agentische AI-systemen nodig hebben. De meeste agentfouten zijn geen intelligentiefouten. Het zijn verificatiefouten — de agent denkt dat het klaar is maar heeft het niet gecontroleerd.
Astra demonstreert dat een model lang genoeg kan redeneren om een formeel bewijs te produceren en dat bewijs te laten verifiëren door een externe checker. Als je dat patroon — genereer + verifieer — toepast op codegeneratie, krijg je agents die hun eigen code niet alleen schrijven maar formeel testen.
De Verificatiepoort: De Gewoonte Die Het Waard Is Om Over Te Nemen
De les voor bouwers is niet "gebruik Astra voor wiskunde." Het is: bouw een verificatiestap in elke agentlus.
Astra's kracht is niet het genereren — het is het verifiëren. De Lean-checker is de externe autoriteit die zegt "dit klopt" of "dit klopt niet." De equivalent in codeerworkflows: laat je agent tests schrijven voor zijn eigen output, draai die tests, en accepteer de output alleen als de tests slagen.
Dit is hetzelfde principe als de verificatielussen die ik beschreef in mijn Fable 5 promptgewoontes — maar nu met een concreet voorbeeld van hoe krachtig het is wanneer het model zijn eigen werk formeel kan controleren.
Wat Ik Nog Niet Koop
Dat dit generaliseert naar alle problemen. Wiskunde is uniek geschikt voor formele verificatie — de regels zijn exact, de checker is waterdicht. Codegeneratie is dichtbij maar niet identiek. Natuurlijke taalprobleem (strategie, communicatie, design) zijn ver verwijderd van formele verificatie.
Dat de $2.000 representatief is. Zie hierboven.
Dat dit beter is dan DeepMind's AlphaProof. DeepMind loste in 2024 IMO-problemen op met een vergelijkbare aanpak. Astra gaat verder (open onderzoeksproblemen vs. competitieproblemen), maar het is een voortbouwen op eerder werk, niet een fundamentele doorbraak in de aanpak.
Wat Daadwerkelijk Verandert voor een Werkende Ontwikkelaar
Eén ding, en het is niet wiskunde: de verificatiepoort wordt standaard.
Verwacht dat binnen zes maanden de grote IDE's en AI-codeertools een "verifieer je output"-stap inbouwen die vergelijkbaar is met wat Astra doet voor wiskunde. Niet formele bewijzen van code — maar geautomatiseerde tests die de agent zelf schrijft en draait voordat het "klaar" zegt. Dat patroon is waar Astra op wijst: genereer, verifieer, pas aan, herhaal.
Je kunt dat vandaag al handmatig doen — en als je mijn eerdere posts hebt gelezen, doe je het waarschijnlijk al. Astra maakt het duidelijk dat het model het op termijn zelf kan.
Als je hulp nodig hebt bij het inbouwen van verificatielussen in je agentworkflows — fiverr.com/s/EgxYmWD.
Veelgestelde Vragen
Wat is OpenAI Astra?
OpenAI Astra is een wiskundig redeneringsmodel dat tien eerder onopgeloste wiskundeproblemen oploste met formeel geverifieerde bewijzen in Lean 4. Het produceerde het eerste bewijs van een niet-sofische groep.
Heeft OpenAI Astra echt open wiskundeproblemen opgelost?
Ja — tien problemen, formeel geverifieerd in Lean 4 en onafhankelijk bevestigd door wiskundigen. Het niet-sofische groepresultaat is het meest significant.
Is de $2.000 compute-kostenclaim accuraat?
De $2.000 is de inferentiekost van de succesvolle runs. Het bevat niet de trainingskosten (geschatte miljoenen), mislukte pogingen, of menselijke begeleiding. Het is echt maar niet het hele plaatje.
Hoe verschilt dit van DeepMind's AlphaProof?
AlphaProof loste IMO-competitieproblemen op. Astra loste open onderzoeksproblemen op — een stap verder. Dezelfde brede aanpak (formele verificatie via Lean), maar toegepast op moeilijkere problemen.
Wat moet een ontwikkelaar hier daadwerkelijk mee doen?
Bouw verificatiestappen in je agentlussen — laat je agent zijn eigen output testen voordat het "klaar" zegt. Dat is het patroon dat Astra demonstreert, toegepast op code in plaats van wiskunde.
Laten We Samenwerken
- Fiverr: fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited: ramlit.com
- ColorPark: colorpark.io
- xCyberSecurity: xcybersecurity.io
