gpt-oss-120b-GGUF

gpt-oss-120b-GGUF

Runs OpenAI's open-weight gpt-oss-120b, a 117B model with 5.1B active parameters, from GGUF files by Unsloth that carry its fixes. Built for reasoning, agent tasks and developer use.

Made by unsloth on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This repository holds GGUF versions of gpt-oss-120b, the larger open-weight model in OpenAI's gpt-oss series. It has 117B parameters, with 5.1B active at a time. Unsloth made the files and says every GGUF carries its fixes. The F16 file keeps the model's original precision.

Who it suits: Developers who want a strong open reasoning model they can run and customize themselves. The weights are estimated at about 58.4 GB at 4-bit, so this suits well-equipped machines.

Industry | Who uses it | How they use it | Example
Software | Developers | Build agents that call functions and run code | Let the model choose a tool for a request
Research | AI researchers | Study reasoning with a visible chain of thought | Inspect how the model reaches an answer
Self-hosting | Teams with large hardware | Run a general-purpose model without a hosted API | Serve it inside their own network
Customization | ML engineers | Fine-tune the model for a specific use case | Adapt it to a company's own tasks

People with a small laptop can skip this size, because the smaller gpt-oss-20b is the one aimed at local use.

Where to use it:

• Tools that load GGUF files, with Unsloth's guide as the card's pointer
• A machine that can hold the weights, which the card says fit on a single H100 GPU in native form
• Windows, macOS or Linux with Python, for downloading the files

Use case | Who | What they get back
Reasoning tasks | Developers and researchers | Answers with an adjustable depth of reasoning
Agent work | Developers | Function calls, web browsing and Python code execution
Structured output | Developers | Answers that follow a set format

How to set it up:

• Python, for the Hugging Face hub tools
• A runner that loads GGUF files
• Disk space and memory for the file you choose, with the 4-bit weights estimated at about 58.4 GB

1. Install the Hugging Face hub tools with pip.
2. Download the files with the hf command.
3. Load a file in your runner, following Unsloth's guide for gpt-oss.

pip install -U huggingface_hub
hf download unsloth/gpt-oss-120b-GGUF

How to use it: The card shows no run command in the part given. The model was trained on OpenAI's harmony response format and works correctly only with that format. A chat template applies it for you. You can set the reasoning effort to low, medium or high, depending on how hard the task is and how much delay you accept.

Tool | What it does
Reasoning effort | Low, medium or high, to trade depth for speed
Function calling | Lets the model call functions you define
Web browsing | A native tool the model can use for browsing
Python execution | A native tool for running Python code
Structured outputs | Keeps answers in a set format

Example: A developer sets the reasoning effort to high and asks the model a hard question. The model thinks through it and returns an answer. The full chain of thought is available for debugging, but the card says it is not meant for end users.

For newcomers and experts: This is a big model, so begin with a small test on a machine that can hold it. Use the chat template so the harmony format is applied for you. Check the answer, then raise or lower the reasoning effort.

The model is a mixture-of-experts with 117B parameters and 5.1B active. OpenAI trained its MoE layer in native MXFP4 precision, which is why the 120b model fits on one H100 GPU. This repo's F16 file keeps the original precision, and the other files are smaller quantizations.

Format the chat in the harmony format
Choose a reasoning effort
The model reasons, then answers
A tool call, if any, comes back as text

Good to know:

• Format: The model works correctly only with the harmony response format.
• Reasoning: The chain of thought is fully visible and meant for debugging, not for showing to end users.
• Sizes: The 120b model has 117B parameters, and the smaller gpt-oss-20b has 21B with 3.6B active.
• License: Apache 2.0, with no copyleft limits or patent risk, as the card puts it.
• Cost to run: none named. You need hardware that can hold the weights, and no paid service appears in the source.
• Data it reaches: Files on your computer. The web browsing and code execution tools are native features of the model.
• Not for: Showing raw reasoning to end users, and running without the harmony format.

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 117B
• Weights: about 58.4 GB at 4-bit (estimate)
• Formats: GGUF
• Downloads in the last 30 days: 81,029
• Likes: 303
• License: apache-2.0
• Based on: openai/gpt-oss-120b
• Tags: transformers, gguf, gpt_oss, text-generation, openai, unsloth, mxfp4, conversational

Links

• Model: https://huggingface.co/unsloth/gpt-oss-120b-GGUF
• Files: https://huggingface.co/unsloth/gpt-oss-120b-GGUF/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download unsloth/gpt-oss-120b-GGUF

Then follow the usage in its model card. Nothing in this kit runs by itself.