Nemotron 3.5 Super vs GPT-6 Astra: what a scanned page costs on each

OpenAI GPT-6 Astra bills a scanned document by the token. NVIDIA Nemotron 3.5 Super bills it by the GPU second. That single sentence is most of this comparison, and it is not the sentence either vendor would put in a headline. The NVIDIA model — 120 billion total parameters with 12 billion active per token, a C-RADIO vision encoder on a hybrid Mamba-2 and Transformer mixture of experts, announced by NVIDIA on 15 October 2026 under the name NVIDIA Nemotron 3.5 Super VL and shipped on Ollama as code>nemotron-3.5-super/code> — entered the world with its weights already three days old on Hugging Face, uploaded 12 October. Astra is OpenAI's flagship: 1,050,000 tokens of context, 128,000 tokens of maximum output, text, image and file input, always-on reasoning, and a list price of $10 per million input tokens and $50 per million output.

Those two price points are a factor of ten apart in input and twenty-five apart in output, which makes the interesting question unusually sharp. At what volume does a fixed-cost open checkpoint beat a $10/$50 meter for document work — and does the answer change when the document is a page of pixels rather than a page of text?

They are not competing for the same request

The first thing to get straight is that on measured capability these two models are not close, and neither vendor claims otherwise.

• Third-party index — Astra sits at roughly 54.7 on the panel that scores these models, with a Coding Index of 76.9 and an Agentic Index of 51.6, all recorded on Astra's own catalogue entry · the NVIDIA checkpoint is at roughly 26. That is a gap of about twenty-eight points and it is measured by neither vendor.

• Context — 1,050,000 tokens for Astra with a 128,000-token output cap · 1,000,000 for the NVIDIA checkpoint with no published output cap at all, and the card's own caveat that memory and runtime settings determine the usable figure.

• Reasoning surface — Astra runs always-on reasoning with configurable effort from low through max, returns full reasoning traces through the Responses API, and supports structured outputs, seeds and web search as a tool · the NVIDIA checkpoint has an on/off thinking mode switched through the chat template and a published benchmark table but no hosted surface of any kind.

• Input modality — text, images and files for Astra · text, images and video for the NVIDIA checkpoint, with a 1.6 GiB vision projector on every published tag so the image path is always present.

• Price — $10 in and $50 out per million tokens, with a long-context tier above 272,000 prompt tokens · no price, because the model has no endpoint.

• What you get — an API key and a trace · four H100s or two GB200s of BF16, or one 96 GB card for the 82.3 GiB default 4-bit tag, under OpenMDW-1.1 with commercial use permitted.

Read that list and the conclusion is obvious: if the work needs frontier reasoning, Astra is the model and the comparison is over. What makes this page worth reading is the case where the work does not need frontier reasoning, because that is where a 120-billion-parameter checkpoint with a vision encoder starts to make economic sense — and it is a larger share of real document pipelines than anyone likes to admit.

The page-cost arithmetic, done with real numbers

Take a concrete job: a corpus of scanned invoices, 200 pages a day, each page rendered at a resolution high enough to read a handwritten reference number. Call it 1,500 image tokens per page after the encoder does its work, plus a 300-token prompt and a 150-token answer. That is roughly 1,950 tokens in and 150 out per page, or 390,000 input and 30,000 output tokens a day across the corpus.

On Astra's published rate that is $3.90 of input and $1.50 of output — about $5.40 a day, or roughly $160 a month for a job that a single GPU can do overnight. Push the resolution up, add a page that trips the long-context tier above 272,000 prompt tokens, or run the corpus twice because the first pass was wrong, and the number moves in one direction. This is the shape of the problem: at $10 and $50, a per-page workflow has a per-page bill, and the bill scales with exactly the thing that grows — the number of pages.

On the NVIDIA checkpoint the same job costs whatever fraction of a GPU-hour 230,000 tokens consumes, which at 200 pages a day is a rounding error against the electricity. The bill is the card, and the card is the same whether you process 200 pages or 20,000.

Three caveats before anyone runs to buy hardware. The first is that this stops being true at low volume — a 96 GB card and the power to run it cost more per month than most teams spend on tokens, and at 200 pages a day you would likely lose. The second is that the NVIDIA quantisation most people will actually run, q4_K_M, has no published evaluation anywhere; every figure on NVIDIA's card is BF16 or NVFP4, so the accuracy of the version you deploy is unknown. The third is that Astra's output is measurably better, and on a corpus where a misread reference number is a real cost, better accuracy can overwhelm a price difference of any size.

