Alpha
Contact
Implement · OpenAI gpt-oss

Can you run it?

Ownership levelSubstantialnone·limited·partial·substantial·fullAnalytical input B ยท 78.8/100

This page is a projection of the one entry record, the Reliability and Data control factors that Implement covers. The full verdict is set by all four factors together, floor-weighted so the weakest caps the whole.

Which domain expands which factor
  • AssessUse & modify + Transparency
  • ImplementData control + Reliability
  • UseReliability
  • SupportTransparency

Install & run

gpt-oss checkpoints are safetensors on the verified openai org, shipped natively in MXFP4. The usual paths all work. Always pin an exact revision.

# Hugging Face transformers.
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "openai/gpt-oss-20b"        # Or openai/gpt-oss-120b.
rev = "<pinned-commit-sha>"            # Pin the revision; do not float on main.
tok = AutoTokenizer.from_pretrained(model_id, revision=rev)
model = AutoModelForCausalLM.from_pretrained(model_id, revision=rev, torch_dtype="auto")
# Ollama (single command).
ollama run gpt-oss:20b

# vLLM (OpenAI-compatible server).
vllm serve openai/gpt-oss-120b --revision <sha>

# llama.cpp / LM Studio (MXFP4 or GGUF).
./llama-cli -m gpt-oss-20b-mxfp4.gguf -p "Hello"

Prefer the safetensors from the openai org and verify per-file checksums after download.

Hardware & VRAM requirements

Only a small fraction of parameters are active per token, so gpt-oss is cheaper to serve than its total-parameter counts suggest. gpt-oss-120b (~117B total, 5.1B active) fits on a single 80GB GPU (H100/MI300-class) in native MXFP4. gpt-oss-20b (~21B total, 3.6B active) runs in about 16GB, which is high-end consumer or edge hardware.

Budget extra headroom for the KV cache at long context lengths (both models support 128K).

Serving stacks

The checkpoints have day-0, first-class runtime support with native MXFP4 kernels, which is why Operational Readiness scores 5.

StackUse it for
vLLMHigh-throughput serving and OpenAI-compatible API
llama.cppCPU, edge, GGUF and MXFP4 inference
OllamaLocal single-command runs
transformersPrototyping and fine-tuning
MLXApple-silicon inference

Hosted endpoints are also available on major providers, so serving can move between self-hosted and managed without changing the client contract.

Safe-deployment controls & Deployment Ceiling

The model-specific gate rows from the safe-deployment playbook are below.

  • Supply chain: pin the exact openai revision hash and verify checksums. Prefer the canonical safetensors (no pickle load).
  • Prompt layer: render prompts with the harmony response format via openai/harmony, because the models are trained only for it, and never surface raw chain-of-thought to end users.
  • Model layer: the models are safety-tuned, but the tuning can be fine-tuned away on open weights. Set conservative decoding defaults.
  • Input/output layers: add input/output guardrails and your own guard classifier for any customer-facing path. The base release ships no guard model, and OpenAI's separate gpt-oss-safeguard classifier can fill that role. Add prompt-injection defences and treat retrieved and tool content as untrusted.
  • Compliance: archive OpenAI's training-content summary and copyright posture in the AI-BOM. The deployment depends on OpenAI for the training-content summary because the data is not published.

Deployment Ceiling: T2 (customer-facing, human-reviewed), conditional. With harmony-correct prompts, input/output guardrails, a guard classifier and no raw-CoT exposure, gpt-oss reaches customer-facing, human-reviewed use. Its strong native tool use makes it a capable agentic backbone. T3+ (bounded autonomous) additionally needs a deterministic action-policy engine, per-action human approval for irreversible operations, and external guard tooling beyond what the release provides. It is held at T2 because the base release ships no companion guard model.

Available quantizations

gpt-oss is natively quantized in MXFP4. The mixture-of-experts weights are released at 4-bit, which lets the 120b fit on one 80GB GPU and the 20b in 16GB. This is a first-class publisher quantization. Community GGUF conversions for llama.cpp and Ollama also circulate. Quant type codes have differed between runtimes (for example llama.cpp and Ollama), so verify that a third-party GGUF loads and behaves correctly before production use.

Fine-tuning & adaptation

The Apache-2.0 weights fine-tune with the standard open stack, PEFT/LoRA/QLoRA via transformers and TRL on the safetensors checkpoints, and OpenAI's reference repo (openai/gpt-oss) documents fine-tuning.

Two ceilings apply. The pre-training data and code are not released, so the weights can be fine-tuned and continue-trained but not reproduced from scratch. Fine-tuning can also remove safety behaviour, so re-apply guardrails and re-evaluate any derivative. Placing a derivative on the EU market has provider implications (see Assess).

API / OpenAI-compatible integration

Serve gpt-oss behind vLLM's or Ollama's OpenAI-compatible endpoint for drop-in integration with existing OpenAI-client code.

