OpenAI open weights / deployment worksheet

gpt-oss 20B or 120B: what actually has to fit?

Q: How much memory does gpt-oss-20b need?

OpenAI says gpt-oss-20b can run on systems with as little as 16 GB of memory. Its official MXFP4 checkpoint is 12.8 GiB. This page's one-sequence 4K load profile is 14.29 GiB after KV cache and a 10 percent runtime reserve.

Q: How much GPU memory does gpt-oss-120b need?

OpenAI says gpt-oss-120b fits on one 80 GB GPU, such as an H100. Its official MXFP4 checkpoint is 60.8 GiB. This page's one-sequence 4K load profile is 67.19 GiB after KV cache and a 10 percent runtime reserve.

Q: Why are active parameters smaller than the memory requirement?

Mixture-of-experts routing activates only some experts for each token, reducing compute per token. The full checkpoint still contains all experts, so total parameters and the deployed artifact—not active parameters alone—set the weight-memory requirement.

Q: How does 128K context affect gpt-oss memory?

A conservative full-cache estimate adds about 6 GiB for gpt-oss-20b and 9 GiB for gpt-oss-120b at 131,072 tokens for one BF16 sequence. Actual runtimes can allocate differently because gpt-oss alternates dense and 128-token sliding attention layers.

Start with OpenAI's 12.8 GiB and 60.8 GiB checkpoints. Then add context, concurrency, runtime headroom, and usable GPU memory before buying hardware.

Open the editable 120B plan →

Quick answer / one sequence

16 GB is the small-model floor. 80 GB is the large-model floor.

OpenAI's official memory claims describe the MXFP4 release artifacts. The first two editable load profiles use the exact checkpoints, one 4K BF16 cache, a 10% runtime reserve, and 95% usable memory. The 128K profiles tighten the operational boundary with 20% reserve and 90% usable memory.

gpt-oss-20b · 4K · 1 × 16 GB 14.29 GiB 12.80 checkpoint + 0.19 KV + reserve → gpt-oss-120b · 4K · 1 × 80 GB 67.19 GiB 60.80 checkpoint + 0.28 KV + reserve → gpt-oss-20b · 128K · 1 × 24 GB 22.56 GiB 12.80 checkpoint + 6.00 KV + reserve; short → gpt-oss-120b · 128K · 2 × 80 GB 83.76 GiB 60.80 checkpoint + 9.00 KV + reserve →

Official artifact vs planning model

Checkpoint size is real. Headroom is workload-specific.

The official checkpoint includes higher-precision attention, embeddings, routing, metadata, and MXFP4 expert weights. The calculator is a transparent capacity model, not a replacement for loading the exact artifact in the intended runtime.

Swipe the matrix horizontally →

Model	Official architecture	Official checkpoint	OpenAI memory claim	4K planning target
gpt-oss-20b	24L · 20.91B total · 3.61B active	12.8 GiB	As little as 16 GB	14.29 GiB 1 × 16 GB
gpt-oss-120b	36L · 116.83B total · 5.13B active	60.8 GiB	1 × 80 GB GPU	67.19 GiB 1 × 80 GB

A GB vendor label and a GiB software measurement are different units. Drivers, kernels, graph capture, batching, and serving-engine allocations also consume memory. Treat “fits” as the start of benchmarking, not proof of acceptable speed.

Read the claim

Active is not resident.
MoE routing reduces compute per token; it does not erase the inactive experts from the checkpoint.

Context is not free.
A fully allocated 128K cache materially changes the capacity plan.

Capacity is not speed.
CPU offload can make a model load while still missing the latency target.

The 128K boundary

Advertised context and allocated cache are different decisions.

gpt-oss-20b
0.19 GiB at 4K → 6 GiB at 128K

gpt-oss-120b
0.28 GiB at 4K → 9 GiB at 128K

Concurrency repeats the cache.
Four fully allocated 128K sequences raise the conservative cache allowance to 24 GiB for 20B or 36 GiB for 120B.

These figures apply the standard full-cache formula across every layer. gpt-oss alternates dense attention with a 128-token sliding window, so an optimized runtime may allocate less. Measure the exact engine, batching policy, and cache format before reserving production capacity.

Primary-source inputs

Use OpenAI's artifact facts. Edit your workload assumptions.

Model sizes, checkpoint sizes, MXFP4 precision, active parameters, layers, attention heads, KV heads, head dimension, sliding window, and context length come from OpenAI's model card and official model configurations.

Open the GPU memory calculator → Open the KV-cache calculator → OpenAI gpt-oss announcement → OpenAI gpt-oss model architecture → Official gpt-oss-20b configuration → Official gpt-oss-120b configuration →

How much memory does gpt-oss-20b need?

OpenAI says the model can run on systems with as little as 16 GB. The official checkpoint is 12.8 GiB; this page's 4K load profile reaches 14.29 GiB after a full BF16 KV cache and a 10% runtime reserve.

How much GPU memory does gpt-oss-120b need?

OpenAI says the 120B model fits on one 80 GB GPU. The official checkpoint is 60.8 GiB; this page's 4K load profile reaches 67.19 GiB after cache and a 10% runtime reserve.

Why are active parameters smaller than the memory requirement?

Only 3.61B or 5.13B parameters are active for each token, but the deployed checkpoint contains 20.91B or 116.83B total parameters. Active parameters describe compute routing, not the whole resident weight artifact.

How does 128K context affect gpt-oss memory?

A conservative full BF16 cache estimate adds 6 GiB for 20B or 9 GiB for 120B for one 131,072-token sequence. Optimized runtimes may allocate less because half the layers use 128-token sliding attention.