gpt-oss-120b

Updated
03.07.2026
Tools
Thinking
Reasoning
Code

Run gpt-oss-120b, OpenAI's open 120B model, locally with Atomic Chat. Private, offline, with no API keys or usage limits. Download free.

huggingface-cli download openai/gpt-oss-120b
from transformers import AutoModel
model = AutoModel.from_pretrained("openai/gpt-oss-120b")

More models

NameSize / UsageContextInput
gpt-oss-20b
128KText

At a glance

  • License: Apache 2.0
  • Context length: 128K tokens
  • Languages: Multilingual
  • Minimum hardware: ~80 GB VRAM
  • Strengths: frontier open-weight reasoning and tool use

Overview

gpt-oss-120b is an open-weight language model from OpenAI, released under the Apache-2.0 license.

  • License: Apache 2.0
  • Context length: 128K tokens
  • Languages: Multilingual
  • Minimum hardware: ~80 GB VRAM
  • Strengths: frontier open-weight reasoning and tool use

Highlights

  • Permissive Apache 2.0 — no copyleft or patent risk, cleared for commercial deployment.
  • Configurable reasoning effort — set low, medium, or high to trade quality against latency.
  • Full chain-of-thought — complete access to the model's reasoning for debugging and trust.
  • Agentic capabilities — native function calling, web browsing, Python execution, and structured outputs.
  • MXFP4 quantization — MoE weights post-trained in MXFP4 so it runs on a single 80GB GPU (H100 / MI300X).

What it is good at

The capability tags on gpt-oss-120b are tools, thinking, reasoning, and code. Those map onto a few concrete jobs:

  • Agentic tool use — native function calling lets the model trigger searches, run code, or hit local tools and fold the results back into its answer.
  • Step-by-step reasoning — it exposes its chain of thought and supports adjustable reasoning depth, useful for math, planning, and multi-step problems. OpenAI reports it lands near o4-mini on core reasoning benchmarks.
  • Coding help — writing, explaining, and debugging code, including longer files that benefit from the 128K context.

Running it locally

gpt-oss-120b reports a 120.4B parameter count, and OpenAI ships the checkpoint in MXFP4 form at roughly 61 GiB. The clean target for local serving is a single 80 GB GPU such as an H100; setups with less VRAM can run it through CPU offloading at lower speed. The 128K context window means you can feed it large documents or long chat histories.

huggingface-cli download openai/gpt-oss-120b

From there you can serve it with Transformers or vLLM, or load it in Atomic Chat with one click and start chatting fully on-device.

License

gpt-oss-120b is released under Apache-2.0. You can use it commercially, modify it, fine-tune it, and ship products built on it, with no copyleft requirement and an explicit patent grant. Keeping the license notice is the main obligation.

Desktop
macOS
(M1 or better)
Download
Windows
(x64)
Download
Linux
(x86_64)
Download

Frequently asked questions

gpt-oss-120b is an open-weight language model from OpenAI built on a Mixture-of-Experts architecture, with about 120B total parameters and roughly 5B active per token. It is tuned for reasoning, tool use, and code, supports a 128K context window, and is released under the Apache-2.0 license so anyone can download and run it.

The practical target is a single GPU with 80 GB of VRAM, such as an NVIDIA H100, since OpenAI ships the model in MXFP4 form at around 61 GiB. You can run it on less VRAM by offloading layers to system RAM, but expect slower generation. Plan for ample system memory as well to handle long contexts.

Yes. The weights are published under the Apache-2.0 license, so the model is free to download, run, and even use commercially. Running it locally in Atomic Chat means there is no API key and no per-token cost.

Yes. Once the weights are downloaded to your machine, gpt-oss-120b runs entirely on-device with no internet connection required. Your prompts and data stay local, which is the point of running it in Atomic Chat instead of a hosted API.

It is strongest at reasoning, agentic tool use, and coding. OpenAI reports it reaches near-parity with o4-mini on core reasoning benchmarks, and its native function calling lets it drive external tools. The 128K context window also helps with long documents and extended code files.