Nemotron 3.5 Super vs GPT-6 Astra: wat een ingescande pagina bij elk kost

OpenAI GPT-6 Astra factureert een gescand document per token. NVIDIA Nemotron 3.5 Super factureert het per GPU-seconde. Die ene zin vormt het grootste deel van deze vergelijking, en het is niet de zin die een van beide leveranciers in een kop zou zetten. Het NVIDIA-model — 120 miljard totale parameters met 12 miljard actieve per token, een C-RADIO-vision-encoder op een hybride Mamba-2- en Transformer-mixture-of-experts, op 15 oktober 2026 door NVIDIA aangekondigd onder de naam NVIDIA Nemotron 3.5 Super VL en op Ollama uitgebracht als code>nemotron-3.5-super/code> — kwam ter wereld met zijn gewichten al drie dagen oud op Hugging Face, geüpload op 12 oktober. Astra is het vlaggenschip van OpenAI: 1.050.000 tokens context, 128.000 tokens maximale uitvoer, tekst-, afbeeldings- en bestandsinvoer, altijd actieve redenering, en een listprijs van $10 per miljoen invoertokens en $50 per miljoen uitvoertokens.

Die twee prijspunten liggen een factor tien uit elkaar bij input en een factor vijfentwintig bij output, wat de interessante vraag uitzonderlijk scherp maakt. Bij welk volume verslaat een open checkpoint met vaste kosten een $10/$50-meter voor documentwerk — en verandert het antwoord wanneer het document een pagina pixels is in plaats van een pagina tekst?

Ze concurreren niet om hetzelfde verzoek

Het eerste dat duidelijk moet zijn, is dat deze twee modellen qua gemeten capaciteiten niet dicht bij elkaar liggen, en geen van beide leveranciers beweert iets anders.

• Index van derden — Astra staat op ongeveer 54,7 op het paneel dat deze modellen beoordeelt, met een Coding Index van 76,9 en een Agentic Index van 51,6, allemaal vastgelegd in Astra's eigen catalogusvermelding · het NVIDIA-checkpoint staat op ongeveer 26. Dat is een verschil van ongeveer achtentwintig punten en het wordt door geen van beide leveranciers gemeten.

• Context — 1.050.000 tokens voor Astra met een uitvoerlimiet van 128.000 tokens · 1.000.000 voor het NVIDIA-checkpoint zonder enige gepubliceerde uitvoerlimiet, en de eigen waarschuwing van de kaart dat geheugen- en runtime-instellingen het bruikbare aantal bepalen.

• Reasoning-oppervlak — Astra voert continu actieve reasoning uit met configureerbare inspanning van laag tot en met max, retourneert volledige reasoning-traces via de Responses API en ondersteunt gestructureerde outputs, seeds en webzoekopdracht als tool · het NVIDIA-checkpoint heeft een aan/uit-denkmodus die via de chat-template wordt omgeschakeld en een gepubliceerde benchmarktabel, maar geen enkele vorm van een gehost oppervlak.

• Invoermodaliteit — tekst, afbeeldingen en bestanden voor Astra · tekst, afbeeldingen en video voor het NVIDIA-checkpoint, met op elke gepubliceerde tag een vision-projector van 1,6 GiB zodat het afbeeldingspad altijd aanwezig is.

• Prijs — $10 in en $50 uit per miljoen tokens, met een tarief voor lange context boven de 272.000 prompttokens · geen prijs, omdat het model geen endpoint heeft.

• Wat je krijgt — een API-sleutel en een trace · vier H100's of twee GB200's van BF16, of één 96 GB-kaart voor de standaard 4-bit-tag van 82,3 GiB, onder OpenMDW-1.1 met commercieel gebruik toegestaan.

Lees die lijst en de conclusie is duidelijk: als het werk frontier reasoning vereist, is Astra het model en is de vergelijking voorbij. Wat deze pagina de moeite waard maakt, is het geval waarin het werk geen frontier reasoning nodig heeft, want dat is waar een checkpoint met 120 miljard parameters en een vision-encoder economisch zin begint te krijgen — en het is een groter deel van echte documentpipelines dan men graag toegeeft.

De rekensom van paginakosten, uitgevoerd met echte cijfers

