GPT-6 Astra vs Nex N2.5 Pro: One Computer-Use Agent Bills by the Token

A computer-use agent is the one workload where per-token pricing stops being an abstraction. Take a single task — open a browser, find a record, fill a form, verify the result — and an agent that thinks between every action will run it in tens of thousands of tokens, then repeat it ten thousand times. GPT-6 Astra, O​penAI's flagship released September 3, 2026, charges $10.00 per million input tokens and $50.00 per million output for that, with a doubled band above 272,000 tokens. Nex-N2.5 Pro, the 397-billion-parameter computer-use model Nex-AGI announced on September 8, 2026, was built for the same class of task and is published under Apache-2.0, with serving instructions for one node of eight H100s. Both vendors report OSWorld-2 figures. Only one of them gives you a meter you can read before you start.

The benchmark row that actually overlaps

OSWorld-2 is the closest thing to a shared yardstick between these two, and it is worth seeing how little that shared row establishes. Nex-AGI's card lists Nex-N2.5 Pro at 56.4 on OSWorld-2, alongside Claude Opus 5 at 68.3 and Qwen3.8-Max at 46.7, which it cites from leaderboard and provider sources. O​penAI's launch material for GPT-6 Astra reports 72.6% on OSWorld 2.0 at roughly 40 minutes per task, which it describes as about 47% less time per task than GPT-5.6 Sol.

Those two numbers cannot be placed in the same column. They were produced by different labs, on different harnesses, at different dates, with different action budgets — and Nex-AGI states plainly that its computer-use and browser-use evaluations went through its own NexCUA harness, which it says it will open-source but has not. So the honest reading of the pair is directional and narrow: O​penAI's figure is the higher one, both are vendor-reported, and neither has been reproduced. What the row does establish is that both companies consider OSWorld-2 the benchmark that matters for this class of model, which tells you what to watch for an independent run.

The rest of Nex-AGI's card is a single-vendor table with the same caveat attached to every line:

• Computer use, vendor-reported — OSWorld-2 56.4, OSWorld-Verified 82.2, OSWorld-G 87.4, WebArena-Verified 67.6, WebTest 52.8, Vision2Web 68.2

• Coding and text, vendor-reported — Terminal-Bench 2.1 at 82.7, SWE-Bench Pro 61.2, BrowseComp 89.7, AutomationBench v1.0.6 at 44.2

• GPT-6 Astra's independent record — 53 on the Artificial Analysis Intelligence Index, 44.6 output tokens per second, $3.26 per completed index task, seventh of 216 on intelligence and 168th of 185 on speed

• GPT-6 Astra's vendor record — 98% FrontierMath Tier 4, 99.9% ARC-AGI-3 (62.7% under ARC Prize's standard harness, 99.9% under a provider adapter), 100% ExploitBench, 57.9% Terminal-Bench 4.0

Read those four lines together and the asymmetry is clear. Astra has an independent scoreboard and a vendor table that disagree with each other, which at least gives you something to weigh. Nex-N2.5 Pro has only the vendor table — there is no Artificial Analysis entry for it, and no page for any Nex model on that board — so every figure above carries Nex-AGI's authority and nothing else.

What the second number on the card is: the weights landed

The Nex-N2.5 Pro repository on Hugging Face was created on September 8, 2026, and when the family was announced the model card carried a coming-soon notice for the weights. That gap has closed. The repository now holds 122 safetensors shards totalling roughly 407 GB, published under Apache-2.0, and the card documents the serving recipe in enough detail to run it without reverse-engineering anything.

That recipe is worth reading before you price the comparison, because it is the argument for the model as much as any benchmark row. Nex-N2.5 Pro is a sparse mixture of experts: 397 billion parameters total with roughly 17 billion active per token. The documented deployment is a single node of eight H100s running a customised SGLang build — nexagi/sglang:v0.5.18-nex-patch — with tensor parallelism across all eight, the Q​wen3 reasoning parser and the Q​wen3-coder tool-call parser enabled, a 262,144-token context length, and recommended sampling at temperature 0.7, top_p 0.95, top_k 40. Eight H100s is a substantial but routine footprint. Because only 17 billion parameters fire per token, the compute per action stays small even though the weight footprint is large — which is the entire reason a 397B model is deployable by anyone other than a hyperscaler.

The 262,144-token context is the specification that decides most agent designs. Astra's window is 1,050,000 tokens with a 128,000-token output ceiling, and its own service bands make the long end expensive: above 272,000 input tokens the whole request is repriced at $20.00 input and $75.00 output, with cache reads at $2.00 and cache writes at $25.00. Nex-N2.5 Pro's 262,144-token serving length sits just under that line, which is either a coincidence or a specification written by someone who reads other vendors' pricing pages. Either way, the practical consequence is that an agent loop holding a long session history on Nex-N2.5 Pro never crosses the tier boundary that roughly doubles Astra's input cost.

Where the money goes over ten thousand runs

Per-token price is the wrong unit for this workload, and it is worth being concrete about why. A browser agent that completes a task in a hundred actions sends a hundred requests, each carrying the accumulated session state. Even with prompt caching doing real work, the input side grows with the square of the action count while the output side grows with it linearly. That is the shape that makes a rate card into a budget line.

The two models answer that shape differently, and the difference is not primarily about the numbers:

• Cost structure — GPT-6 Astra metered at $10.00 in / $1.00 cached / $12.50 cache writes / $50.00 out per 1M, doubling above 272K tokens vs Nex-N2.5 Pro metered or self-hosted, with no published list rate from Nex-AGI for the Pro tier

• Capital requirement — GPT-6 Astra none, it is an API vs Nex-N2.5 Pro a single node of eight H100s, or a hosted endpoint whose commercial terms are the vendor's to set