vllm serve openai/gpt-oss-120b --revision <sha> --port 8000
# Then point any OpenAI SDK at http://localhost:8000/v1.

The one model-specific requirement is the harmony response format. Use the openai/harmony renderer to construct the role hierarchy and channels instead of passing plain role strings. With that in place, routing, retries and gateways carry over unchanged.

How this scores

The ownership factors this domain covers, drawn from the one entry record.

3

ReliabilityIs it reliable and good enough for the job?

Strong

The models run dependably across every major runtime and hosted endpoint, and misuse is well controlled: an independently reviewed worst-case safety study backs the safety tuning.

How this scores (AOI sub-dimensions)
Operational5/5how practical it is to run, serve and maintain in productionEcosystem support is first-class from day 0: safetensors on the verified openai org shipped in native MXFP4, with support across vLLM, llama.cpp, Ollama, Hugging Face transformers and MLX, plus hosted endpoints on major providers.
Safety4/5whether misuse risks are evaluated and guardrails are providedSafety-tuned reasoning releases come with a published safety evaluation, Preparedness-Framework capability testing, and a worst-case malicious-fine-tuning study whose methodology was independently reviewed by external experts (METR, SecureBio, Daniel Kang).
4

Doesn't extract your dataDoes running it keep your knowledge and data yours?

Strong

Self-hosted, the ungated Apache weights run entirely on the deployer's own infrastructure with no clawback or telemetry, so data stays with the deployer.

How this scores
Not a scored AOI dimension. For a self-hosted model, data-control is a structural property of running the weights yourself, strong by default unless the model phones home or the licence claws back rights. For a hosted API this factor is the retention + train-on-inputs + residency read, scored from the binding terms.
What this means for adoptionYou substantially own gpt-oss: ungated Apache-2.0 weights that you run, modify and self-host, governed by a two-sentence usage policy (obey applicable law) that is about as light as an open-weight AUP gets. The safety posture is a differentiator: a published worst-case malicious-fine-tuning study whose methodology METR independently reviewed, with OpenAI at least partially addressing each of METR's six high-urgency items. Transparency holds ownership below full: training data and pre-training code are closed, so the weights can be adapted but not reproduced. Adopt it for general open-weight deployment, building to the harmony response format it requires and adding standard input/output guardrails for customer-facing use.

Sources

The same evidence records as the entry sheet. Read means the text was verified; unverified means it is known to exist but not yet read.

Vendor announcementunverified2026-07-25
OpenAI introduces gpt-oss-120b and gpt-oss-20b as open-weight reasoning models under Apache-2.0 with configurable reasoning effort, native agentic tool use and structured outputs, running on 80GB / 16GB hardware.
Technical_reportread2026-07-25
The gpt-oss-120b & gpt-oss-20b Model Card (arXiv 2508.10925) describes two open-weight reasoning models on an efficient mixture-of-expert transformer architecture, trained with large-scale distillation and reinforcement learning.
Model cardread2026-11-19
gpt-oss weights are hosted on the verified openai organisation on Hugging Face as safetensors under Apache-2.0 with a 128K context window.
Licenceread2026-07-25
The gpt-oss LICENSE is a standard Apache License 2.0 (January 2004) boilerplate with the copyright line left as a template placeholder and no bespoke restrictions in the file itself: unconditional commercial use.
Terms of serviceread2026-07-25
The gpt-oss USAGE_POLICY is complete in two sentences: "We aim for our tools to be used safely, responsibly, and democratically, while maximizing your control over how you use them.
Third-party analysisunverified2026-07-25
Hugging Face's launch guide documents day-0 gpt-oss support across transformers, vLLM, Ollama and llama.cpp, the native MXFP4 quantization, and the harmony format.
Documentationunverified2026-07-25
gpt-oss is trained for OpenAI's harmony response format (role hierarchy and separate reasoning/tool/final channels), rendered via the openai/harmony library.
Securityread2026-07-25
The OpenAI gpt-oss safety report PDF describes adversarial malicious-fine-tuning on bio/cyber data to simulate a worst case (with external reviewers METR, SecureBio, Daniel Kang).
Third-party analysisread2026-07-25
METR's third-party methodology review of OpenAI's gpt-oss malicious-fine-tuning safety work states "OpenAI at least partially addressed each of our 6 high-urgency items," while flagging that no published High-capability criteria exist.
Third-party analysisunverified2026-07-25
gpt-oss ranks strongly among open-weight models on independent public leaderboards.
Documentationunverified2026-07-25
The openai/gpt-oss reference repository provides implementations, serving guidance and fine-tuning references for the open weights.
Model cardread2026-11-19
gpt-oss-safeguard-20b and gpt-oss-safeguard-120b (created 2025-09-18) are separate OpenAI safety-classification fine-tunes of gpt-oss.
Third-party analysisunverified2026-07-25
gpt-oss is available in the Ollama model library for local single-command serving.