TL;DR — OpenAI released downloadable weights for a 120B mixture-of-experts model, priced at $0.037/M input and $0.17/M output tokens on hosted APIs with a 131,072-token context window. Probe results show fast, correct structured extraction and code generation, but noticeably slow multi-step reasoning. It's a strong pick for high-volume, cost-sensitive pipelines rather than latency-critical chat.
For most of the last decade, "OpenAI" and "open weights" didn't belong in the same sentence. That changed with gpt-oss-120b, a downloadable mixture-of-experts model that you can run on your own hardware or rent through hosted APIs for pennies. The plot twist isn't that the weights exist — it's what a near-zero price tag does to your build-vs-buy math once a frontier-adjacent lab is the one handing you the file.
What's actually in the box
The metadata is blunt about the shape of this thing: a 131,072-token context window (128K, enough for a mid-size codebase or a long contract in one pass) and hosted pricing of $0.037 per million prompt tokens and $0.17 per million completion tokens. That completion price is the number worth staring at — it's the kind of rate you'd expect from a small distilled model, not a 120-billion-parameter one. Mixture-of-experts architecture is exactly why that's possible: you pay compute for the parameters actually activated per token, not the full 120B every time.
I ran it through three probes — a coding task, a multi-step word problem, and a structured-extraction task — to see what that price actually buys you in practice.
What the probes showed
The merge_intervals coding probe came back in 11.7 seconds at 31.2 tokens/sec. The code itself is clean: it sorts by start, copies the first interval, and sets up the merge loop correctly — solid, idiomatic Python with a docstring that actually describes the contract. The transcript cuts off mid-loop at 364 completion tokens, so I can't personally verify the closing logic finished without a bug, but everything visible is textbook-correct and shows no sloppy shortcuts.
The structured-output probe is the standout: given a messy invoice string, it returned {"vendor": "Meridian Office Supply", "date": "03 March 2026", "total": 445.50} — valid JSON, correct field selection (it grabbed the amount due rather than the subtotal, which is the right call), in 3.5 seconds at 34.8 tokens/sec. No preamble, no markdown fencing, no chatty wrapper. That's exactly the behavior you want for a batch extraction job.
The reasoning probe is where the story gets more honest. The tank-filling problem was solved correctly — net rate 30 L/min for 20 minutes gives 600 L, leaving 1,800 L, which pump A alone at 90 L/min finishes in 20 more minutes. The arithmetic checks out and the final boxed answer is right. But it took 44.3 seconds and ran at only 9.3 tokens/sec, more than three times slower than the other two tasks. Correct, but slow — this model seems to spend a lot of generation budget "showing its work" step by step, which is good for auditability and bad for anything latency-sensitive.
Where this actually wins over a closed frontier model
This is the part that matters. A closed frontier API charges a premium partly for capability you may not need on every call. gpt-oss-120b's pricing and open weights change the calculus for a specific set of jobs:
High-volume structured extraction. Invoice parsing, log-to-JSON conversion, form field extraction — anything you're running thousands or millions of times a day. At $0.17/M completion tokens, a job that would run you real money on a premium closed API becomes close to free, and the probe shows the model returns clean JSON without extra scaffolding to strip out.
Long-document summarization and retrieval prep. The 131,072-token context window is enough to swallow a full contract, a design doc, or a stitched-together set of support tickets in one call, without a closed-model markup per token.
Batch code generation and refactoring passes. The coding probe's output quality suggests it's fine for scaffolding functions, writing tests, or generating boilerplate across a repo — work that's easy to review after the fact, so a bit of latency doesn't hurt.
Regulated or air-gapped environments. Because the weights are downloadable, teams that can't send customer data to a third-party API get an actual option here — self-host it, and the "vendor" is your own infrastructure team.
Cost-sensitive agent loops. If you're running an agent that calls a model dozens of times per task (planning, tool selection, summarizing tool output), the completion price difference compounds fast. This is the workload where per-token pricing actually shows up on an invoice.
Where it's the wrong tool: anything where a user is staring at a spinner. The reasoning probe's 44-second turnaround for a fairly simple word problem is not something you put in front of a live chat interface. If your product needs sub-second or few-second multi-step reasoning, either accept the latency, use a smaller sibling model for that step, or reserve a closed frontier model for the interactive path and route the bulk batch work here.
The honest caveat
"Open weights from OpenAI" is a genuinely new category, but don't confuse downloadable with free-to-self-host-cheaply. A 120B-parameter MoE model, even with sparse activation, is not something you casually run on a laptop — you're looking at serious GPU memory if you go the self-hosted route rather than the priced-per-token hosted API. The probe numbers here are for the hosted path; your mileage on your own hardware will depend entirely on what you're willing to provision. And the reasoning latency is a real constraint, not a benchmark artifact — plan your pipeline around it rather than hoping it goes away.
Bottom line
gpt-oss-120b isn't trying to be the smartest model in the room. It's trying to be the model you run a million times without checking your budget. The probes back that positioning up: fast, clean structured output and code generation, correct but slow multi-step reasoning. If your workload is volume, not vibes, that's a trade worth taking.
Tomorrow's episode moves out of the server rack and into the devices in your pocket — open-weight AI in consumer tech, and how much of it is already running closer to you than you think.
The numbers (measured, not quoted)
I ran three quick probes against gpt-oss-120b via a hosted API today before writing this. Small sample, one snapshot in time, routed hardware I don't control — treat these as a smell test, not a benchmark:
| Probe | Wall-clock | Output tokens | Tokens/sec (effective) | Result |
|---|---|---|---|---|
| Code | 11.7s | 364 | 31.2 | completed |
| Reasoning | 44.3s | 413 | 9.3 | completed |
| Structured output | 3.5s | 122 | 34.8 | completed |
Effective tokens/sec includes queueing and time-to-first-token — it's what you actually experience, not peak decode speed.
Model card: context window 131,072 tokens · hosted pricing $0.037/M input · $0.17/M output · weights: openai/gpt-oss-120b on Hugging Face
Credits — where it's due
- OpenAI — for training gpt-oss-120b and releasing the weights openly: openai/gpt-oss-120b. Open releases like this are why a series like this can exist at all.
- OpenRouter — the hosted API used for today's live probes and the pricing/context figures.
- The quantizers and runtime maintainers — the mostly-unpaid people who turn every open release into something that runs on real hardware within days.
Top comments (0)