OpenAI shipped two very different models. The 20B fits a normal 16GB card and flies; the 120B is an 80GB-class model you'll mostly rent. Here's the card I'd buy for each — VRAM-first, with current requirements cited.
People ask me for 'the best GPU for gpt-oss' as if it's one question, but OpenAI shipped two very different models under that name, and they land on opposite ends of the hardware world. The 20B is a genuine joy — it fits on a normal gaming card and runs fast. The 120B is a different conversation entirely: it's an 80GB-class model that most people will rent or offload rather than own. The reason both are friendlier than their parameter counts suggest is that OpenAI released them in MXFP4 (a native 4-bit format), so they're far smaller in memory than a typical FP16 model of the same size. So let me split this cleanly — here's the card I'd buy for the 20B, and the honest reality of the 120B.
~14GB
gpt-oss-20B
MXFP4 — fits a 16GB card
~225 tok/s
20B speed
on an RTX 4090 (reviewers)
~61GB
gpt-oss-120B
MXFP4 checkpoint → 80GB-class
5.13B / tok
120B active params
but ALL weights must fit
gpt-oss-20B runs happily on a normal 16GB card; the 120B is a different animal. Illustration generated with AI. · Generated with Higgsfield
gpt-oss-20B: a great fit for a normal card
This is the one most people actually want, and it's refreshingly undemanding. Because it ships in MXFP4, gpt-oss-20B loads in about 14GB rather than the ~40GB an FP16 20B would need. In practice that makes 16GB my hard floor — enough to hold the weights with a bit of room — while 24GB gives you comfortable context headroom. Speed is not the problem here: reviewers clock it around 225 tokens/sec on an RTX 4090, which is faster than you can read. On a 12GB card it still runs, but part of the model offloads to system RAM and the speed drops off a cliff — I wouldn't build around that. Watch the 128k context window, too: long contexts eat extra memory on top of the weights, so that's where a 24GB card earns its keep.
gpt-oss 20B vs 120B — what each one needs (MXFP4)
gpt-oss-20B
Memory to run
~14GB (16GB min)
GPU that fits
RX 9070 / 5070 Ti / used 3090
Reality
Fast on any 16GB+ card
gpt-oss-20B + long context
Memory to run
~16–20GB
GPU that fits
24GB card comfortable
Reality
Where 24GB pays off
gpt-oss-120B
Memory to run
~61GB floor → 80GB
GPU that fits
H100 80GB / RTX PRO 6000
Reality
Rent, or unified memory
Memory to run
GPU that fits
Reality
gpt-oss-20B
~14GB (16GB min)
RX 9070 / 5070 Ti / used 3090
Fast on any 16GB+ card
gpt-oss-20B + long context
~16–20GB
24GB card comfortable
Where 24GB pays off
gpt-oss-120B
~61GB floor → 80GB
H100 80GB / RTX PRO 6000
Rent, or unified memory
gpt-oss-120B: the 80GB problem
Here's where the mixture-of-experts design trips people up. gpt-oss-120B has 116.8B parameters but only activates ~5.13B per token — and I keep having to tell people that the active number does not size your hardware. Every expert weight has to sit in memory even if only a few fire per token, so you plan for the whole thing. OpenAI says the ~60.8GiB MXFP4 checkpoint can run on a single 80GB GPU, and the roughly-60GB figure is a constrained floor, not comfortable headroom. Translation: this is an 80GB-class model. On the consumer side that means something like an RTX PRO 6000 Blackwell (96GB) — glorious, but priced like a car — or you split it across multiple cards, which adds real complexity. My honest answer for almost everyone: don't own it.
Memory footprint — gpt-oss 20B vs 120B (MXFP4)
gpt-oss-20B~14GB
fits a 16GB card
gpt-oss-120B (floor)~61GB
constrained MXFP4 floor
gpt-oss-120B (clean)80GB
OpenAI's single-GPU target
Which GPU I'd actually buy
For the 20B — which is what most of you are really after — I'd buy a 16GB card and not overthink it. On pure value my pick is a used RTX 3090 (24GB), which gives you both the 20B with full context headroom and room to grow; the used-GPU value case is here. If you want new, an RX 9070 or RTX 5070 Ti (both 16GB) is plenty. For the 120B, I would not buy a card at all unless you run it daily: rent an 80GB H100 by the hour (I compared the neocloud rental prices), or go the unified-memory route for a slower-but-owned option. And whatever you're eyeing, size it against your real target first in the cost-to-run tool and the wider best-GPU-for-local-AI pillar — the deeper 120B hardware breakdown lives in the gpt-oss-120B requirements guide.
Verdict
What I'd run gpt-oss on
For gpt-oss-20B: a 16GB card is the floor and a used RTX 3090 (24GB) is my value pick — it's fast on anything modern, so buy VRAM, not speed. For gpt-oss-120B: treat it as an 80GB-class model — rent an H100 by the hour unless you run it daily, or accept a slower unified-memory box if you must own it. The 20B is the one worth building a machine around; the 120B is the one worth renting.
Best for: Anyone choosing a GPU to run OpenAI's gpt-oss locally in 2026
Common questions
Can I run gpt-oss-120B on a consumer GPU?
Not on a normal one. It's an 80GB-class model (~61GB floor at MXFP4), so it needs something like an RTX PRO 6000 Blackwell (96GB), a multi-GPU split, unified memory (a 128GB Strix Halo box or big Mac), or a rented 80GB H100. A single 24GB or 32GB gaming card can't hold it cleanly.
What's the minimum GPU for gpt-oss-20B?
16GB of VRAM is my practical minimum — the model loads in ~14GB at its native MXFP4 precision. A 12GB card works but offloads part of the model to system RAM and slows down noticeably. 24GB gives comfortable headroom for the 128k context.
Why is gpt-oss smaller in memory than its parameter count suggests?
Because OpenAI released it in MXFP4, a native 4-bit format. That's why a 20B model fits in ~14GB instead of ~40GB, and a 120B in ~61GB instead of far more. It's the whole reason these are runnable locally at all.
Is the 120B's '5.13B active parameters' the number I should size hardware around?
No — that's a common trap. Mixture-of-experts models only activate a few experts per token, but every expert weight must still fit in memory. Plan for the full ~61GB checkpoint, not the 5.13B active figure.
Rent or buy for gpt-oss-120B?
Rent, unless you run it daily for years. An 80GB H100 by the hour beats owning a five-figure card that sits idle most of the day. If you use it constantly, owning eventually wins — do the crossover math for your hours.
MXFP4 is why gpt-oss fits at all — a 4-bit checkpoint instead of full-precision weights. Illustration generated with AI. · Generated with Higgsfield