On August 5, 2025, OpenAI released gpt-oss-120b and gpt-oss-20b, two open-weight reasoning models under the Apache 2.0 license and the company's first open-weight language models since GPT-2. The larger model fits on a single 80 GB GPU, and the smaller one runs within 16 GB of memory, which puts an OpenAI-trained reasoning model on developer laptops and on-premises servers. For .NET teams, gpt-oss makes it practical to run the same kind of model locally and in the cloud behind one API shape.

Key Facts#

  • Release: August 5, 2025, with weights on Hugging Face, a reference repository on GitHub and a published model card.
  • gpt-oss-120b: 117B total parameters with 5.1B active per token, sized to run on one 80 GB GPU such as an Nvidia H100 or AMD MI300X.
  • gpt-oss-20b: 21B total parameters with 3.6B active, designed to run within 16 GB of memory.
  • License: Apache 2.0, plus a short usage policy that asks users to comply with applicable law.
  • Capabilities: text-only reasoning with configurable effort (low, medium or high), full chain-of-thought access, function calling, web browsing and Python tools, and Structured Outputs.
  • Format: both models were trained on OpenAI's "harmony" response format and only work correctly with it.
  • Performance claim: OpenAI says gpt-oss-120b achieves near-parity with o4-mini on core reasoning benchmarks, and gpt-oss-20b delivers results similar to o3-mini.

What Happened#

Both models are mixture-of-experts (MoE) transformers. According to Hugging Face's launch analysis, they use a 128K-token context with rotary position embeddings, alternate full-context attention layers with 128-token sliding-window layers, and add a learned "attention sink" to each head. They use the same tokenizer as GPT-4o. The key to their small footprint is MXFP4, a 4-bit microscaling format that OpenAI applied to the MoE weights during post-training. OpenAI ran all its published evaluations on those quantized weights, so the numbers describe the files you actually download.

The ecosystem was ready on day one. Hugging Face shipped Transformers support and hosted inference, llama.cpp added native MXFP4 kernels, vLLM provided an OpenAI-compatible server with both the Chat Completions and Responses APIs, and the gpt-oss repository documents ollama pull gpt-oss:20b and LM Studio downloads for consumer hardware. Hugging Face also listed both models in the Azure AI Model Catalog for managed online endpoints.

The models introduced some unusual conventions. Harmony separates a strict "system" message, which holds the date, the model identity and the reasoning effort, from a free-form "developer" message that plays the role most developers associate with system prompts. OpenAI exposes the full chain of thought for debugging and monitoring but says it is not intended to be shown to end users.

Background#

OpenAI had not released the weights of a language model since GPT-2, and for years its most capable reasoning models were available only through its API. Meanwhile, open-weight releases from DeepSeek, Alibaba's Qwen team, Meta and Moonshot AI had set expectations for permissive licensing and strong reasoning in downloadable models. gpt-oss was OpenAI's entry into that market.

The choice of Apache 2.0 is significant. It carries no user thresholds, no naming rules and no regional restrictions, which makes gpt-oss simpler to adopt in enterprises than models under custom community licenses. The models are also explicitly fine-tunable, and OpenAI's reference repository includes reference implementations of the browser and Python tools the models were trained with.

Why It Matters for Developers#

The biggest change is that a hybrid architecture becomes easy. The OpenAI .NET library and Microsoft.Extensions.AI can target OpenAI's hosted models, a local gpt-oss instance and a self-hosted vLLM cluster with the same code. On Windows, Microsoft's Foundry Local can also run gpt-oss-20b behind an OpenAI-compatible REST endpoint powered by ONNX Runtime. That helps with offline scenarios, data-residency requirements and cost control. Our guide to local AI with ONNX Runtime, Ollama and Foundry Local covers the setup options.

Structured Outputs are the other practical win. With IChatClient, you can ask gpt-oss for a typed result and validate it before acting on it:

C#
using Microsoft.Extensions.AI;
using OllamaSharp;

// After `ollama pull gpt-oss:20b`; the 20B model runs within 16 GB of memory.
IChatClient client = new OllamaApiClient(new Uri("http://localhost:11434"), "gpt-oss:20b");

var response = await client.GetResponseAsync<TicketTriage>(
    "Triage this ticket: 'Checkout returns HTTP 500 for all EU customers since 09:10.'");

if (response.TryGetResult(out var triage))
{
    Console.WriteLine($"{triage.Severity}: {triage.Component} ({triage.Summary})");
}

record TicketTriage(string Severity, string Component, string Summary);

A few details are easy to get wrong. Because these are reasoning models, budget generous maximum output lengths. Hugging Face warns that short limits cut answers off mid-reasoning and produce false negatives in evaluations. Strip or hide the reasoning channel before logging or displaying output. Use the effort setting deliberately: low effort for classification and extraction, and high effort only where accuracy justifies the latency. If you bypass a runtime's chat template, you must render harmony prompts yourself, and OpenAI publishes an openai-harmony package for that.

Finally, treat the benchmark comparisons as OpenAI's claims and verify them on your own workloads. Tool calling and structured output quality can vary between runtimes and quantizations, so run a small regression suite, as described in our function-calling guide, whenever you change the serving stack.

What's Next#

Open questions at launch included how well the models would hold up outside OpenAI's own evaluations, how quickly the community would fine-tune them, and whether OpenAI would keep releasing open weights. The models were quickly adopted across local runtimes and cloud catalogs. Microsoft's Edge AI for Beginners course, for example, includes gpt-oss-20b among the models it deploys with Foundry Local, alongside Phi, Qwen and DeepSeek.

For teams building on Azure, the practical path is to prototype locally with gpt-oss-20b and move to a managed endpoint in Azure AI Foundry or a hosted model when scale requires it, without rewriting application code.

Sources#