Where Astra is not merely better but structurally better

It would be dishonest to frame Astra as an expensive alternative to a cheaper option. On several axes it is a different class of product, and the difference is not about scores.

Astra returns full reasoning traces through the Responses API. For a pipeline that has to justify a decision — a claim adjudication, a compliance read, a medical coding pass — an auditable trace is not a feature, it is the requirement. The NVIDIA checkpoint has a thinking mode you can switch on and off in the chat template and no hosted trace surface at all, which means building the audit layer yourself.

Astra supports structured outputs with a schema and a seed. On a document extraction pipeline where the output has to conform to a record layout, a model that can be constrained to a schema is cheaper to integrate than one where you validate and retry, and the retry cost is invisible until it is not.

And Astra's tool surface is a first-party product: function calling, response_format, seed and web search as a tool. The NVIDIA checkpoint's deployment recipe reuses a tool-call parser it did not write — the vendor's own vLLM recipe names code>qwen3_coder/code> as the tool-call parser and code>nemotron_v3/code> as the reasoning parser. That is a sensible engineering choice and it also means the tool-calling surface is borrowed rather than designed for this model, and will need testing before it is trusted.

The vLLM recipe also tells you what the vendor expects a replica to handle: tensor parallelism of 4, GPU memory utilisation 0.85, a maximum of 32 concurrent sequences, one image and one video per prompt, video pruning at 0.5, and speculative decoding through the built-in MTP head with three speculative tokens. Thirty-two concurrent sequences is the ceiling on a four-GPU node. Astra's ceiling is a rate limit.

The trap in the NVIDIA default, and why it shows up first on documents

This is the detail that will decide whether the first experiment succeeds, and it is only visible if you read the runtime registry rather than the vendor's post.

The card specifies two sampling configurations: temperature 1.0 with top_p 0.95 for text work, and temperature 0.6 with top_p 0.95 for vision. The shipped default in the Ollama manifest is the text pair — code>{"temperature": 1.0, "top_p": 0.95}/code> with code>draft_num_predict: 3/code>. So the configuration most people will meet this vision model under is tuned for the half of it that is not vision. If the first thing you do with it is point it at a scanned invoice and the result is loose or hallucinated, the sampling settings are the first thing to change — before you conclude anything about the checkpoint.

Two more registry details worth knowing before you deploy. Four of the nine published tags — code>:latest/code>, code>:120b/code>, code>:120b-a12b/code> and code>:120b-a12b-q4_K_M/code> — resolve to the same q4_K_M layer, so the tag named after the full parameter count is not the file you receive. And the version gate is enforced rather than advised: the config declares code>requires: 0.40.5/code>, so on an older runtime the pull does not work at all.

Compare that to the failure mode on the other side of this comparison, which is a changed endpoint. Astra is a hosted service; its behaviour can be revised. Neither risk is a reason to avoid the model. They are different risks and they call for different mitigations — a config change on one side, a fallback route on the other.

The routing answer, which is the same for both

Astra is on our key. OrcaRouter routes it at the provider's list price passed through with no per-token markup — $10 and $50 per million tokens, with the long-context tier priced exactly as OpenAI prices it, live on our side the same day rather than at your next renewal. If the question is whether Astra handles your document workload, that is one key and no procurement, and the answer costs a few dollars of tokens.

The NVIDIA checkpoint is not on our key. We route a little over two hundred models and there is no NVIDIA Nemotron entry among them, so this article is not a claim that you can call it here. If you need that checkpoint, NVIDIA's own build and distribution channels and the local pull are your route.

What the platform is genuinely for in this decision is sequencing. Run the corpus against Astra first and measure two things: the cost per page, and the error rate per page. Those two numbers together decide everything. If the error rate is low and the volume is low, stay on the meter forever — you will never beat it with hardware. If the error rate is low and the volume is high, you now have a defensible case for moving the commodity pages to a card you own while keeping the hard ones on the meter. If the error rate is high, no amount of price advantage on the NVIDIA side helps, because the arithmetic of a misread invoice is not about tokens.

And whichever way you go, route the new model behind a fallback. A checkpoint whose weights are four days old has four days of operational history, and the cheapest insurance against that is a second model on the same call. Astra is a reasonable thing to have behind a four-day-old open model; it is also the model most readers of this page will conclude they do not need to replace.