Neem een concrete taak: een corpus van gescande facturen, 200 pagina's per dag, waarbij elke pagina op een resolutie wordt weergegeven die hoog genoeg is om een handgeschreven referentienummer te lezen. Noem het 1.500 imagetokens per pagina nadat de encoder zijn werk heeft gedaan, plus een prompt van 300 tokens en een antwoord van 150 tokens. Dat is ongeveer 1.950 tokens in en 150 uit per pagina, of 390.000 input- en 30.000 outputtokens per dag voor het hele corpus.

Bij het gepubliceerde tarief van Astra is dat $3,90 aan input en $1,50 aan output — ongeveer $5,40 per dag, of zo'n $160 per maand voor een taak die één enkele GPU in één nacht kan uitvoeren. Verhoog de resolutie, voeg een pagina toe die de long-context-tier boven de 272.000 prompttokens activeert, of draai het corpus twee keer omdat de eerste pass fout was, en het getal beweegt maar in één richting. Dit is de vorm van het probleem: bij $10 en $50 heeft een per-pagina-workflow een per-pagina-rekening, en de rekening schaalt mee met precies het ding dat groeit — het aantal pagina's.

Op de NVIDIA-checkpoint kost dezelfde taak de fractie van een GPU-uur die 230.000 tokens verbruiken, wat bij 200 pagina's per dag in het niet valt bij de elektriciteitskosten. De rekening is de kaart, en de kaart is dezelfde of je nu 200 pagina's of 20.000 pagina's verwerkt.

Drie kanttekeningen voordat iemand halsoverkop hardware gaat kopen. De eerste is dat dit bij een laag volume niet meer opgaat — een 96GB-kaart en de stroom om die te laten draaien kosten per maand meer dan de meeste teams aan tokens uitgeven, en bij 200 pagina's per dag zou je waarschijnlijk verlies draaien. De tweede is dat de NVIDIA-kwantisatie die de meeste mensen daadwerkelijk zullen draaien, q4_K_M, nergens een gepubliceerde evaluatie heeft; elk cijfer op NVIDIA's kaart is BF16 of NVFP4, dus de nauwkeurigheid van de versie die je inzet is onbekend. De derde is dat de output van Astra meetbaar beter is, en op een corpus waar een verkeerd gelezen referentienummer een reële kostenpost is, kan betere nauwkeurigheid zwaarder wegen dan een prijsverschil van welke omvang dan ook.

Waar Astra niet alleen beter is, maar structureel beter

Het zou oneerlijk zijn om Astra neer te zetten als een duur alternatief voor een goedkopere optie. Op meerdere vlakken is het een andere klasse van product, en het verschil gaat niet over scores.

Astra retourneert volledige redeneertraces via de Responses API. Voor een pijplijn die een beslissing moet rechtvaardigen — een claimbeoordeling, een compliance-analyse, een medische coderingsronde — is een auditeerbare trace geen functie, maar een vereiste. De NVIDIA-checkpoint heeft een denkmodus die je in de chat-template aan en uit kunt zetten en helemaal geen gehoste trace-interface, wat betekent dat je de auditlaag zelf moet bouwen.

Astra ondersteunt gestructureerde outputs met een schema en een seed. In een pijplijn voor documentextractie waarin de uitvoer moet voldoen aan een recordindeling, is een model dat aan een schema kan worden gebonden goedkoper te integreren dan een model waarbij je valideert en opnieuw probeert, en de kosten van opnieuw proberen zijn onzichtbaar totdat ze dat niet meer zijn.

En Astra's tool-oppervlak is een first-partyproduct: function calling, response_format, seed en webzoeken als tool. Het deploymentrecept van de NVIDIA-checkpoint hergebruikt een tool-call-parser die het niet zelf heeft geschreven — het eigen vLLM-recept van de leverancier noemt code>qwen3_coder/code> als de tool-call-parser en code>nemotron_v3/code> als de reasoning-parser. Dat is een verstandige technische keuze, en het betekent ook dat het tool-calling-oppervlak geleend is in plaats van ontworpen voor dit model, en getest moet worden voordat men het vertrouwt.

Het vLLM-recept vertelt je ook wat de leverancier verwacht dat een replica aankan: tensorparallellisme van 4, GPU-geheugengebruik van 0,85, maximaal 32 gelijktijdige sequenties, één afbeelding en één video per prompt, videopruning op 0,5, en speculatieve decoding via de ingebouwde MTP-head met drie speculatieve tokens. Tweeëndertig gelijktijdige sequenties is het plafond op een node met vier GPU's. Astra's plafond is een snelheidslimiet.

