I've been waiting for this for a long time. OpenAI, at last, has released gpt-oss, his first family of models with open weights in many years: two versions, gpt-oss-120b y gpt-oss-20b, with Apache 2.0 license and designed to be implemented locally. Yesterday, August 5, 2025, They published the official website and download links. As someone who's quite keen on having the models running on my own machine, I was really looking forward to something like this: less reliance on external services, more control, and more room to experiment.
It's not "open-source" in the strictest sense (they haven't published the data or the complete training process), but it is open-weight, With a permissive license and downloadable files. For many uses, that's more than enough.
What exactly have they launched and why should I be interested?
OpenAI has published two models:
- gpt-oss-120b, designed for demanding tasks and requiring a GPU with approximately 80 GB of VRAM.
- gpt-oss-20b, much lighter than It works with about 16 GB of memory (ideal for desktop computers, powerful laptops or home servers).
Both admit context of up to 128k tokens, and they have a particularity that I find interesting: you can adjust the “reasoning effort” (low, medium o high) simply with a system instruction. This allows for modulating performance and cost according to usage.
OpenAI presents these models as an intermediate step: they do not replace hosted models (like GPT-4), but they do allow for options. private, reproducible and controlled, which can be integrated into any local flow. Just what I wanted.
Use cases I have in mind
- Local agents that can execute code, browse, or do function calling without cloud connection.
- Complex reasoning in technical or code problems, with stable latency.
- Personal projects where I don't want to rely on an external API or send data outside.
- Custom settings, without trade restrictions.
This is how I got it working (all from the terminal)
Quick option: Ollama
If I want to test the model already, The most direct route is with Ollama, which allows you to pull models with a single command:
# Small model (recommended for beginners)
ollama run gpt-oss:20b
# Large model (if you have a powerful GPU)
ollama run gpt-oss:120b
These models are already published and available in the Ollama interface. In the first message, you can indicate the level of reasoning, for example:
System: Reasoning: medium
Ready to work in seconds.
OpenAI-compatible local API: vLLM
If I want something more versatile, I pick up a local server compatible with the OpenAI API using vLLM. This allows me to connect from scripts, applications, or the terminal.
For example, in Docker:
docker run --gpus all \ -p 8000:8000 \
--ipc=host
vllm/vllm-openai:gptoss \ --model openai/gpt-oss-20b
And to interact via HTTP:
curl http://localhost:8000/v1/chat/completions \
-H ""Content-Type: application/json"" \ -d '{
"model": "openai/gpt-oss-20b",
"messages": [
{"role": "system", "content": "Reasoning: high"},
{"role": "user", "content": "Explain RAG to me in 5 lines."}
],
"max_tokens": 300
}'
Ideal if you want to set up a private API environment.
More flexible option: Transformers (Hugging Face)
If I prefer to write a script in Python, I can use Transformers directly with the model:
pip install -U transformers torch python - < ''PY''
from transformers import pipeline
pipe = pipeline(
""text-generation"",
model=""openai/gpt-oss-20b"", torch_dtype=""car"", device_map=""car""
) messages = [ {""role"": ""system"", ""content"": ""Reasoning: low""},
{""role"": ""user"", ""content"": ""Give me an example of a prompt to generate unit tests.""}
]
out = pipe(messages, max_new_tokens=256) print(out[0][""generated_text""][-1]) PY
This pipeline already supports the “harmony” chat format” that OpenAI recommends for gpt-oss.
Minimalist option: download the weights
If what I want is just the files to tinker with or integrate them in another way:
huggingface-cli download openai/gpt-oss-20b --local-dir gpt-oss-20b huggingface-cli download openai/gpt-oss-120b --local-dir gpt-oss-120b
All the details (formats, settings, quantization, etc.) are in the model cards officers.
Technical details that I'll keep to myself
- License: Apache 2.0 → allows commercial use and fine-tuning (fine-tuning).
- Quantization: The weights come in the format MXFP4, which allows for the use of less memory.
- Indicative requirements:
20b: works well with ~16 GB of VRAM.120b: requires ~80 GB (not for all computers, of course).
- Long context: up to 128k tokens → useful for long documents.
- Performance: OpenAI places it close to models like o3-mini or o4-mini, and well-suited for reasoning, programming, and agent tasks.
I had been using closed OpenAI models for years and, although they are excellent, I missed having something I could download, run, modify… and check. This, without being truly “open-source”, It feels like an important step. Now I can have my own GPT-style models running at home, ready for whatever comes up.