<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>GPT-OSS &#8211; iAIFeed</title>
	<atom:link href="https://www.iaifeed.com/tag/gpt-oss/feed" rel="self" type="application/rss+xml" />
	<link>https://www.iaifeed.com</link>
	<description>iAIFeed</description>
	<lastBuildDate>Thu, 01 Oct 2026 12:41:12 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.2</generator>

<image>
	<url>https://www.iaifeed.com/wp-content/uploads/2026/07/cropped-iaifeed1-80x80.png</url>
	<title>GPT-OSS &#8211; iAIFeed</title>
	<link>https://www.iaifeed.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>How to Quantize GPT-OSS for Low-VRAM GPUs</title>
		<link>https://www.iaifeed.com/how-to-quantize-gpt-oss-for-low-vram-gpus</link>
					<comments>https://www.iaifeed.com/how-to-quantize-gpt-oss-for-low-vram-gpus#respond</comments>
		
		<dc:creator><![CDATA[iamltlb]]></dc:creator>
		<pubDate>Thu, 01 Oct 2026 12:41:12 +0000</pubDate>
				<category><![CDATA[Blog]]></category>
		<category><![CDATA[GPT-OSS]]></category>
		<guid isPermaLink="false">https://www.iaifeed.com/how-to-quantize-gpt-oss-for-low-vram-gpus</guid>

					<description><![CDATA[Full-precision GPT-OSS will not fit on a consumer GPU. This guide walks through GGUF quantisation levels, what each one actually costs you, and how to serve the quantised model behind an API.]]></description>
										<content:encoded><![CDATA[<p>Running <a href="https://www.iaifeed.com/ai-tool/gpt-oss">GPT-OSS</a> at full precision needs far more VRAM than most people own. Quantising it to GGUF shrinks the 20B model enough to fit an 8GB or 12GB card, and the quality loss at 4-bit is smaller than you would expect.</p>
<h2>What does quantisation actually do to GPT-OSS?</h2>
<p>Quantisation stores the model weights with fewer bits per value. Instead of 16-bit floats you get 4 or 5 bit integers plus a scale factor. A 20B model drops from roughly 40GB of weights to about 11-13GB at Q4_K_M. Inference gets faster too, because memory bandwidth is usually the bottleneck, not raw compute.</p>
<h2>Which GGUF quant should you pick?</h2>
<table>
<tr>
<th>Quant</th>
<th>Approx size</th>
<th>VRAM needed</th>
<th>Quality vs FP16</th>
</tr>
<tr>
<td>Q8_0</td>
<td>~21GB</td>
<td>24GB</td>
<td>Near lossless</td>
</tr>
<tr>
<td>Q6_K</td>
<td>~16GB</td>
<td>20GB</td>
<td>Very slight loss</td>
</tr>
<tr>
<td>Q5_K_M</td>
<td>~14GB</td>
<td>16GB</td>
<td>Barely noticeable</td>
</tr>
<tr>
<td>Q4_K_M</td>
<td>~12GB</td>
<td>12GB</td>
<td>Good default</td>
</tr>
<tr>
<td>Q3_K_M</td>
<td>~9.5GB</td>
<td>10GB</td>
<td>Noticeable on reasoning</td>
</tr>
</table>
<p>Q4_K_M is the sane default. I would not go below Q3_K_M — factual recall and multi-step arithmetic start falling apart, and you paid for a 20B model only to get something closer to a 7B in behaviour.</p>
<h2>How do you serve a quantised GPT-OSS as an API?</h2>
<ol>
<li>Download a GGUF build from a community repo on Hugging Face.</li>
<li>Start llama.cpp&#8217;s server: <code>./llama-server -m gpt-oss-20b-Q4_K_M.gguf -c 8192 -ngl 99 --port 8080</code>.</li>
<li>Point any OpenAI-compatible client at <code>http://localhost:8080/v1</code>.</li>
<li>Set <code>-ngl 99</code> to offload every layer to the GPU; drop it if you run out of VRAM.</li>
</ol>
<p>The context window matters. At 8192 tokens a 12GB card is fine; push to 32K and the KV cache eats several extra gigabytes, which can force layers back onto the CPU and cut speed by half.</p>
<h2>What breaks at low precision?</h2>
<p>Code generation holds up well — most users will not notice. Long chains of logic degrade first, and the model becomes more likely to repeat a phrase when the prompt is ambiguous. If you run agentic loops with tool calls, test at your target quant before shipping; a 4-bit model sometimes malforms JSON arguments where the 8-bit version would not.</p>
<h2>When is quantisation the wrong move?</h2>
<p>If you have a 48GB or 80GB card, just run Q8_0 or the unquantised weights. The speed gain from quantisation mostly disappears once you are not memory-starved, and you avoid the quality gamble entirely. Also skip aggressive quants for anything safety-critical.</p>
<h2>Key Takeaways</h2>
<ul>
<li>Q4_K_M fits GPT-OSS 20B on a 12GB GPU at around 12GB of weights.</li>
<li>Do not drop below Q3_K_M; reasoning quality falls off a cliff.</li>
<li>llama-server exposes an OpenAI-compatible endpoint on localhost.</li>
<li>Watch the KV cache — long contexts can undo your VRAM savings.</li>
<li>Below 48GB of VRAM, quantisation is usually worth it; above it, skip it.</li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://www.iaifeed.com/how-to-quantize-gpt-oss-for-low-vram-gpus/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>How to Run GPT-OSS Locally on Your Own Machine</title>
		<link>https://www.iaifeed.com/how-to-run-gpt-oss-locally-on-your-own-machine</link>
					<comments>https://www.iaifeed.com/how-to-run-gpt-oss-locally-on-your-own-machine#respond</comments>
		
		<dc:creator><![CDATA[iamltlb]]></dc:creator>
		<pubDate>Thu, 01 Oct 2026 12:40:49 +0000</pubDate>
				<category><![CDATA[Blog]]></category>
		<category><![CDATA[GPT-OSS]]></category>
		<guid isPermaLink="false">https://www.iaifeed.com/how-to-run-gpt-oss-locally-on-your-own-machine</guid>

					<description><![CDATA[GPT-OSS is OpenAI's open-weight model family you can download and run offline. Here is how to install it, pick the right size, and get a working local chat in about 15 minutes.]]></description>
										<content:encoded><![CDATA[<p><a href="https://www.iaifeed.com/ai-tool/gpt-oss">GPT-OSS</a> is OpenAI&#8217;s open-weight language model family that you download and run on your own hardware, no API key required. You can have it answering prompts locally in roughly 15 minutes if you already have Python and enough RAM.</p>
<h2>What is GPT-OSS and what sizes does it come in?</h2>
<p>GPT-OSS ships in two main variants: a 20B parameter model and a larger 120B one. Both use a mixture-of-experts design, which means only a slice of the network fires on each token. That keeps the 20B model usable on a single 16GB GPU or a 32GB Mac, while the 120B version realistically wants 80GB+ of VRAM or a beefy multi-GPU rig.</p>
<p>Weights are on Hugging Face under a permissive license, so commercial use is allowed. The catch: no official fine-tuning recipe is bundled, and the safety tuning is lighter than the hosted OpenAI models.</p>
<h2>How do you install GPT-OSS?</h2>
<p>The fastest route is Ollama, then llama.cpp if you want full control.</p>
<ol>
<li>Install Ollama: <code>curl -fsSL https://ollama.com/install.sh | sh</code> on Linux or macOS, or grab the Windows installer.</li>
<li>Pull the small model: <code>ollama pull gpt-oss:20b</code>. Expect about 13GB of download.</li>
<li>Run it: <code>ollama run gpt-oss:20b</code> and type a prompt.</li>
</ol>
<p>On the 20B model I get roughly 35-45 tokens per second on an RTX 4090 at 4-bit quantisation. A 2020 MacBook Air with 8GB will not run it — you need at least 16GB of unified memory, and 32GB feels comfortable.</p>
<h2>Is GPT-OSS free to use?</h2>
<p>Yes. The weights cost nothing and there is no per-token billing. Your real cost is electricity and hardware. That is the whole appeal for teams who cannot send data to a third-party API — legal, medical and defence shops especially.</p>
<p>What you give up: no usage dashboard, no autoscaling, and you own every outage. If your GPU driver updates and breaks CUDA, that is your problem at 2am.</p>
<h2>How does GPT-OSS compare with hosted models?</h2>
<table>
<tr>
<th>Factor</th>
<th>GPT-OSS 20B (local)</th>
<th>Hosted API</th>
</tr>
<tr>
<td>Cost</td>
<td>Hardware only</td>
<td>Per token</td>
</tr>
<tr>
<td>Privacy</td>
<td>Fully offline</td>
<td>Data leaves your network</td>
</tr>
<tr>
<td>Speed</td>
<td>35-45 tok/s on a 4090</td>
<td>Faster, network-bound</td>
</tr>
<tr>
<td>Setup</td>
<td>~15 minutes</td>
<td>An API key</td>
</tr>
</table>
<h2>Who should run GPT-OSS and who should skip it?</h2>
<p>It fits you if data residency matters, if you hit API rate limits constantly, or if you want to experiment without a bill running. Skip it if you need the strongest reasoning available or multi-modal input — the open weights lag the frontier models on hard math and long-context tasks, and there is no vision input here.</p>
<h2>Key Takeaways</h2>
<ul>
<li>GPT-OSS is OpenAI&#8217;s free open-weight model, downloadable and runnable offline.</li>
<li>The 20B variant runs on 16GB VRAM; the 120B wants 80GB+.</li>
<li>Ollama gives you a working local chat in about 15 minutes.</li>
<li>No API cost, but you supply the hardware and the uptime.</li>
<li>Not the right pick if you need true frontier reasoning or vision.</li>
</ul>
]]></content:encoded>
					
					<wfw:commentRss>https://www.iaifeed.com/how-to-run-gpt-oss-locally-on-your-own-machine/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