• Context at serving time — GPT-6 Astra 922,000 input tokens, 128,000 output vs Nex-N2.5 Pro 262,144 tokens as documented in the launch configuration

• Reasoning control — GPT-6 Astra reasoning.effort from low to max vs Nex-N2.5 Pro reasoning_effort at none, medium (adaptive, the default) or high

• Input — GPT-6 Astra text, image and file per router listings, text and image per O​penAI's own page vs Nex-N2.5 Pro text and image, with vision treated as the agent's perception channel rather than a second modality

• Weights — GPT-6 Astra closed vs Nex-N2.5 Pro Apache-2.0, 122 shards, roughly 407 GB

That last row is the one that changes the arithmetic rather than the price. If you own the eight H100s and they are not otherwise busy, the marginal cost of the next agent run approaches electricity, and no per-token competitor reaches that number at any volume. If you do not own them, the capital line is the comparison, and a metered API starts to look cheap in exactly the way that a rental car looks cheap next to a car payment — until you drive it every day for three years.

The honest version of the buy-versus-build question here is utilisation. An agent workload that runs continuously makes the node look like a bargain; one that spikes during business hours and idles overnight makes the API's flexibility worth its premium. Neither vendor's card will tell you which you have, and no benchmark row substitutes for the number your own traffic produces.

One thing the Nex-N2.5 Pro card will not tell you is its price. Nex-AGI publishes no per-token list rate for the Pro tier; the model reached users first through hosted endpoints linked from its own card, and the commercial terms are the vendor's to set rather than something an outside page should estimate. This article does not print one.

What each one is actually built to do

The clearest difference between these two is not capability, it is the loop they were designed around. Nex-AGI's framing for the N2.5 family is that vision is not merely an input modality but the interface through which the agent perceives its environment, verifies the outcome of an action, and decides what to do next. Nex-N2.5 Pro is post-trained from Qwen3.5 lineage specifically for that perception-and-check loop, in browser and desktop sessions, with self-correction from the visual result. Its reasoning control reflects the same design: the default mode is adaptive, letting the model decide how much to think before each action, with a non-thinking mode available for steps that plainly do not need it. For an agent making hundreds of sequential decisions, per-step thinking control is a cost lever, not a quality dial, and the default setting is the one that matters.

GPT-6 Astra's positioning is broader and its computer-use story comes with a price structure that assumes long runs. O​penAI sells it for long-horizon, end-to-end professional work — taking a task from an instruction to a finished artefact using a computer the way a person does — and the 1,050,000-token window is the specification that makes those runs possible without summarisation. That is a genuine advantage for the class of task where the agent must still find a requirement it was given hours ago; it is also the reason the 272,000-token band exists, and anyone running Astra as an agent should read that band as the price of the feature rather than as a penalty.

Two operational facts about Astra belong in any evaluation of it as an agent platform, because both affect a production loop. Its measured throughput is 44.6 output tokens per second on Artificial Analysis's run, which is slow enough to matter when each of a hundred actions waits for a response. And Astra is the first O​penAI model to cross the company's Critical cybersecurity capability threshold, which means that as shipped it refuses advanced cyber tasks and that safeguard machinery sits in the request path — in ChatGPT and Codex a user may be asked to review an action, while on the API the task simply stops. For a defensive-security agent that is a real constraint; for an ordinary business-process agent it is mostly invisible.

Running both, and what a router does about it

Nex-N2.5 Pro is not on OrcaRouter and this page is not claiming it is — it is an Apache-2.0 checkpoint from a newer lab, and your route to it is Nex-AGI's own hosted services, a third-party platform, or the eight-H100 deployment its card documents. GPT-6 Astra is on our catalogue as openai/gpt-6-astra, at OpenAI's list rates passed through with 0% markup of ours, so a change to any of its four meters lands on your existing key the same day it is published.

That split is what makes a mixed fleet practical rather than theoretical. A team that wants to find out whether a self-hosted computer-use agent handles its workload can put the metered model behind the same OpenAI-compatible endpoint it already calls, point a slice of traffic at the checkpoint, and compare finished tasks per dollar rather than tokens per call — which is the only unit that answers the question. Automatic failover covers the deployment's bad days without anyone writing a second integration, and it covers the API's bad days too. The comparison this page has been making is a comparison of cost structures, and a cost structure is something you test on your traffic rather than read off a card.

Which one to run

Choose Nex-N2.5 Pro if computer and browser operation is the product rather than a feature of it, if you already operate GPU capacity, or if Apache-2.0 is decisive because the data the agent touches cannot leave your infrastructure. Budget the node before you budget anything else, and run your own evaluation of the OSWorld-2 figure before you depend on it — the harness that produced it is not public yet, and until it is, 56.4 is a claim rather than a result.

Choose GPT-6 Astra if the work needs the top of a very long context, if you want an independent scoreboard to weigh against a vendor table, or if you would rather not run GPUs at all. It costs $10.00 and $50.00 per million tokens and $3.26 per completed index task — the most expensive option in this comparison and the one with the least operational overhead. Do not put a short-prompt, high-volume agent on it; at those request sizes you are paying a flagship rate for a workload a cheaper model completes, and the 272,000-token band that justifies the rate card is one you will never use.

The summary worth keeping is that these two are priced against different constraints. Nex-N2.5 Pro's cost is a node, and its economics improve the more you use it. GPT-6 Astra's cost is a meter, and its economics are flat no matter how much you use it. For a computer-use agent that runs continuously, that difference compounds faster than any benchmark gap between them.

A release is also the moment to check what has gone wrong before: the documented AI incidents and agent failures around models in this class are collected in the OrcaRouter AI Incident Archive , where each entry carries its own sources, severity, confidence grade and disputed flag.