OpenAI released gpt-oss-120b and gpt-oss-20b, its first open-weight language models since GPT-2, under the permissive Apache 2.0 license.
In this guide I break down the verified specs of both sizes, what the release changes for developers, and how to run the 20b model on your own hardware this week.
1. Context: What OpenAI Actually Released
OpenAI announced the gpt-oss family on August 5, 2025, after previewing the effort with the open-source community. These are text-only reasoning models built as Mixture-of-Experts Transformers, trained with reinforcement learning techniques informed by OpenAI’s most advanced internal systems, including o3. Both sizes ship natively quantized in MXFP4, which is exactly what makes their memory footprint practical.
gpt-oss-120b — the big one
117B total parameters with 5.1B active per token, 36 layers, 128 experts with top-4 routing. Fits on a single 80GB GPU for production-grade reasoning.
gpt-oss-20b — the local one
21B total parameters with 3.6B active per token, 24 layers, 32 experts with top-4 routing. Runs within 16GB of memory on consumer hardware.
Context window
128k tokens natively, with rotary position embeddings and grouped multi-query attention for efficient long-context inference.
License
Apache 2.0 plus a usage policy — commercial use, modification, and fine-tuning are all allowed without copyleft obligations.
Reasoning control
Configurable reasoning effort (low, medium, high) plus full chain-of-thought access, so you can debug what the model was thinking.
Why Apache 2.0 Matters
Unlike restrictive research licenses, Apache 2.0 lets you use, modify, and ship these weights inside commercial products without copyleft obligations or patent risk. That is the difference between a demo you can admire and infrastructure you can actually build on.
On benchmarks, OpenAI reports that gpt-oss-120b reaches near-parity with o4-mini on core reasoning evaluations and outperforms o3-mini, while gpt-oss-20b matches or exceeds o3-mini despite its size — with strong results on competition math, tool use, and health-related queries. Treat vendor numbers as a starting signal, not gospel: the real test is your own workload, which you can now run yourself for free.
2. Four Implications for Developers
An open-weight reasoning model of this class changes both the economics and the architecture of what you can ship. These are the four shifts I consider most important.
Prototype locally, deploy anywhere
The 20b model runs within 16GB of memory, so a decent consumer GPU or a high-end laptop can host a reasoning model offline. Iteration cycles drop from minutes to seconds, and your demos work on planes.
Experimentation gets dramatically cheaper
Every failed prompt, every eval sweep, and every fine-tuning experiment used to burn API credits. With the weights on your own disk, the marginal cost of one more run is basically electricity.
Agentic building blocks included
Native function calling, web-search and Python tool use, structured outputs, and full chain-of-thought access make these models ready for agent scaffolding without depending on proprietary APIs.
Fine-tuning freedom
Apache 2.0 plus released weights means you can specialize the 20b model on your domain and ship it inside your product. The 120b can even be fine-tuned on a single H100 node.
Do Not Skip the Fine Print
These are text-only models with no vision input, and all official evals were run on the MXFP4-quantized checkpoints — the exact artifacts you download. Reasoning models also spend tokens thinking, so budget output tokens accordingly and start on low effort for simple tasks.
3. What to Do This Week: Run It Locally
The fastest way to understand these models is to run one. Start with the 20b size — it is the consumer-hardware option — and scale up only if your task demands it.
Day 1–2: Chat with it via Ollama
Install Ollama, pull the weights (about 14GB on disk), and start chatting offline. This is the simplest possible setup and needs at least 16GB of VRAM or unified memory.
ollama pull gpt-oss:20b ollama run gpt-oss:20b
Day 3–4: Serve it as an API with vLLM
For server-style usage, vLLM exposes an OpenAI-compatible endpoint on localhost:8000 that your existing code can point to. Use the gpt-oss build pinned by the official guide.
uv pip install --pre vllm==0.10.1+gptoss --extra-index-url https://wheels.vllm.ai/gpt-oss/ --extra-index-url https://download.pytorch.org/whl/nightly/cu128 --index-strategy unsafe-best-match vllm serve openai/gpt-oss-20b
Day 5: Grab the raw weights from Hugging Face
If you want the reference implementation or plan to fine-tune, download the checkpoints directly from the official openai collection on the Hub.
huggingface-cli download openai/gpt-oss-20b --include "original/*" --local-dir gpt-oss-20b/
Weekend: Put it to work on one real task
Point an agent scaffold at your local endpoint, try low, medium, and high reasoning effort on the same prompt, and compare cost, latency, and quality against the API model you use today. One measured task beats ten opinion threads.
Hardware Rule of Thumb
The 20b model needs at least 16GB of VRAM or unified memory, and long contexts on a 16GB card get tight — cap the context length if you hit memory errors. The 120b wants around 60GB or more, so treat it as workstation or server territory.
4. Honest Limits Before You Commit
Open weights do not mean magic. Here is what I would verify before betting a production system on gpt-oss.
Text only, no vision
If your pipeline needs image input, you will still need a multimodal model alongside gpt-oss. Plan a two-model architecture from the start instead of discovering this mid-project.
The 120b hardware bar is real
Fitting into 80GB means a datacenter GPU or a serious multi-GPU workstation. Most independent developers should prototype on 20b and rent 120b inference by the hour.
MXFP4 is the only official flavor
The weights ship natively quantized to MXFP4 with no other official quantization, and community ports vary in quality. Stick to the official Ollama, vLLM, or Hugging Face artifacts.
Vendor benchmarks are a starting signal
Near o4-mini and matching o3-mini are OpenAI’s numbers on OpenAI’s evals. Re-run the evaluations that matter for your domain before promising anything to a client.
Golden Rule
Open-weight is not open-source training data: you get the weights, not the dataset or the full training recipe. Audit outputs, keep evals, and never ship a model you have not tested on your own distribution.
Conclusion
The gpt-oss release moves a serious reasoning model from behind an API key to inside your own infrastructure. That changes who can experiment, what latency is acceptable, and how much control you keep over your stack.
My recommendation is simple: spend one week with the 20b model on your own machine, measure it on one real task, and then decide whether the 120b — or your current API provider — earns a place in your architecture.
GPT-OSS: Cheat Sheet
The Models
- • 120b: 117B total, 5.1B active, 80GB GPU
- • 20b: 21B total, 3.6B active, 16GB
- • 128k context · Apache 2.0
Run It
- • ollama run gpt-oss:20b
- • vllm serve openai/gpt-oss-20b
- • HF: openai/gpt-oss-20b
Build
- • Tool use + structured outputs
- • Full CoT for debugging
- • Fine-tunable weights
