gpt-oss-20b: A Reasoning Model That Runs in 16GB of Memory

The useful question about a small open model is not how it ranks against frontier systems. It is whether it is good enough for a specific job on hardware you already own. gpt-oss-20b is one of the few models where the honest answer is often yes, and one of the few where the vendor has also told you clearly where it is weak.

OpenAI released it alongside gpt-oss-120b on 5 August 2025, under Apache 2.0. The 120b model targets a single data-centre GPU. The 20b model targets a laptop, a workstation card or an edge box.

What fits in 16GB

According to OpenAI's model card, gpt-oss-20b has about 20.9B total parameters and about 3.6B active per token. It has 24 layers and 32 experts per MoE block, with the top four routed per token. Context is 131,072 tokens and the knowledge cutoff is June 2024.

The expert weights ship in MXFP4, a 4-bit format the model was post-trained in, and the checkpoint is 12.8 GiB. OpenAI states the model runs within 16GB of memory. That covers a 16GB consumer GPU, and it is also why Apple Silicon machines with enough unified memory are a common target; OpenAI's repository includes a Metal implementation, though it describes that one as not production-ready.

Sixteen gigabytes is the floor for loading the weights, not for serving well. Long prompts grow the KV cache, and concurrent requests multiply it. If you plan to use a large share of the 131K window or serve several users from one card, measure memory under that load before you commit. Models that fit on one GPU compares the realistic options at this size.

Strong reasoning, thin knowledge

OpenAI describes the 20b model as competitive with its larger sibling despite being roughly six times smaller, and reports that it performs slightly better than o1 on HealthBench. Those are vendor-run figures, but they point in a consistent direction: the model reasons better than its size suggests.

The same model card is unusually frank about the other side. Without browsing, gpt-oss-20b has a hallucination rate of 0.914 on SimpleQA, against 0.782 for gpt-oss-120b and 0.750 for o4-mini. On PersonQA it is 0.532, against 0.491 and 0.361. OpenAI attributes the gap partly to smaller models simply holding less world knowledge.

That number should shape how you deploy it. Asked a bare factual question of the hard, obscure kind those benchmarks use, the 20b model gets far more wrong than right, and it does so fluently. Given the facts in the prompt, through retrieval, a tool call or the document itself, it reasons over them well. Design for the second mode. RAG vs long context covers the options for getting the facts in front of it.

Jobs it suits

The model's strengths line up with a particular kind of workload: bounded tasks where the input carries the information and the output has a checkable shape.

• Extraction and classification over documents you supply, especially with structured outputs, which the model supports natively.
• Tool-using agents with short horizons, such as routing a support ticket or calling two or three internal APIs. Function calling, browsing and Python execution are built-in capabilities according to OpenAI.
• Offline and private work, where data cannot leave a laptop or a site without network access.
• A cheap first pass in front of a larger model, escalating only what it cannot handle.

Reasoning effort is adjustable between low, medium and high. On a small model that knob matters more than usual: low effort keeps latency down for simple classification, and high effort buys back some quality on multi-step problems at the cost of more generated tokens.

One deployment rule carries over from the larger model. Both gpt-oss models were trained on the harmony response format and OpenAI says they only work correctly with it. Use a serving stack that implements it, such as vLLM, Ollama, LM Studio or Transformers, rather than a hand-written chat template.

Fine-tuning and the safeguard variant

Because the weights are open and small, the 20b model is a realistic fine-tuning base for a team without a training cluster. OpenAI lists it as fine-tunable, and Apache 2.0 means you can ship the result commercially.

OpenAI did one such specialisation itself. gpt-oss-safeguard-20b is built on this model and tuned to classify content against a policy you write in the prompt. If your task is moderation or trust-and-safety labelling, start there rather than fine-tuning your own.

Running it hosted, and the cost picture

If you do not want to run it locally, gpt-oss-20b is listed on OpenRouter at $0.018 input and $0.09 output per million tokens at the time of writing. At those rates it is close to the cheapest reasoning-capable model you can call, and rates vary between the providers serving it.

There is also a :batch listing: the same model on an asynchronous endpoint where you submit work and collect results later. Batch endpoints are usually discounted, but compare the listed rates before switching rather than assuming, because on a model this cheap the difference can be small or absent.

When to step up to 120b

A short decision rule:

• Stay on 20b when the task is bounded, the facts arrive in the prompt, latency matters, or it has to run on local hardware.
• Move to 120b when a task needs several dependent reasoning steps, longer tool-use chains, or less hallucination on recall. The gpt-oss-120b guide covers the trade in memory and cost.
• Use both by routing: 20b first, escalate on a failed check. That is usually cheaper than running the larger model on everything.

Whichever you choose, test on twenty of your own tasks with the facts supplied as they will be in production, and score whether the output is usable without edits. A small model that passes that test is the right model, regardless of where it sits on a leaderboard.