De valkuil in de NVIDIA-standaard, en waarom die het eerst op documenten opduikt

Dit is het detail dat bepaalt of het eerste experiment slaagt, en het is alleen zichtbaar als je het runtime-register leest in plaats van het bericht van de leverancier.

De kaart specificeert twee samplingconfiguraties: temperatuur 1.0 met top_p 0.95 voor tekstwerk, en temperatuur 0.6 met top_p 0.95 voor vision. De meegeleverde standaard in het Ollama-manifest is het tekstpaar — code>{"temperature": 1.0, "top_p": 0.95}/code> met code>draft_num_predict: 3/code>. Dus de configuratie waaronder de meeste mensen dit visionmodel zullen tegenkomen, is afgestemd op de helft ervan die geen vision is. Als het eerste dat je ermee doet, het op een gescande factuur richten is en het resultaat onsamenhangend of gehallucineerd is, dan zijn de samplinginstellingen het eerste dat je moet aanpassen — voordat je iets over het checkpoint concludeert.

Nog twee registrydetails die je moet weten voordat je uitrolt. Vier van de negen gepubliceerde tags — code>:latest/code>, code>:120b/code>, code>:120b-a12b/code> en code>:120b-a12b-q4_K_M/code> — verwijzen naar dezelfde q4_K_M-laag, dus de tag die vernoemd is naar het volledige aantal parameters, is niet het bestand dat je ontvangt. En de versiepoort wordt afgedwongen in plaats van geadviseerd: de config declareert code>requires: 0.40.5/code>, dus op een oudere runtime werkt de pull helemaal niet.

Vergelijk dat met de faalmodus aan de andere kant van deze vergelijking, namelijk een gewijzigd eindpunt. Astra is een gehoste service; het gedrag kan worden herzien. Geen van beide risico's is een reden om het model te vermijden. Het zijn verschillende risico's en ze vragen om verschillende mitigerende maatregelen — een configuratiewijziging aan de ene kant, een fallbackroute aan de andere kant.

Het routeringsantwoord, dat voor beide hetzelfde is

Astra staat op onze key. OrcaRouter routeert het tegen de lijstprijs van de provider, doorgegeven zonder markup per token — $10 en $50 per miljoen tokens, waarbij de long-contextlaag exact zo geprijsd is als OpenAI die prijst, dezelfde dag nog live aan onze kant in plaats van bij je volgende verlenging. Als de vraag is of Astra je documentwerklast aankan, dan is dat één key en geen inkooptraject, en het antwoord kost een paar dollar aan tokens.

De NVIDIA-checkpoint staat niet op onze sleutel. We routeren iets meer dan tweehonderd modellen en daar zit geen NVIDIA Nemotron-vermelding tussen, dus dit artikel is geen bewering dat je hem hier kunt aanroepen. Als je die checkpoint nodig hebt, zijn de eigen build- en distributiekanalen van NVIDIA en de lokale pull jouw route.

Waar het platform in deze beslissing echt voor dient, is het bepalen van de volgorde. Draai het corpus eerst tegen Astra en meet twee dingen: de kosten per pagina en het foutpercentage per pagina. Die twee getallen samen bepalen alles. Als het foutpercentage laag is en het volume laag, blijf dan voor altijd op de meter — je kunt het met hardware nooit verslaan. Als het foutpercentage laag is en het volume hoog, heb je nu een verdedigbaar argument om de commoditypagina's naar een kaart die je zelf bezit te verplaatsen, terwijl je de moeilijke pagina's op de meter houdt. Als het foutpercentage hoog is, helpt geen enkel prijsvoordeel aan de NVIDIA-kant, want de rekensom van een verkeerd gelezen factuur gaat niet over tokens.

En welke weg je ook kiest, zet het nieuwe model achter een fallback. Een checkpoint waarvan de gewichten vier dagen oud zijn, heeft vier dagen operationele geschiedenis, en de goedkoopste verzekering daartegen is een tweede model in dezelfde call. Astra is een redelijke keuze om achter een vier dagen oud open model te hebben; het is ook het model waarvan de meeste lezers van deze pagina zullen concluderen dat ze het niet hoeven te vervangen.