Specialist · sources checked 30 October 2026
gpt-oss 20B VRAM and RAM requirements
Run this model with Ollama or LM Studio ↓
Check a model download using its actual file size.
New to local AI? Find your GPU memory and understand these settings.
gpt-oss 20B is an open-weight model from OpenAI, released in August 2025. It is not ChatGPT, it is not GPT-4o, and it does not become either of those because the name contains "gpt". OpenAI's Hugging Face card says the weights were trained for the harmony response format and should only be used with that format, because otherwise the model does not work correctly. The same card says the chain of thought is there for debugging and is not meant to be shown to end users. If a chat app prints the trace as the answer, that is the app, not the model card.
Most of the parameters sit idle on each token
The model card's parameter table lists 20.91 billion parameters in total and 3.61 billion active per token. Of the total, 19.12 billion are in the mixture-of-experts MLP, 0.64 billion are attention, and 1.16 billion are the embedding and unembedding. There are 24 layers. OpenAI describes alternating dense and locally banded sparse attention, grouped attention with a group size of 8, and a native context of 128,000 tokens. The group size of 8 matches the 8 KV heads this calculator uses. The head dimension in our architecture record is 64, which is why the cache grows more slowly than it does for a Llama or Qwen model with a head dimension of 128.
Active parameters are a speed story. They are not a memory story. Every expert has to be present even though only some of them run on a given token. Quantising the MoE weights, which OpenAI says are more than 90 percent of the parameter count, is how the model fits a small machine. The weights were post-trained in MXFP4 at 4.25 bits per parameter. The official checkpoint is 12.8 GiB. OpenAI says that lets the 20B model run on a system with as little as 16 GB of memory, and that the published evals used this same MXFP4 checkpoint rather than a mystery higher-precision copy.
The 16 GB claim and this calculator are measuring different things
Ollama's gpt-oss:20b tag, read on 30 October 2026, is a 14 GB download with a 128K context. Ollama says it keeps the native MXFP4 format rather than requantising. This catalogue uses that rounded 14 GB package as the weight allowance, which is why the table shows 14.00 GB and not the 12.8 GiB checkpoint. A backend that expands the experts out of MXFP4 can need much more memory than either number. There is no Q4_K_M or Q8 row here, because those are not the format OpenAI shipped.
| Precision | GPU VRAM target | System RAM target | Weight allowance |
|---|---|---|---|
| MXFP4 | 16.4 GiB | 24 GiB | 14.00 GB |
At 8,192 tokens the planning target is 16.4 GiB of GPU memory, 24 GiB of system RAM and 32 GiB of unified memory. The cache is only 0.4 GiB. At 1,024 tokens the GPU target is 16.0 GiB and the unified target is 24 GiB, while system RAM stays 24 GiB because of the loading allowance. OpenAI's "16 GB" is the compressed model running, close to our short-context GPU column and below our system-RAM column. A 16 GB laptop can match the checkpoint claim and still fall short of the 24 GiB RAM allowance this table uses, and a Mac has to clear the unified figure rather than the GPU figure. Treat 16 GB as OpenAI's floor for the MXFP4 weights, then add cache, runtime and the operating system before you buy the machine.
At 131,072 tokens the cache is 6.0 GiB and the GPU target is 22.6 GiB, with the unified target still 32 GiB because of the way this calculator rounds. Two caveats belong next to that row. First, our KV maths allocate a full FP16 cache for every layer. OpenAI's banded sparse attention may use less, and we do not model that saving, so the long-context number is conservative. Second, a high reasoning effort produces a long trace, and the trace is context. The sweep:
| Context | KV cache | GPU target | Mac unified target |
|---|---|---|---|
| 1,024 tokens | 0.05 GiB | 16.0 GiB | 24 GiB |
| 4,096 tokens | 0.19 GiB | 16.1 GiB | 32 GiB |
| 8,192 tokens | 0.38 GiB | 16.4 GiB | 32 GiB |
| 32,768 tokens | 1.50 GiB | 17.6 GiB | 32 GiB |
| 131,072 tokens | 6.00 GiB | 22.6 GiB | 32 GiB |
Reasoning effort moves the scores more than the parameter count does
OpenAI reports the 20B model at low, medium and high reasoning effort. The high column is the one that gets quoted. The low column is what you get when you ask for a faster answer. No-tools, high, then medium, then low:
- AIME 2024: 92.1, 80.0, 42.1. With tools at high effort: 96.0.
- AIME 2025: 91.7, 72.1, 37.1. With tools at high effort: 98.7.
- GPQA Diamond: 71.5, 66.0, 56.8.
- MMLU: 85.3, 84.0, 80.4.
- SWE-Bench Verified: 60.7, 53.2, 37.4.
- HLE, no tools: 10.9, 7.0, 4.2. Hard expert questions mostly fail even at high effort.
- Tau-Bench retail: 54.8, 47.3, 35.0. Tau-Bench airline: 38.0, 42.6, 32.0.
- HealthBench: 42.5 at high effort. Codeforces, no tools: 2,230 at high effort, 1,366 at low.
The airline row is the warning. High effort scores 38.0 and medium effort scores 42.6, so spending more thinking tokens is not automatically a better agent. HLE at 10.9 is the other warning: a model that looks exceptional on AIME can still miss most items in a harder expert set. MMLU barely moves from low to high, which is what you would expect if the extra tokens are helping multi-step problems rather than stored knowledge. HostingLinks has not rerun any of these. They are OpenAI's model-card figures, on OpenAI's harness, at MXFP4.
Apache 2.0, and the models it actually competes with
The licence is Apache 2.0. OpenAI's announcement contrasts that with copyleft and with patent risk, and says the weights can be fine-tuned. There is no "Built with Llama" notice and no 700 million user clause, because this is not a Llama file. Tool use, browsing and a Python tool are part of the model's advertised capability, and they depend on the harmony format and on a runtime that implements the tools. A bare chat window that only forwards text will not reproduce the "with tools" AIME numbers.
Qwen3 8B is the rival that fits a smaller GPU. Its Q4 package is about 5.2 GB and its 8,192 token planning target is under 8 GiB, against a 14 GB download and a 16.4 GiB target here. Qwen's thinking-mode AIME 2024 score of 76.0 is not comparable to OpenAI's 92.1 without saying the harnesses differ, and Qwen can turn thinking off. Choose Qwen3 8B when the machine is a 12 GB card or you need a direct answer. Choose gpt-oss 20B when you can meet the MXFP4 budget, you want Apache 2.0 weights from OpenAI, and the task benefits from the high-effort maths and software scores above.
Llama 3.1 8B is smaller again and sits under the Llama community licence, with a December 2023 cutoff and no reasoning-effort switch. gpt-oss 120B is the same family with 116.8 billion parameters, 5.13 billion active, a 60.8 GiB checkpoint and OpenAI's statement that it fits one 80 GB GPU. Ollama lists that tag at 65 GB. It is the step up when the 20B high-effort scores are not enough and you already have the 80 GB device. DeepSeek's 32B Qwen distill is the other local reasoning file people load, under MIT, with a 20 GB Q4 download that still misses a 24 GB card once the trace is included. gpt-oss 20B is the one of the three whose published floor is a 16 GB system, provided you keep MXFP4 packed and you do not confuse that floor with a 128K unified-memory plan.
Sources for gpt-oss 20B
- OpenAI, Introducing gpt-oss: 16 GB and 80 GB memory claims, Apache 2.0, 128K context
- OpenAI gpt-oss model card: parameter table, MXFP4, and the low, medium and high score table
- Hugging Face card: harmony format, chain-of-thought guidance, and the 16 GB MXFP4 note
- Ollama gpt-oss library: 20b at 14 GB and 120b at 65 GB, native MXFP4, read 30 October 2026
Run gpt-oss 20B locally
These steps use MXFP4 weights. Compare the MXFP4 row above with your available memory before downloading. The command does not choose Q8 or 16-bit weights, even if you explored those in the calculator.
View the exact Ollama download, file size and licence. Download tags checked 16 September 2026; publishers can update their files. File size is not the same as total running memory.
Option 1: Ollama
- Install and start Ollama from its official website. Check its supported GPUs.
- Open Terminal on Mac or Linux, or PowerShell on Windows. Run the command below. On first use, Ollama downloads the model before opening a chat.
ollama run gpt-oss:20bInside the Ollama chat, enter this setting before your first prompt to use the same 8,192-token context as the table above:
/set parameter num_ctx 8192Then try a short prompt such as “Explain how a solar panel works in three sentences.” In a second terminal, run ollama ps to inspect whether the model is on the GPU or partly on the CPU. CPU offload changes performance and falls outside this calculator's full-GPU assumptions. See Ollama's context and GPU-loading instructions.
Option 2: LM Studio
- Install LM Studio and open its model discovery screen.
- Search for gpt-oss 20B. Match the family, size and variant exactly. Check the publisher and model card; community conversions are not necessarily published by the original model creator.
- Choose a supported native MXFP4 gpt-oss download and compatible runtime. An expanded or differently quantized version may need substantially more memory.
- Load the model into a chat. Set the context length to 8,192 tokens and check the GPU offload settings. Try a short prompt before adding a long conversation or document.
LM Studio's official model download guide. Search results and available formats can change; we have verified the Ollama tags, not every community LM Studio conversion.
If the model will not load
Check your runtime version and GPU support, then close other memory-heavy apps. Try a shorter context or a smaller model and recalculate. Confirm that the downloaded format matches the estimate. Extra conversations, vision processing and runtime-specific allocations can increase memory use.
Find a smaller model for my computer · Check my memory and settings